0:\\n # padrow.append(0)\\n # padrow2.append(0)\\n # count = count - 1\\n # paddedimg.append(padrow)\\n # for row in img:\\n # newrow = []\\n # newrow.append(0)\\n # paddedimg.append(newrow)\\n #\\n # for pixel in row:\\n # newpixel = pixel\\n # newrow.append(newpixel)\\n # newrow.append(0)\\n # paddedimg.append(padrow2)\\n\\n denoiseimg = img\\n rowcount = -1\\n colcount = -1\\n\\n for row in img:\\n denoiserow = []\\n # denoiseimg.append(denoiserow)\\n rowcount = rowcount + 1\\n colcount = -1\\n for pixel in row:\\n colcount = colcount + 1\\n pixelavg = 0\\n pixelavgcount = 0\\n pixelavg = pixelavg + paddedimg[rowcount ][colcount ]\\n pixelavg = pixelavg + paddedimg[rowcount ][colcount + 1]\\n pixelavg = pixelavg + paddedimg[rowcount ][colcount + 2]\\n pixelavg = pixelavg + paddedimg[rowcount + 1][colcount ]\\n pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 1]\\n pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 2]\\n pixelavg = pixelavg + paddedimg[rowcount + 2][colcount ]\\n pixelavg = pixelavg + paddedimg[rowcount + 2][colcount + 1]\\n pixelavg = pixelavg + paddedimg[rowcount + 2][colcount + 2]\\n # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 1]\\n\\n if paddedimg[rowcount ][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount ][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount ][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 2][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 2][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n\\n\\n pixelavg = pixelavg / pixelavgcount\\n # denoiserow.append(pixelavg)\\n if pixelavg < pixel:\\n denoiseimg[rowcount][colcount] = pixelavg\\n else:\\n denoiseimg[rowcount][colcount] = pixel\\n\\n\\n\\n utils.write_image(denoiseimg,'results/task2_result0.jpg')\\n\\n count = len(img[0])\\n padrow = []\\n padrow2 = []\\n paddedimg = []\\n padrow.append(0)\\n padrow2.append(0)\\n padrow.append(0)\\n padrow2.append(0)\\n while count > 0:\\n padrow.append(0)\\n padrow2.append(0)\\n count = count - 1\\n paddedimg.append(padrow)\\n for row in denoiseimg:\\n newrow = []\\n newrow.append(0)\\n paddedimg.append(newrow)\\n\\n for pixel in row:\\n newpixel = pixel\\n newrow.append(newpixel)\\n newrow.append(0)\\n paddedimg.append(padrow2)\\n\\n denoiseimg2 = img\\n rowcount = -1\\n colcount = -1\\n for row in img:\\n # denoiseimg.append(denoiserow)\\n rowcount = rowcount + 1\\n colcount = -1\\n for pixel in row:\\n colcount = colcount + 1\\n pixelavg = 0\\n pixelavgcount = 0\\n medianarray = []\\n\\n medianarray.append(paddedimg[rowcount ][colcount ])\\n medianarray.append(paddedimg[rowcount ][colcount + 1])\\n medianarray.append( paddedimg[rowcount ][colcount + 2])\\n medianarray.append( paddedimg[rowcount + 1][colcount ])\\n medianarray.append( paddedimg[rowcount + 1][colcount + 1])\\n medianarray.append( paddedimg[rowcount + 1][colcount + 2])\\n medianarray.append( paddedimg[rowcount + 2][colcount ])\\n medianarray.append( paddedimg[rowcount + 2][colcount + 1])\\n medianarray.append( paddedimg[rowcount + 2][colcount + 2])\\n # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 1]\\n\\n if paddedimg[rowcount ][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount ][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount ][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 1][colcount ] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 2][colcount + 1] != 0:\\n pixelavgcount = pixelavgcount + 1\\n if paddedimg[rowcount + 2][colcount + 2] != 0:\\n pixelavgcount = pixelavgcount + 1\\n\\n medianarray.sort()\\n pixelavg = pixelavg / pixelavgcount\\n # denoiserow.append(pixelavg)\\n denoiseimg2[rowcount][colcount] = medianarray[4]\\n\\n # pixelavg = pixelavg + paddedimg[rowcount ][colcount ]\\n # pixelavg = pixelavg + paddedimg[rowcount ][colcount + 1]\\n # pixelavg = pixelavg + paddedimg[rowcount ][colcount + 2]\\n # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount ]\\n # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 1]\\n # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 2]\\n # pixelavg = pixelavg + paddedimg[rowcount + 2][colcount ]\\n # pixelavg = pixelavg + paddedimg[rowcount + 2][colcount + 1]\\n # pixelavg = pixelavg + paddedimg[rowcount + 2][colcount + 2]\\n # # pixelavg = pixelavg + paddedimg[rowcount + 1][colcount + 1]\\n #\\n # if paddedimg[rowcount ][colcount ] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount ][colcount + 1] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount ][colcount + 2] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 1][colcount ] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 1][colcount + 1] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 1][colcount + 2] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 1][colcount ] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 2][colcount + 1] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n # if paddedimg[rowcount + 2][colcount + 2] != 0:\\n # pixelavgcount = pixelavgcount + 1\\n #\\n #\\n # pixelavg = pixelavg / pixelavgcount\\n # # denoiserow.append(pixelavg)\\n # if pixelavg < pixel:\\n # denoiseimg[rowcount][colcount] = pixelavg\\n # else:\\n # denoiseimg[rowcount][colcount] = pixel\\n\\n utils.write_image(denoiseimg2,'results/task2_result2.jpg')\\n return denoiseimg2\\n # cv2.imwrite('results/task2_result.jpg',denoiseimg)\",\n \"def decompress(self, tensors):\",\n \"def filtroBilateral(frame):\\n fb = cv2.bilateralFilter(frame, 0, 32, 2)\\n return fb\",\n \"def decompose(self, *args, **kwargs):\\n return _image.image_decompose(self, *args, **kwargs)\",\n \"def filter(self):\\n self.data = self.data.loc[~self.data.isnull().any(1),:]\",\n \"def use_effect(self):\\n if self.preview_name in FILTERS:\\n photo = Image.open(self.path.url[1:])\\n preview = photo.filter(FILTERS.get(self.preview_name))\\n preview.save(self.path.url[1:])\",\n \"def filter_and_threshold(ctx: Context):\\n if ctx.skin_color is None:\\n return\\n\\n # Soften image\\n cv2.GaussianBlur(ctx.image, (11, 11), 0, ctx.temp_image3)\\n # Denoise\\n cv2.medianBlur(ctx.temp_image3, 11, ctx.temp_image3)\\n\\n # Look for approximated skin color\\n tolerance = (ctx.tolerance / 100) * ctx.skin_variance\\n cv2.inRange(ctx.temp_image3, ctx.skin_color - tolerance, ctx.skin_color + tolerance, ctx.filter_image)\\n\\n cv2.morphologyEx(ctx.filter_image, cv2.MORPH_OPEN, None, ctx.filter_image)\\n cv2.morphologyEx(ctx.filter_image, cv2.MORPH_CLOSE, None, ctx.filter_image)\\n\\n cv2.GaussianBlur(ctx.image, (3, 3), 0, ctx.filter_image)\",\n \"def smooth_mask ( gray , blur = 1 , threshold = 128 ) :\\n\\n assert gray is not None\\n\\n gray_markers = nd.median_filter(gray, blur)\\n _ , gray_markers = cv2.threshold ( gray_markers , threshold , 255 , cv2.THRESH_BINARY )\\n\\n return gray_markers\",\n \"def sharpen(img, ker = (9,9), sigX=10.0):\\n gaus = cv2.GaussianBlur(img, ker, sigX)\\n unsharp = cv2.addWeighted(img, 1.5, gaus, -0.5, 0, img)\\n return unsharp\",\n \"def pipeline(image, plot = False):\\n # undistort image\\n undistorted_image = undistort_image(image)\\n \\n # R&S|sobel-x thresholding\\n _, _, _, _, threshold_image = thresholding(undistorted_image)\\n \\n # yellow mask\\n _, mask_yellow = filter_color(undistorted_image, np.array([20,100,100]), np.array([50,255,255]))\\n \\n # white mask\\n _, mask_white = filter_color(undistorted_image, np.array([0,0,220]), np.array([255,35,255]))\\n \\n # combine yellow and white mask\\n mask = cv2.bitwise_or(mask_yellow, mask_white)\\n comb_image = np.zeros_like(threshold_image)\\n \\n # combine mask and thresholded image\\n comb_image[(mask > 0)&(threshold_image == 1)] = 1\\n \\n # warp the binary image\\n warped_image, Minv = warp(comb_image, src, dst)\\n if plot:\\n plt.figure(2)\\n plt.imshow(warped_image, cmap = \\\"gray\\\")\\n plt.title(\\\"Binary warped image\\\")\\n \\n # calculate polynomial fit\\n left_fitx, right_fitx, ploty, left_curverad, right_curverad, offset = fit_polynomial(warped_image, plot)\\n \\n # superimpose lines on top of the polynomial\\n superimposed_image = mark_lane_lines(undistorted_image, warped_image, ploty, left_fitx, right_fitx, Minv)\\n cv2.putText(superimposed_image, \\\"Left curvature = \\\" + str(np.round(left_curverad, 2)) + \\\" m\\\",(40,40), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Right curvature = \\\" + str(np.round(right_curverad, 2)) + \\\" m\\\",(40,80), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n cv2.putText(superimposed_image,\\\"Offset = \\\" + str(np.round(offset*100, 2)) + \\\" cm\\\",(40,120), \\\\\\n cv2.FONT_HERSHEY_PLAIN, 2, (255,0,0), 2)\\n \\n return superimposed_image\",\n \"def highpass_filter_reset(self, data):\\n zi = scipy.signal.sosfilt_zi(self._highpass_sos)\\n print('Zi shape: ', zi.shape, data.shape)\\n self._highpass_state = data[0, :] * np.repeat(zi[:, :, np.newaxis],\\n data.shape[1], axis=2)\\n logging.info('Resetting the high-pass filter state.')\",\n \"def highPassFilter(img, window=30):\\n gray = grayscale(img)\\n\\tf = np.fft.fft2(gray)\\n\\tfshift = np.fft.fftshift(f)\\n\\trows, cols = gray.shape\\n\\tcrow, ccol = rows/2, cols/2\\n\\tfshift[crow-window:crow+window, ccol-window:ccol+window] = 0\\n\\tf_ishift = np.fft.ifftshift(fshift)\\n\\timg_back = np.fft.ifft2(f_ishift)\\n\\timg_back = np.abs(img_back)\\n\\treturn img_back\",\n \"def unsharp_mask(img, size=3):\\n\\n # apply the averaging filter\\n avg = average(img, size)\\n\\n # subtract the average from the image, for a \\\"diference\\\" mask\\n int_img = np.asarray(img, np.int)\\n diff_mask = int_img - avg\\n\\n # Finally add the mask to the original image\\n sharp = int_img + diff_mask\\n\\n return np.asarray(np.clip(sharp, 0, 255), dtype=np.uint8)\",\n \"def preprocess_obs(obj_data, **kwargs):\\n try: # transform into a pandas DataFrame\\n obj_data = obj_data.to_pandas()\\n except AttributeError: # is it already a pandas DataFrame\\n pass\\n obj_data = cs.rename_passband_column(obj_data)\\n\\n try:\\n do_subtract_background = kwargs[\\\"do_subtract_background\\\"]\\n except KeyError:\\n do_subtract_background = False\\n\\n if do_subtract_background: # estimate a background flux and remove it\\n # from the light curve.\\n preprocessed_obj_data = subtract_background(obj_data)\\n else: # do nothing\\n preprocessed_obj_data = obj_data\\n\\n return preprocessed_obj_data\",\n \"def filter(self, data):\\n filtered = None\\n if not self.matcher:\\n return data, None\\n\\n self.buffer.extend(data)\\n\\n # We'd like to preserve colouring in self.buffer, but allow filtering\\n # for the side channel without control sequences.\\n\\n # Copy the buffer chunks without control sequences\\n buffer_no_cs = bytearray()\\n # Chunks offsets in self.buffer\\n offsets_buffer = []\\n # Corresponding offsets in buffer_no_cs\\n offsets_buffer_no_cs = []\\n # Current offset in self.buffer while iterating over CSEQ.\\n offset = 0\\n for m in re.finditer(self.CSEQ, self.buffer):\\n if m.start() > offset:\\n # Copy over the chunk until a CSEQ start and remember\\n # the offsets\\n offsets_buffer_no_cs.append(len(buffer_no_cs))\\n offsets_buffer.append(offset)\\n buffer_no_cs.extend(self.buffer[offset:m.start()])\\n offset = m.end()\\n # Copy the rest of the buffer into the search buffer buffer_no_cs\\n if offset < len(self.buffer):\\n offsets_buffer_no_cs.append(len(buffer_no_cs))\\n offsets_buffer.append(offset)\\n buffer_no_cs.extend(self.buffer[offset:])\\n\\n # Note that we are scanning over the buffer again and again\\n # if this causes noticeable performance issue, consider maintaining\\n # a smaller part of the buffer to scan.\\n match = self.matcher.search(buffer_no_cs)\\n if match:\\n # We've just found the boundaries of the desired output.\\n self.matcher = None\\n filtered = bytes(buffer_no_cs[:match.end()])\\n # Find corresponding offset in the original buffer to remove\\n # whatever corresponded to the found message.\\n idx = bisect.bisect_left(offsets_buffer_no_cs, match.end())\\n assert idx > 0\\n offset_rest = offsets_buffer[idx-1] + match.end() - offsets_buffer_no_cs[idx-1]\\n output = bytes(self.buffer[offset_rest:])\\n self.buffer = bytearray()\\n return output, filtered\\n return b'', None\",\n \"def deprocess_image(img):\\n # normalize tensor: center on 0., ensure std is 0.1\\n img -= img.mean()\\n img /= (img.std() + 1e-5)\\n img *= 0.1\\n\\n # clip to [0, 1]\\n img += 0.5\\n img = np.clip(img, 0, 1)\\n\\n # convert to RGB array\\n img *= 255\\n\\n # TF image format if channels = (1 or 3) towards the last rank.\\n if img.shape[-1] != 3 and img.shape[-1] != 1:\\n img = img.transpose((1, 2, 0))\\n\\n img = np.clip(img, 0, 255).astype('uint8')\\n return img\",\n \"def compress(filename,threshold,ratio,makeup,attack,release,wout=True,plot=False):\\n start=time.time()\\n if ratio < 1.0:\\n print('Ratio must be > 1.0 for compression to occur! You are expanding.')\\n if ratio==1.0:\\n print('Signal is unaffected.')\\n n, data, data_dB,sr,ch=inputwav(filename)\\n #Array for the compressed data in dB\\n dataC=data_dB.copy()\\n #attack and release time constant\\n a=np.exp(-np.log10(9)/(44100*attack*1.0E-3))\\n re=np.exp(-np.log10(9)/(44100*release*1.0E-3))\\n #apply compression\\n print('Compressing...')\\n for k in range(ch):\\n for i in range (n):\\n if dataC[i,k]>threshold:\\n dataC[i,k]=threshold+(dataC[i,k]-threshold)/(ratio)\\n #gain and smooth gain initialization\\n gain=np.zeros(n)\\n sgain=np.zeros(n)\\n #calculate gain\\n gain=np.subtract(dataC,data_dB)\\n sgain=gain.copy()\\n #smoothen gain\\n print('Smoothing...')\\n for k in range(ch):\\n for i in range (1,n):\\n if sgain[i-1,k]>=sgain[i,k]:\\n sgain[i,k]=a*sgain[i-1,k]+(1-a)*sgain[i,k]\\n if sgain[i-1,k]<sgain[i,k]:\\n sgain[i,k]=re*sgain[i-1,k]+(1-re)*sgain[i,k] \\n #Array for the smooth compressed data with makeup gain applied\\n dataCs=np.zeros(n)\\n dataCs=data_dB+sgain+makeup\\n #Convert our dB data back to bits\\n dataCs_bit=10.0**((dataCs)/20.0)\\n #sign the bits appropriately:\\n for k in range (ch):\\n for i in range (n):\\n if data[i,k]<0.0:\\n dataCs_bit[i,k]=-1.0*dataCs_bit[i,k]\\n #Plot the data:\\n if plot==True:\\n print('Plotting...')\\n t=np.linspace(0,n/(1.0*sr),n)\\n py.close()\\n fig, (ax1, ax2) = py.subplots(nrows=2) \\n ax2.plot(t,gain,'k-',linewidth=0.1,label='Gain Reduction')\\n ax2.plot(t,sgain,'r-',linewidth=1, label='Gain Reduction Smooth')\\n ax1.plot(t,data,'k-',linewidth=1,label=filename)\\n ax1.plot(t,dataCs_bit,'m-',linewidth=0.1,\\n label=filename+' compressed')\\n ax1.axhline(10**(threshold/20.0),linestyle='-',\\n color='cyan',linewidth=1)\\n ax1.axhline(-10**(threshold/20.0),linestyle='-',\\n color='cyan',linewidth=1)\\n ax1.legend()\\n ax2.legend()\\n ax2.set_xlabel('Time (s)')\\n ax2.set_ylabel('Gain Reduction (dB)')\\n ax1.set_ylabel('Amplitude (Rel. Bit)')\\n ax1.set_xlabel('Time (s)')\\n #write data to 16 bit file\\n if wout==True:\\n print('Exporting...')\\n sf.write(filename[0:len(filename)-4]+'_compressed.wav',dataCs_bit,\\n sr,'PCM_16')\\n end=time.time()\\n elapsed=int(1000*(end-start))\\n print('Done!')\\n print('...............................')\\n print('Completed in '+str(elapsed)+' milliseconds.') \\n return dataCs,dataCs_bit\",\n \"def process_mask(self, image):\\n image = np.array(image)\\n image[image == 5] = 1 # set un-classified to undestroyed\\n return Image.fromarray(image)\",\n \"def amplifyTemporalColorSignal(originalPyr, filteredVideoPyr, alpha, chromAttenuation): \\n amplifiedPyr=[]\\n \\n for layer in range(len(filteredVideoPyr)):\\n tensor = originalPyr[layer].copy()\\n if layer==len(filteredVideoPyr)-1:\\n tensor[:,:,:,0] += filteredVideoPyr[layer][:,:,:,0] * alpha\\n tensor[:,:,:,1] += filteredVideoPyr[layer][:,:,:,1] * alpha * chromAttenuation\\n tensor[:,:,:,2] += filteredVideoPyr[layer][:,:,:,2] * alpha * chromAttenuation\\n \\n amplifiedPyr.append(tensor)\\n \\n return amplifiedPyr\",\n \"def image_preprocessing(img):\\n\\n # Removing parasite data (sky, trees and front of the car)\\n return img[60:-20, :, :]\",\n \"def filter_array(image: Image, filter_id: str) -> Image:\\n \\n if filter_id == \\\"3\\\":\\n image = three_tone(image,\\\"aqua\\\",\\\"blood\\\",\\\"lemon\\\")\\n elif filter_id == \\\"X\\\":\\n image = extreme_contrast(image)\\n elif filter_id == \\\"T\\\":\\n image = sepia_filter(image)\\n elif filter_id == \\\"P\\\":\\n image = posterize(image)\\n elif filter_id == \\\"E\\\":\\n image = detect_edges(image,15)\\n elif filter_id == \\\"V\\\":\\n image = flip_vertical(image)\\n elif filter_id == \\\"H\\\":\\n image = flip_horizontal(image)\\n \\n return image\",\n \"def noiseReduction(self):\\n pass\",\n \"def filterWithSITK(self):\\r\\n # research\\r\\n profbox()\\r\\n backgroundNode = slicer.app.layoutManager().sliceWidget(\\\"Red\\\").sliceLogic().GetBackgroundLayer().GetVolumeNode()\\r\\n backgroundNodeName = backgroundNode.GetName()\\r\\n backgroundImage = sitk.ReadImage(sitkUtils.GetSlicerITKReadWriteAddress(backgroundNodeName))\\r\\n filterImage = sitk.GradientMagnitudeRecursiveGaussian(backgroundImage, float(2));\\r\\n del backgroundImage\\r\\n sitk.WriteImage(filterImage, sitkUtils.GetSlicerITKReadWriteAddress(backgroundNodeName))\\r\\n\\r\\n # notify\\r\\n backgroundNode.GetImageData().Modified()\\r\\n backgroundNode.Modified()\",\n \"def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\\n orig_scene = orig.copy()\\n mask_scene = mask.copy()\\n orig_scene_no_mask = orig.copy()\\n \\n mask_info = np.where(mask_scene == 0) \\n min_x = max(min(mask_info[0]) - local_context_size, 0)\\n max_x = max(mask_info[0]) + local_context_size\\n min_y = max(min(mask_info[1]) - local_context_size, 0)\\n max_y = max(mask_info[1]) + local_context_size\\n \\n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\\n \\n dialation_mask = np.zeros(mask_scene.shape) + 255\\n \\n if dilation:\\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\\n \\n #implot(dialation_mask)\\n #plt.imshow(dialation_mask, 'gray')\\n \\n for x in range(mask_scene.shape[0]):\\n for y in range(mask_scene.shape[1]):\\n if mask_scene[x, y] == 0:\\n orig_scene[x, y, :] = 0\\n orig_scene_no_mask[x,y,:] = 0\\n if dilation:\\n if dialation_mask[x,y] == 0:\\n orig_scene[x, y, :] = 0\\n \\n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask\",\n \"def removeAutoSaveFilter(filter):\",\n \"def cube_fix_badpix_annuli(array, fwhm, cy=None, cx=None, sig=5., \\n protect_mask=0, r_in_std=50, r_out_std=None,\\n verbose=True, half_res_y=False, min_thr=None, \\n max_thr=None, full_output=False):\\n\\n obj_tmp = array.copy()\\n ndims = obj_tmp.ndim\\n assert ndims == 2 or ndims == 3, \\\"Object is not two or three dimensional.\\\\n\\\"\\n\\n #thresholds\\n if min_thr is None:\\n min_thr = np.amin(obj_tmp)-1\\n if max_thr is None:\\n max_thr = np.amax(obj_tmp)-1\\n\\n def bp_removal_2d(obj_tmp, cy, cx, fwhm, sig, protect_mask, r_in_std,\\n r_out_std, verbose):\\n\\n n_x = obj_tmp.shape[1]\\n n_y = obj_tmp.shape[0]\\n\\n # Squash the frame if twice less resolved vertically than horizontally\\n if half_res_y:\\n if n_y % 2 != 0:\\n msg = 'The input frames do not have of an even number of rows. '\\n msg2 = 'Hence, you should not use option half_res_y = True'\\n raise ValueError(msg+msg2)\\n n_y = int(n_y/2)\\n cy = int(cy/2)\\n frame = obj_tmp.copy()\\n obj_tmp = np.zeros([n_y,n_x])\\n for yy in range(n_y):\\n obj_tmp[yy] = frame[2*yy]\\n\\n #1/ Stddev of background \\n if r_in_std or r_out_std:\\n r_in_std = min(r_in_std*fwhm,cx-2, cy-2,n_x-cx-2,n_y-cy-2)\\n if r_out_std:\\n r_out_std *= fwhm\\n else:\\n r_out_std = min(n_y-(cy+r_in_std), cy-r_in_std, \\n n_x-(cx+r_in_std), cx-r_in_std)\\n ceny, cenx = frame_center(obj_tmp)\\n width = max(2,r_out_std-r_in_std)\\n obj_tmp_crop = get_annulus_segments(obj_tmp, r_in_std, width, \\n mode=\\\"val\\\")\\n else:\\n obj_tmp_crop = obj_tmp\\n _, _, stddev = sigma_clipped_stats(obj_tmp_crop, sigma=2.5)\\n\\n #2/ Define each annulus, its median and stddev\\n \\n ymax = max(cy, n_y-cy)\\n xmax = max(cx, n_x-cx)\\n if half_res_y:\\n ymax *= 2\\n rmax = np.sqrt(ymax**2+xmax**2)\\n # the annuli definition is optimized for Airy rings\\n ann_width = max(1.5, 0.5*fwhm) #0.61*fwhm\\n nrad = int(rmax/ann_width)+1\\n d_bord_max = max(n_y-cy, cy, n_x-cx, cx)\\n if half_res_y:\\n d_bord_max = max(2*(n_y-cy), 2*cy, n_x-cx, cx)\\n\\n big_ell_frame = np.zeros_like(obj_tmp)\\n sma_ell_frame = np.zeros_like(obj_tmp)\\n ann_frame_cumul = np.zeros_like(obj_tmp)\\n n_neig = np.zeros(nrad, dtype=np.int16)\\n med_neig = np.zeros(nrad)\\n std_neig = np.zeros(nrad)\\n neighbours = np.zeros([nrad,n_y*n_x])\\n\\n for rr in range(nrad):\\n if rr > int(d_bord_max/ann_width):\\n # just to merge farthest annuli with very few elements \\n rr_big = nrad \\n rr_sma = int(d_bord_max/ann_width)\\n else: \\n rr_big = rr\\n rr_sma= rr\\n if half_res_y:\\n big_ell_idx = ellipse(r=cy, c=cx, \\n r_radius=((rr_big+1)*ann_width)/2, \\n c_radius=(rr_big+1)*ann_width, \\n shape=(n_y,n_x))\\n if rr != 0:\\n small_ell_idx = ellipse(r=cy, c=cx, \\n r_radius=(rr_sma*ann_width)/2, \\n c_radius=rr_sma*ann_width, \\n shape=(n_y,n_x))\\n else:\\n big_ell_idx = disk((cy, cx), radius=(rr_big+1)*ann_width,\\n shape=(n_y,n_x))\\n if rr != 0:\\n small_ell_idx = disk((cy, cx), radius=rr_sma*ann_width, \\n shape=(n_y,n_x))\\n big_ell_frame[big_ell_idx] = 1\\n if rr!=0: sma_ell_frame[small_ell_idx] = 1\\n ann_frame = big_ell_frame - sma_ell_frame\\n n_neig[rr] = ann_frame[np.where(ann_frame)].shape[0]\\n neighbours[rr,:n_neig[rr]] = obj_tmp[np.where(ann_frame)]\\n ann_frame_cumul[np.where(ann_frame)] = rr\\n\\n # We delete iteratively max and min outliers in each annulus, \\n # so that the annuli median and stddev are not corrupted by bpixs\\n neigh = neighbours[rr,:n_neig[rr]]\\n n_rm = 0\\n n_pix_init = neigh.shape[0]\\n while neigh.shape[0] >= np.amin(n_neig[rr]) and n_rm < n_pix_init/5:\\n min_neigh = np.amin(neigh)\\n if reject_outliers(neigh, min_neigh, m=5, stddev=stddev):\\n min_idx = np.argmin(neigh)\\n neigh = np.delete(neigh,min_idx)\\n n_rm += 1\\n else:\\n max_neigh = np.amax(neigh)\\n if reject_outliers(neigh, max_neigh, m=5, stddev=stddev):\\n max_idx = np.argmax(neigh)\\n neigh = np.delete(neigh,max_idx)\\n n_rm += 1\\n else: break\\n n_neig[rr] = neigh.shape[0]\\n neighbours[rr,:n_neig[rr]] = neigh\\n neighbours[rr,n_neig[rr]:] = 0\\n med_neig[rr] = np.median(neigh)\\n std_neig[rr] = np.std(neigh)\\n \\n #3/ Create a tuple-array with coordinates of a circle of radius 1.8*fwhm\\n # centered on the provided coordinates of the star\\n if protect_mask:\\n if half_res_y: \\n circl_new = ellipse(cy, cx, r_radius=protect_mask/2., \\n c_radius=protect_mask, shape=(n_y,n_x))\\n else: \\n circl_new = disk((cy, cx), radius=protect_mask, \\n shape=(n_y, n_x))\\n else: circl_new = []\\n\\n #4/ Loop on all pixels to check bpix\\n bpix_map = np.zeros_like(obj_tmp)\\n obj_tmp_corr = obj_tmp.copy()\\n obj_tmp_corr, bpix_map = correct_ann_outliers(obj_tmp, ann_width, sig, \\n med_neig, std_neig, cy, \\n cx, min_thr, max_thr, \\n stddev, half_res_y)\\n\\n #5/ Count bpix and uncorrect if within the circle\\n nbpix_tot = np.sum(bpix_map)\\n nbpix_tbc = nbpix_tot - np.sum(bpix_map[circl_new])\\n bpix_map[circl_new] = 0\\n obj_tmp_corr[circl_new] = obj_tmp[circl_new]\\n if verbose:\\n print(nbpix_tot, ' bpix in total, and ', nbpix_tbc, ' corrected.')\\n\\n # Unsquash all the frames\\n if half_res_y:\\n frame = obj_tmp_corr.copy()\\n frame_bpix = bpix_map.copy()\\n n_y = 2*n_y\\n obj_tmp_corr = np.zeros([n_y,n_x])\\n bpix_map = np.zeros([n_y,n_x])\\n ann_frame = ann_frame_cumul.copy()\\n ann_frame_cumul = np.zeros([n_y,n_x])\\n for yy in range(n_y):\\n obj_tmp_corr[yy] = frame[int(yy/2)]\\n bpix_map[yy] = frame_bpix[int(yy/2)]\\n ann_frame_cumul[yy] = ann_frame[int(yy/2)]\\n\\n return obj_tmp_corr, bpix_map, ann_frame_cumul\\n\\n\\n if cy is None or cx is None:\\n cy, cx = frame_center(obj_tmp)\\n if ndims == 2:\\n obj_tmp, bpix_map, ann_frame_cumul = bp_removal_2d(obj_tmp, cy, cx, \\n fwhm, sig, \\n protect_mask, \\n r_in_std, r_out_std,\\n verbose)\\n if ndims == 3:\\n n_z = obj_tmp.shape[0]\\n bpix_map = np.zeros_like(obj_tmp)\\n ann_frame_cumul = np.zeros_like(obj_tmp)\\n if isinstance(fwhm, (int,float)):\\n fwhm = [fwhm]*n_z\\n if isinstance(cy, (float,int)) and isinstance(cx, (float,int)): \\n cy = [cy]*n_z\\n cx = [cx]*n_z\\n for i in range(n_z):\\n if verbose:\\n print('************Frame # ', i,' *************')\\n print('centroid assumed at coords:',cx[i],cy[i]) \\n res_i = bp_removal_2d(obj_tmp[i], cy[i], cx[i], fwhm[i], sig,\\n protect_mask, r_in_std, r_out_std, verbose)\\n obj_tmp[i], bpix_map[i], ann_frame_cumul[i] = res_i\\n \\n if full_output:\\n return obj_tmp, bpix_map, ann_frame_cumul\\n else:\\n return obj_tmp\",\n \"def augment_img(img):\\n img = random_hflip_img(img)\\n img = cutout_img(img, size=12)\\n img = zero_pad_and_crop_img(img)\\n return img\",\n \"def applyBackwardNoDataFilter(image, bandNames):\\n #Get a list of band names to iterate over, from year(-2) through year(0)\\n bandNamesEE = ee.List(bandNames[:-1]).reverse()\\n \\n #Define backwards filter\\n #In first iteration, bandName=bandNames[-2] and followingImage is image.select(bandNames[-1]), or the classifications for the final year\\n #currentImage = image.select(bandNames[-2]), the second to last year\\n #followingImage = image.select(bandNames[-1]), the final year\\n #Find where the second to last year has missing data, replace those values with the values of the following year\\n #Append followingImage to currentImage, so now currentImage is a two band image, with the first band being the second to last year with the gap fill\\n #and the second band is the final years classification\\n #The iteration continues, now with followingImage.select[0] being the second to last year with the gap fill applied, and bandName is the third to last year\\n def backwardNoDataFilter(bandName, followingImage):\\n currentImage = image.select(ee.String(bandName))\\n followingImage = ee.Image(followingImage)\\n currentImage = currentImage.unmask(followingImage.select([0]))\\n return currentImage.addBands(followingImage)\\n \\n #Apply backwards filter, starting with the final year and iterating through to year(0) \\n filtered = bandNamesEE.iterate(backwardNoDataFilter,ee.Image(image.select(bandNames[-1])))\\n #Re-order bands to be in chronological order\\n filtered = ee.Image(filtered)\\n return filtered.select(bandNames)\",\n \"def color_jitter(self, img):\\n # define filter not to distort the background\\n filt = (img != 0)\\n \\n a = np.random.uniform(0.5, 1.5)\\n b = np.random.uniform(-100, 100)\\n img = (a * img + b).astype(np.int64)\\n img = np.clip(img, 0, 255)\\n img *= filt\\n\\n return img\",\n \"def remove_transparency(image):\\n new_image = Image.new(\\\"RGBA\\\", image.size, \\\"WHITE\\\")\\n new_image.paste(image, (0, 0), image)\\n new_image.convert('RGB')\\n return new_image\",\n \"def _gap_filter(self):\\n res = self.cfg.resolution\\n xedges = np.linspace(self.lrx[0]-res/2., self.lrx[-1]+res/2.0, len(self.lrx)+1)\\n yedges = np.linspace(self.lry[0]-res/2., self.lry[-1]+res/2.0, len(self.lry)+1)\\n\\n # Calculates point density of als shots per DEM grid cell\\n self.rzhist, xe, ye = np.histogram2d(self.x[self.nonan].flatten(),\\n self.y[self.nonan].flatten(),\\n bins=[xedges, yedges])\\n self.rzhist = self.rzhist.transpose()\\n data_mask = self.rzhist > 0.0\\n\\n filter_algorithm = self.cfg.gap_filter[\\\"algorithm\\\"]\\n if filter_algorithm == \\\"maximum_filter\\\":\\n data_mask = maximum_filter(data_mask, **self.cfg.gap_filter[\\\"keyw\\\"])\\n else:\\n raise NotImplementedError(\\\"Filter algorithm: %s\\\" % filter_algorithm)\\n\\n self.dem_mask = ~data_mask\",\n \"def waveletdenoise_2d(img,threshold,wavelet='coif1',mode='soft',level=3,smooth=False):\\n\\n w=pywt.Wavelet(wavelet)\\n #----- decompose\\n # nlevel = int( floor( log2(img.shape[0]) ) ) # 5\\n coeffs = pywt.wavedec2(img, w, level=level)\\n\\n #----- threshold denoising - soft\\n coeffs_new=threshold_wcoeffs(coeffs,threshold,mode=mode)\\n if smooth:\\n coeffs_new=smooth_wcoeffs(coeffs_new,order=1)\\n\\n img_new = pywt.waverec2(coeffs_new, wavelet=w)\\n\\n # optional plotting:\\n # plotsave_img(img_new, directory+'img'+operation+suffix)\\n # plot_coeffs(coeffs_new, directory+'coeff'+operation+suffix)\\n\\n return img_new\",\n \"def remove_shadow(self):\\n #Separate the RGB\\n rgb_planes = cv.split(self.frame)\\n\\n result_norm_planes = []\\n #Go through the planes, get a dilated image and a blur image, then get the difference between the two images, then normalize the final image\\n for plane in rgb_planes:\\n dilated_img = cv.dilate(plane, np.ones((7,7), np.uint8))\\n bg_img = cv.medianBlur(dilated_img, 21)\\n diff_img = 255 - cv.absdiff(plane, bg_img)\\n norm_img = cv.normalize(diff_img,None, alpha=0, beta=255, norm_type=cv.NORM_MINMAX, dtype=cv.CV_8UC1)\\n result_norm_planes.append(norm_img)\\n\\n result_norm = cv.merge(result_norm_planes)\\n\\n self.frame = result_norm\",\n \"def _xfilter(self, rgba, data):\\n ii = np.logical_and(0 <= data, data <= 1)\\n jj = self._xcolor > 0\\n c = self._xcolor[np.newaxis, jj]\\n jj = np.append(jj, np.tile(False, 4 - len(jj)))\\n kk = np.ix_(ii, jj)\\n if self._method == 'vec':\\n f = np.sqrt(np.sum((rgba[kk] * c)**2, axis = 1) / np.sum(c**2))\\n elif self._method == 'min':\\n f = np.min(rgba[kk] / c, axis = 1) * np.max(c)\\n f *= self._func(data[ii])\\n rgba[kk] -= f[:, np.newaxis] * c\\n if self._clip:\\n rgba[kk] = np.clip(rgba[kk], 0, 1)\\n return rgba\",\n \"def preprocess_pipeline(self):\\n if self.trim_size > 0:\\n self.df = trim_initial_timeseries(\\n df=self.df,\\n trim_size=self.trim_size,\\n aornums=self.df.aornum.unique()\\n )\\n\\n if self.timebinsize > 0:\\n med_df, std_df = bin_df_time(self.df, timebinsize=self.timebinsize)\\n\\n # Option 1\\n self.df = med_df.copy()\\n\\n \\\"\\\"\\\"\\n # Option 2\\n self.df = med_df.copy()\\n for colname in df.columns:\\n if 'noise' in colname:\\n std_colname = colname.replace('noise', 'flux')\\n self.df[colname] = std_df[std_colname]\\n \\\"\\\"\\\"\\n\\n del med_df, std_df\\n\\n if self.df is None:\\n tso_data = load_from_wanderer(\\n planet_name=self.planet_name,\\n channel=self.channel,\\n aor_dir=self.aor_dir,\\n aper_key='gaussian_fit_annular_mask_rad_2.5_0.0',\\n centering_key=self.centering_key\\n )\\n else:\\n tso_data = load_from_df(\\n self.df,\\n aper_key=self.aper_key,\\n centering_key=self.centering_key\\n )\\n\\n isfinite = np.isfinite(tso_data.times)\\n isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.fluxes))\\n isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.flux_errs))\\n # isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.aornums))\\n isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.ycenters))\\n isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.xcenters))\\n isfinite = np.bitwise_and(isfinite, np.isfinite(tso_data.npix))\\n\\n times = tso_data.times[isfinite]\\n fluxes = tso_data.fluxes[isfinite]\\n flux_errs = tso_data.flux_errs[isfinite]\\n aornums = tso_data.aornums[isfinite]\\n ycenters = tso_data.ycenters[isfinite]\\n xcenters = tso_data.xcenters[isfinite]\\n npix = tso_data.npix[isfinite]\\n\\n med_flux = np.median(fluxes)\\n flux_errs = flux_errs / med_flux\\n fluxes = fluxes / med_flux\\n\\n arg_times = times.argsort()\\n fluxes = fluxes[arg_times]\\n flux_errs = flux_errs[arg_times]\\n aornums = aornums[arg_times]\\n times = times[arg_times]\\n ycenters = ycenters[arg_times]\\n xcenters = xcenters[arg_times]\\n npix = npix[arg_times]\\n\\n if self.standardise_centers:\\n # Center by assuming eclipse is near center\\n ycenter = (ycenter - ycenter.mean()) / ycenter.std()\\n xcenter = (xcenter - xcenter.mean()) / xcenter.std()\\n\\n if self.standardise_times:\\n # Center by assuming eclipse is near center\\n times = times - times.mean()\\n\\n if self.standardise_fluxes:\\n # Center by assuming eclipse is near center\\n med_flux = np.median(fluxes)\\n std_flux = scale.mad(fluxes)\\n\\n idxkeep = np.abs(fluxes - med_flux) < self.n_sig * std_flux\\n\\n self.tso_data = ExoplanetTSOData(\\n times=times[idxkeep],\\n fluxes=fluxes[idxkeep],\\n flux_errs=flux_errs[idxkeep],\\n aornums=aornums[idxkeep],\\n ycenters=ycenters[idxkeep],\\n xcenters=xcenters[idxkeep],\\n npix=npix[idxkeep]\\n )\\n\\n # # TODO: Confirm if this is still required\\n # self.tso_data.times = self.tso_data.times\\n # self.tso_data.fluxes = self.tso_data.fluxes\\n # self.tso_data.flux_errs = self.tso_data.flux_errs\\n # self.tso_data.aornums = self.tso_data.aornums\",\n \"def filter_isolated_pixels(array):\\n filtered_array = np.copy(array)\\n id_regions, num_ids = ndimage.label(filtered_array,\\n structure=np.ones((3, 3)))\\n id_sizes = np.array(ndimage.sum(array, id_regions, range(num_ids+1)))\\n area_mask = (id_sizes == 1)\\n filtered_array[area_mask[id_regions]] = 0\\n return filtered_array\",\n \"def _monochrome(self):\\r\\n\\r\\n self.img = self.img.convert('L')\\r\\n self.img = Image.eval(self.img, lambda a: 0 if a <= MONOWEIGHT else 255)\",\n \"def _pre_filter_decode(self):\\n\\n pass\",\n \"def pwgrwlfilter(self):\\n return None\",\n \"def _imfilter(x_data, f_data):\\n return pipe(f_data, ifftshift, fftn, lambda x: x * fftn(x_data), ifftn).real\",\n \"def apply_filter(image: np.ndarray) -> np.ndarray:\\n # choose filters to apply\\n return clahe(image)\",\n \"def filter_spectrum(spectrum):\\n # avoid division by 0\\n spectrum.hs[1:] /= spectrum.fs[1:]\\n spectrum.hs[0] = 0\",\n \"def filter_img(inarr, data_resolution):\\n outt = inarr.copy()\\n print('outmin', np.nanmin(outt), np.nanmax(outt))\\n\\n t_thresh_size = -40\\n t_thresh_cut = -50\\n\\n outt[outt >= t_thresh_size] = 0\\n outt[np.isnan(outt)] = 0\\n\\n labels, numL = label(outt)\\n\\n u, inv = np.unique(labels, return_inverse=True)\\n n = np.bincount(inv)\\n\\n pix_nb = 700/data_resolution**2\\n\\n badinds = u[(n < pix_nb)]\\n # all blobs with more than 1000 pixels = 25,000km2 (meteosat regridded 5km), 200pix = 5000km2, 8pix = 200km2\\n # scale 30km, radius 15km ca. 700km2 circular area equals 28 pix\\n\\n for bi in badinds:\\n inds = np.where(labels == bi)\\n outt[inds] = 0\\n\\n outt[outt >= t_thresh_cut] = 150\\n\\n grad = np.gradient(outt)\\n outt[outt == 150] = np.nan\\n\\n nogood = np.isnan(outt) # filters edge maxima later, no maxima in -40 edge area by definition!\\n\\n # tdiff = np.nanmax(outt) - np.nanmin(outt) # define background temperature for image\\n # if tdiff > 28: # temp difference of 28 degrees\\n # xmin = 15\\n # else:\\n # xmin = 10\\n\\n xmin = 10\\n outt[nogood] = t_thresh_cut - xmin\\n nok = np.where(abs(grad[0]) > 80)\\n d = 2\\n i = nok[0]\\n j = nok[1]\\n # edge smoothing for wavelet application\\n for ii, jj in zip(i, j):\\n kern = outt[ii - d:ii + d + 1, jj - d:jj + d + 1]\\n outt[ii - d:ii + d + 1, jj - d:jj + d + 1] = ndimage.gaussian_filter(kern, 3, mode='nearest')\\n\\n return outt, nogood, t_thresh_size, t_thresh_cut, pix_nb\",\n \"def image_pre_filtering(left_img: np.ndarray, right_img: np.ndarray) -> tuple:\\n\\n def clahe(image: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Apply Contrast Limited Adaptive Histogram Equalization\\n :param image: the image to be filtered\\n :return: the image filtered with CLAHE\\n \\\"\\\"\\\"\\n clahe_filter = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))\\n return clahe_filter.apply(image)\\n\\n def logarithmic(image: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Apply Logarithmic Transform\\n :param image: the image to be filtered\\n :return: the image filtered with logarithmic transform\\n \\\"\\\"\\\"\\n c = max_disparity / math.log(1 + np.max(image))\\n sigma = 1\\n for i in range(0, image.shape[1]): # image width\\n for j in range(0, image.shape[0]): # image height\\n # compute logarithmic transform\\n image[j, i] = int(c * math.log(1 + ((math.exp(sigma) - 1) * image[j, i])))\\n return image\\n\\n def exponential(image: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Perform pre-processing - raise to the power, as this subjectively appears\\n to improve subsequent disparity calculation\\n :param image:\\n :return:\\n \\\"\\\"\\\"\\n return np.power(image, 0.75).astype('uint8')\\n\\n def apply_filter(image: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Choose which filter to apply to both images, this could be a combination too\\n :param image: the image to be filtered\\n :return:\\n \\\"\\\"\\\"\\n # choose filters to apply\\n return clahe(image)\\n\\n return apply_filter(left_img), apply_filter(right_img)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5940264","0.57888854","0.56609976","0.5598279","0.5571579","0.5547801","0.5547801","0.55289155","0.5483978","0.54816383","0.5425529","0.54046345","0.5402441","0.5388734","0.53727907","0.53614545","0.5357019","0.5333438","0.5318575","0.5286538","0.5277749","0.52689","0.52584684","0.5242493","0.5241647","0.5221419","0.5216327","0.51955026","0.51884335","0.51801425","0.51653814","0.5164892","0.5156967","0.51516443","0.514899","0.51484555","0.51351506","0.5126244","0.51191276","0.51030576","0.50951314","0.5086121","0.5081573","0.50808096","0.5079448","0.50781226","0.50520134","0.5047448","0.50400454","0.50250274","0.50163513","0.501001","0.5007694","0.49998283","0.49945983","0.4990162","0.49817407","0.49786887","0.49767157","0.49703878","0.4969671","0.4956032","0.49452886","0.49440324","0.49405697","0.49403468","0.49389005","0.49369827","0.49361837","0.49337527","0.4928545","0.49123573","0.49065024","0.4900053","0.48989233","0.48925662","0.48865756","0.48786324","0.48780265","0.487496","0.4873615","0.48703432","0.48694193","0.4866449","0.48589942","0.48581108","0.4856055","0.48538634","0.48537773","0.48373544","0.48346844","0.48321015","0.48295954","0.48295173","0.48293662","0.48214215","0.48200068","0.4815323","0.48146275","0.48123088"],"string":"[\n \"0.5940264\",\n \"0.57888854\",\n \"0.56609976\",\n \"0.5598279\",\n \"0.5571579\",\n \"0.5547801\",\n \"0.5547801\",\n \"0.55289155\",\n \"0.5483978\",\n \"0.54816383\",\n \"0.5425529\",\n \"0.54046345\",\n \"0.5402441\",\n \"0.5388734\",\n \"0.53727907\",\n \"0.53614545\",\n \"0.5357019\",\n \"0.5333438\",\n \"0.5318575\",\n \"0.5286538\",\n \"0.5277749\",\n \"0.52689\",\n \"0.52584684\",\n \"0.5242493\",\n \"0.5241647\",\n \"0.5221419\",\n \"0.5216327\",\n \"0.51955026\",\n \"0.51884335\",\n \"0.51801425\",\n \"0.51653814\",\n \"0.5164892\",\n \"0.5156967\",\n \"0.51516443\",\n \"0.514899\",\n \"0.51484555\",\n \"0.51351506\",\n \"0.5126244\",\n \"0.51191276\",\n \"0.51030576\",\n \"0.50951314\",\n \"0.5086121\",\n \"0.5081573\",\n \"0.50808096\",\n \"0.5079448\",\n \"0.50781226\",\n \"0.50520134\",\n \"0.5047448\",\n \"0.50400454\",\n \"0.50250274\",\n \"0.50163513\",\n \"0.501001\",\n \"0.5007694\",\n \"0.49998283\",\n \"0.49945983\",\n \"0.4990162\",\n \"0.49817407\",\n \"0.49786887\",\n \"0.49767157\",\n \"0.49703878\",\n \"0.4969671\",\n \"0.4956032\",\n \"0.49452886\",\n \"0.49440324\",\n \"0.49405697\",\n \"0.49403468\",\n \"0.49389005\",\n \"0.49369827\",\n \"0.49361837\",\n \"0.49337527\",\n \"0.4928545\",\n \"0.49123573\",\n \"0.49065024\",\n \"0.4900053\",\n \"0.48989233\",\n \"0.48925662\",\n \"0.48865756\",\n \"0.48786324\",\n \"0.48780265\",\n \"0.487496\",\n \"0.4873615\",\n \"0.48703432\",\n \"0.48694193\",\n \"0.4866449\",\n \"0.48589942\",\n \"0.48581108\",\n \"0.4856055\",\n \"0.48538634\",\n \"0.48537773\",\n \"0.48373544\",\n \"0.48346844\",\n \"0.48321015\",\n \"0.48295954\",\n \"0.48295173\",\n \"0.48293662\",\n \"0.48214215\",\n \"0.48200068\",\n \"0.4815323\",\n \"0.48146275\",\n \"0.48123088\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5555929"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":84659,"cells":{"query":{"kind":"string","value":"Return gaussian, airy or calibration PSFs Calibration PSFs are rescaled to the required pixel resolution by a bilinear interpolation."},"document":{"kind":"string","value":"def pacs_get_psf(band, resolution, kind='calibration'):\n\n band = band.lower()\n choices = ('blue', 'green', 'red')\n if band not in choices:\n raise ValueError(\"Invalid band '\" + band + \"'. Expected values are \" + \\\n strenum(choices) + '.')\n\n kind = kind.lower()\n choices = ('airy', 'gaussian', 'calibration')\n if kind not in choices:\n raise ValueError(\"Invalid PSF kind '\" + kind + \\\n \"'. Expected values are \" + strenum(choices) + '.')\n\n if kind in ('airy', 'gaussian'):\n func = { 'airy': airy_disk, 'gaussian' : gaussian }[kind]\n fwhm = PacsBase.PSF_FWHM[band]\n size = int(np.round(10 * fwhm / resolution)) // 2 * 2 + 1\n return func((size,size), fwhm=fwhm, resolution=resolution)\n\n raise NotImplementedError()"},"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 _scale_psf(self, input_irf_file, config):\n\n # Find all \"sigma\" values - tells how many PSF components we have in the IRF file\n column_names = [col.name.lower() for col in input_irf_file['POINT SPREAD FUNCTION'].columns]\n sigma_columns = list(filter(lambda s: \"sigma\" in s.lower(), column_names))\n\n # --------------------------\n # Reading the PSF parameters\n self._psf = dict()\n self._psf['Elow'] = input_irf_file['POINT SPREAD FUNCTION'].data['Energ_lo'][0].copy()\n self._psf['Ehigh'] = input_irf_file['POINT SPREAD FUNCTION'].data['Energ_hi'][0].copy()\n self._psf['ThetaLow'] = input_irf_file['POINT SPREAD FUNCTION'].data['Theta_lo'][0].copy()\n self._psf['ThetaHi'] = input_irf_file['POINT SPREAD FUNCTION'].data['Theta_hi'][0].copy()\n\n for i in range(0, len(sigma_columns)):\n sigma_name = 'sigma_{:d}'.format(i + 1)\n self._psf[sigma_name] = input_irf_file['POINT SPREAD FUNCTION'].data[sigma_name][0].transpose().copy()\n\n self._psf['E'] = scipy.sqrt(self._psf['Elow'] * self._psf['Ehigh'])\n self._psf['Theta'] = (self._psf['ThetaLow'] + self._psf['ThetaHi']) / 2.0\n # --------------------------\n\n # Creating the energy-theta mesh grid\n energy, theta = scipy.meshgrid(self._psf['E'], self._psf['Theta'], indexing='ij')\n\n # ---------------------------------\n # Scaling the PSF energy dependence\n\n # Constant error function\n if config['energy_scaling']['err_func_type'] == \"constant\":\n scale_params = config['energy_scaling'][\"constant\"]\n # Constant scaling. Loop over all \"sigma\" values and scale them by the same factor.\n for sigma_column in sigma_columns:\n self._psf[sigma_column + '_new'] = scale_params['scale'] * self._psf[sigma_column]\n\n # Gradients error function\n elif config['energy_scaling']['err_func_type'] == \"gradient\":\n scale_params = config['energy_scaling'][\"gradient\"]\n for sigma_column in sigma_columns:\n self._psf[sigma_column + '_new'] = self._psf[sigma_column] * (\n 1 + scale_params['scale'] * gradient(scipy.log10(energy),\n scipy.log10(scale_params['range_min']),\n scipy.log10(scale_params['range_max']))\n )\n\n # Step error function\n elif config['energy_scaling']['err_func_type'] == \"step\":\n scale_params = config['energy_scaling'][\"step\"]\n break_points = list(zip(scipy.log10(scale_params['transition_pos']),\n scale_params['transition_widths']))\n\n for sigma_column in sigma_columns:\n self._psf[sigma_column + '_new'] = self._psf[sigma_column] * (\n 1 + scale_params['scale'] * step(scipy.log10(energy), break_points)\n )\n\n else:\n raise ValueError(\"Unknown PSF scaling function {:s}\"\n .format(config['energy_scaling']['err_func_type']))\n # ---------------------------------\n\n # ---------------------------------\n # Scaling the PSF angular dependence\n\n # Constant error function\n if config['angular_scaling']['err_func_type'] == \"constant\":\n scale_params = config['angular_scaling'][\"constant\"]\n # Constant scaling. Loop over all \"sigma\" values and scale them by the same factor.\n for sigma_column in sigma_columns:\n # input_irf_file['POINT SPREAD FUNCTION'].data[sigma_column] *= scale_params['scale']\n self._psf[sigma_column + '_new'] = scale_params['scale'] * self._psf[sigma_column + '_new']\n\n # Gradients error function\n elif config['angular_scaling']['err_func_type'] == \"gradient\":\n scale_params = config['angular_scaling'][\"gradient\"]\n for sigma_column in sigma_columns:\n self._psf[sigma_column + '_new'] = self._psf[sigma_column + '_new'] * (\n 1 + scale_params['scale'] * gradient(theta,\n scale_params['range_min'],\n scale_params['range_max'])\n )\n\n # Step error function\n elif config['angular_scaling']['err_func_type'] == \"step\":\n scale_params = config['angular_scaling'][\"step\"]\n break_points = list(zip(scale_params['transition_pos'],\n scale_params['transition_widths']))\n\n for sigma_column in sigma_columns:\n self._psf[sigma_column + '_new'] = self._psf[sigma_column + '_new'] * (\n 1 + scale_params['scale'] * step(theta, break_points)\n )\n\n else:\n raise ValueError(\"Unknown PSF scaling function {:s}\"\n .format(config['angular_scaling']['err_func_type']))\n # ---------------------------------\n\n # Recording the scaled PSF\n for i in range(0, len(sigma_columns)):\n sigma_name = 'sigma_{:d}'.format(i + 1)\n\n input_irf_file['POINT SPREAD FUNCTION'].data[sigma_name][0] = self._psf[sigma_name + '_new'].transpose()","def photometric_calibration():\n pass","def scaling():\n \n for i in range(cfg.nfea):\n dm = 0\n var = 0\n for j in range(cfg.ntrain):\n dm += cfg.a[j,i]\n dm = dm/cfg.ntrain\n \n for j in range(cfg.ntrain):\n var += (cfg.a[j,i]-dm)**2\n\n var = var/cfg.ntrain\n var = np.sqrt(var)\n \n if var >= 10**(-5):\n cfg.clin[i] = 1.0/var \n cfg.dlin[i] = -dm/var \n \n else: \n if np.abs(dm)<=1.0:\n cfg.clin[i] = 1.0\n cfg.dlin[i] = 0.0 \n else: \n cfg.clin[i] = 1.0/dm\n cfg.dlin[i] = 0.0 \n \n for j in range(cfg.ntrain):\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\n \n return","def get_psf_scale_map(self):\n\n scale_map = dict()\n\n scale_map['E_edges'] = scipy.concatenate((self._psf['Elow'], [self._psf['Ehigh'][-1]]))\n scale_map['Theta_edges'] = scipy.concatenate((self._psf['ThetaLow'], [self._psf['ThetaHi'][-1]]))\n\n # Find all \"sigma\" values - tells how many PSF components we have in the IRF file\n column_names = self._psf.keys()\n sigma_columns = list(filter(lambda s: (\"sigma\" in s.lower()) and not (\"new\" in s.lower()),\n column_names))\n\n for sigma_column in sigma_columns:\n # Avoiding division by zero\n can_divide = self._psf[sigma_column] > 0\n\n scale_map[sigma_column] = scipy.zeros_like(self._psf[sigma_column])\n scale_map[sigma_column][can_divide] = self._psf[sigma_column + '_new'][can_divide] / self._psf[sigma_column][can_divide]\n\n wh_nan = scipy.where(scipy.isnan(scale_map[sigma_column]))\n scale_map[sigma_column][wh_nan] = 0\n scale_map[sigma_column] -= 1\n\n return scale_map","def run_python_psf_fitting(input_images, psf_model_file=None, hmin=5, fmin=1E3,\n pmax=7E4, qmax=.5, cmin=-1., cmax=.1,\n ncpu=None, focus_only=False):\n filt = check_images(input_images)\n if psf_model_file is None:\n psf_model_file = get_standard_psf('./', filt)\n det = fits.getval(input_images[0], 'DETECTOR')\n exts = [1] if det == 'IR' else [1,2]\n\n mods = make_models(psf_model_file)\n\n all_tbls = []\n for im in input_images:\n print(im)\n im_tbls = []\n sub_flag = fits.getval(im, 'SUBARRAY')\n if sub_flag:\n raise ValueError('Subarray images are not yet supported \\\n in the python fitting engine.')\n\n for ext in exts:\n data = fits.getdata(im , extname='SCI', extver=ext)\n tbl = measure_stars(data, mods[ext-1], hmin, fmin, pmax,\n qmax, cmin, cmax, ncpu, focus_only)\n\n tbl['x'] += 1.\n tbl['y'] += 1.\n make_sky_coord_cat(tbl, im, sci_ext=ext)\n im_tbls.append(tbl)\n print('='*40)\n # break\n all_tbls.append(im_tbls)\n return all_tbls","def rescale_all(self):\n for param_code in self.parameters.keys():\n self.rescale_parameter(param_code)","def _eta_sfr_scaling(self,x,q):\n i = self.enum[q]\n A = self.scaling_params['A'][i]\n b = self.scaling_params['b'][i]\n return A*x**b","def run(self):\n #calculate platescale of first input image\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n try:\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\n pscale = np.sqrt(np.abs(det))*3600.\n except:\n pscale = self.datain[0].header['PIXSCAL']\n #filtering out images which are too far away from the others\n #passing images added to a list of (image, WCS) tuples\n '''\n image_centers = []\n for f in self.datain:\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\n filtered_datain = []\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\n for i in range(len(image_centers)):\n for j in range(len(image_centers)-1):\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\n '''\n #calculations necessary for updating wcs information\n px = []\n py = []\n \n #in order to avoid NaN interactions, creating weight map\n weights=[]\n for f in self.datain:\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\n \n for f in self.datain:\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\n x0 = (max(px)+min(px))/2.\n y0 = (max(py)+min(py))/2.\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\n sy = (max(py)-min(py)) # arcsec\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\n xpix = size[0]//pscale\n ypix = size[1]//pscale\n cdelt = [pscale/3600.]*2\n \n #create self.dataout and give it a copy of an input's header\n self.dataout = DataFits(config = self.config)\n self.dataout.header = self.datain[0].header.copy()\n \n #update header wcs information\n self.log.info('Creating new WCS header')\n \n self.dataout.header['CRPIX1'] = xpix/2\n self.dataout.header['CRPIX2'] = ypix/2\n self.dataout.header['CRVAL1'] = x0\n self.dataout.header['CRVAL2'] = y0\n self.dataout.header['CD1_1'] = -cdelt[0]\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\n self.dataout.header['CD2_2'] = cdelt[1]\n self.dataout.header['NAXIS1'] = int(xpix)\n self.dataout.header['NAXIS2'] = int(ypix)\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\n self.dataout.header['RADESYS'] = 'ICRS'\n self.dataout.header['EQUINOX'] = 2000\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\n self.dataout.header['LONPOLE'] = 180\n self.dataout.header['PIXASEC'] = pscale\n \n theta_rad = np.deg2rad(self.getarg('outangle'))\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \n [np.sin(theta_rad), np.cos(theta_rad)]])\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\n for i in [0,1]:\n for j in [0,1]:\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\n \n #check drizzle arguments\n if self.getarg('kernel') == 'smoothing':\n kernel = 'lanczos3'\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\n kernel = self.getarg('kernel')\n else:\n self.log.error('Kernel name not recognized, using default')\n kernel = 'square'\n if self.getarg('drizzleweights') == 'uniform':\n driz_wt = ''\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\n driz_wt = self.getarg('drizzleweights')\n else:\n self.log.error('Drizzle weighting not recognized, using default')\n driz_wt = ''\n \n #create drizzle object and add input images\n fullwcs = wcs.WCS(self.dataout.header)\n self.log.info('Starting drizzle')\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\n for i,f in enumerate(self.datain):\n self.log.info('Adding %s to drizzle stack' % f.filename)\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\n \n try:\n fillval=float(self.getarg('fillval'))\n except:\n fillval=np.nan\n self.log.error('Fillvalue not recognized or missing, using default')\n \n #creates output fits file from drizzle output\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\n self.dataout.filename = self.datain[0].filename\n\n #add history\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))","def createIntegratedPsf(self):\n\n (wavelengths, weights) = self.filter\n for i in range(len(wavelengths)):\n\n wavelength = wavelengths[i]\n weight = weights[i]\n self.convertToOpd(wavelength) # creates self.opd\n opd = self.embedOpd()\n zf = numpy.fft.fft2(opd)\n del opd\n # Compute the amplitude squared.\n # (psf is not really the point spread function yet)\n psf = np.conjugate(zf)\n # psf will now be the point spread function, but still complex\n np.multiply(psf, zf, psf)\n del zf\n # normalize the PSF, and convert to single precision\n psf = psf.real / psf.size\n psf = psf.astype(np.float32)\n\n self.center(psf)\n\n # This describes the image scale if no resampling is done.\n cdelt_before_resampling = (wavelength * MICRONStoMETERS) / \\\n (self.D * self.oversample) * RADIANStoDEGREES\n if self.pixel_size is None:\n # we won't resample the output image\n self.cdelt = cdelt_before_resampling\n # Extract a subset.\n if self.output_size < self.npix:\n o_npix = self.output_size\n n0 = (self.npix - o_npix) // 2\n self.integrated_psf += \\\n (psf[n0:n0 + o_npix, n0:n0 + o_npix] * weight)\n else:\n self.integrated_psf += (psf * weight)\n else:\n # we'll resample to this image scale\n self.cdelt = self.pixel_size / self.oversample * ARCSECtoDEGREES\n # These three parameters are only used by mapPsf and for\n # normalizing the weight after resampling.\n self.rescale = self.cdelt / cdelt_before_resampling\n self.input_center = (self.npix + 1) // 2\n self.output_center = (self.output_size + 1) // 2\n sub_psf = np.zeros((self.output_size, self.output_size),\n dtype=np.float32)\n # Do the resampling, writing the output to sub_psf.\n ndimage.geometric_transform(psf, self.mapPsf,\n output_shape=(self.output_size, self.output_size),\n output=sub_psf, prefilter=True)\n weight = weight * self.rescale**2\n self.integrated_psf += (sub_psf * weight)\n del sub_psf\n\n if self.verbose:\n print(\"PSF for wavelength %g has been computed\" % wavelength)","def sgd(self):\n for i, j, r in self.samples:\n # Computer prediction and error\n if (self.type=='bias'):\n prediction = self.get_rating_bias(i, j)\n elif(self.type=='nonbias') :\n prediction = self.get_rating(i, j)\n # print(i, j, r,prediction)\n e = (r - prediction)\n\n # Update biases\n self.b_u[i] =self.b_u[i]+ self.alpha * (e - self.beta * self.b_u[i])\n self.b_i[j] = self.b_i[j] + self.alpha * (e - self.beta * self.b_i[j])\n\n # Create copy of row of P since we need to update it but use older values for update on Q\n P_i = self.P[i, :][:]\n\n # Update user and item latent feature matrices\n # print(self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :]))\n # print(self.P[i, :])\n self.P[i, :] =self.P[i, :] + self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :])\n # print(self.P[i, :],\"&&&&&&\")\n self.Q[j, :] = self.Q[j, :] + self.alpha * (e * P_i - self.beta * self.Q[j, :])\n # print(self.Q[j, :])","def __init__(self, psf,\n wave_array=[487, 625, 770, 870, 1020, 1250, 1650, 2120],\n grid_shape=[11,11]):\n self.img_scale = 0.10 # arcseconds per pixel\n \n # Fix wave_array to be a float\n wave_array = np.array(wave_array, dtype=float)\n wave_shape = psf.shape[0]\n\n if wave_shape != len(wave_array):\n print 'Problem with PSF shape and wave_array shape'\n \n # Reshape the array to get the X and Y positions\n psf = psf.reshape((wave_shape, grid_shape[0], grid_shape[1],\n psf.shape[2], psf.shape[3]))\n psf = np.swapaxes(psf, 1, 2)\n\n # scale array = lambda / 2D (Nyquist sampled)\n tel_diam = 2.235 # meters\n psf_scale = wave_array * (206264.8 * 1e-9) / (2.0 * tel_diam) # arcsec / pixel\n \n # Calculate the positions of all these PSFs. We assume that the\n # outermost PSFs are at the corners such that all observed stars\n # are internal to these corners.\n x_pos = np.mgrid[0:grid_shape[0]]\n y_pos = np.mgrid[0:grid_shape[1]]\n\n # Need to multiply by some of the array size properties.\n # Note that this assumes a pixel scale.\n fov = 10. # arcmin\n fov *= 60. # arcsec\n fov /= self.img_scale # pixels\n\n x_pos *= fov / x_pos[-1]\n y_pos *= fov / y_pos[-1]\n\n \n self.psf = psf\n self.psf_x = x_pos\n self.psf_y = y_pos\n self.psf_wave = wave_array\n self.wave_shape = wave_shape\n self.grid_shape = grid_shape\n self.psf_scale = psf_scale\n\n return","def rescale_intrinsic(self):\n # scale focal length and principal points wrt image resizeing\n if self.downscale > 1:\n self.K = self.K_orig.copy()\n self.K[0, 0] /= float(self.downscale)\n self.K[1, 1] /= float(self.downscale)\n self.K[0, 2] /= float(self.downscale)\n self.K[1, 2] /= float(self.downscale)\n self.intrinsic = self.K\n else:\n self.K = self.intrinsic = self.K_orig.copy()","def findScalingCoeffsMultiExp(self, PFC, lqCN, lqCF, lqPN, lqPF):\n # Get R and Z vectors at the midplane\n R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\n R_omp_min = R_omp_sol - 5.0*(lqPN + lqPF) #already in m\n R_omp_max = R_omp_sol + 20.0*(lqCN + lqCF) #already in m\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\n if R_omp_max > max(PFC.ep.g['R']):\n R_omp_max = max(PFC.ep.g['R']) #in meters now\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\n Z_omp = np.zeros(R_omp.shape)\n\n\n # Evaluate B at outboard midplane\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\n\n #Find coordinate transformation vector at midplane\n psiaxis = PFC.ep.g['psiAxis']\n psiedge = PFC.ep.g['psiSep']\n deltaPsi = np.abs(psiedge - psiaxis)\n gradPsi = Bp_omp*R_omp\n xfm = gradPsi / deltaPsi\n # transform hf width into flux space\n lqPN_hat = lqPN*xfm\n lqPF_hat = lqPF*xfm\n lqCN_hat = lqCN*xfm\n lqCF_hat = lqCF*xfm\n\n #Calculate flux at midplane using gfile\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\n psi = psiN*(psiedge - psiaxis) + psiaxis\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\n s_hat = psiN - PFC.psiMinLCFS\n\n #find locations in Private vs Common flux regions\n useP = np.where(s_hat < 0.0)[0]\n useC = np.where(s_hat >= 0.0)[0]\n\n #integral for SOL in flux space\n if len(useP)>0:\n qPN_hat = np.exp( s_hat[useP] / lqPN_hat[useP])\n qPF_hat = np.exp( s_hat[useP] / lqPF_hat[useP])\n #reinke method\n #intPN = simps(qPN_hat / B_omp[useP], psi[useP])\n #intPF = simps(qPF_hat / B_omp[useP], psi[useP])\n #menard method\n intPN = simps(qPN_hat, psi[useP])\n intPF = simps(qPF_hat, psi[useP])\n else:\n qPN_hat = 0.0\n qPF_hat = 0.0\n intPN = 0.0\n intPF = 0.0\n\n if len(useC)>0:\n qCN_hat = np.exp(-s_hat[useC] / lqCN_hat[useC])\n qCF_hat = np.exp(-s_hat[useC] / lqCF_hat[useC])\n #reinke method\n #intCN = simps(qCN_hat / B_omp[useC], psi[useC])\n #intCF = simps(qCF_hat / B_omp[useC], psi[useC])\n #menard method\n intCN = simps(qCN_hat, psi[useC])\n intCF = simps(qCF_hat, psi[useC])\n else:\n qCN_hat = 0.0\n qCF_hat = 0.0\n intCN = 0.0\n intCF = 0.0\n\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF +\n intPN*self.fracPN + intPF*self.fracPF)\n #account for nonphysical power\n if P0 < 0: P0 = -P0\n #Scale to input power\n q0 = self.Psol/P0\n\n #old method left for reference (same math)\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF +\n # intPN*self.fracPN + intPF*self.fracPF)\n\n return q0","def fit_gp(self):\n raise NotImplementedError('Abstract Method')","def scale_irf(self, config):\n\n if self.am_ok:\n # Opening the IRF input file\n input_irf_file = pyfits.open(self.input_irf_file_name, 'readonly')\n\n # Scaling the PSF\n self._scale_psf(input_irf_file, config['psf'])\n\n # Scaling the Aeff\n self._scale_aeff(input_irf_file, config['aeff'])\n \n # Scaling the Background\n self._scale_bkg(input_irf_file, config['bkg'])\n \n # Scaling the Edisp\n self._scale_edisp(input_irf_file, config['edisp'])\n\n # Getting the new IRF and output file names\n # IRF name\n output_irf_name = config['general']['output_irf_name']\n # Output file name\n output_irf_file_name = config['general']['output_irf_file_name']\n\n # Figuring out the output path\n output_path = '{path:s}/data/cta/{caldb:s}/bcf/{irf:s}'.format(path=self.caldb_path,\n caldb=self.caldb_name,\n irf=self.irf)\n\n # Writing the scaled IRF\n input_irf_file.writeto(output_path + \"/\" + output_irf_file_name, overwrite=True)\n\n # Updating the calibration data base with the new IRF\n self._append_irf_to_db(output_irf_name, output_irf_file_name)\n else:\n print(\"ERROR: something's wrong with the CALDB/IRF names. So can not update the data base.\")","def generate_fgs_fsw_coefficients(siaf=None, verbose=False, scale=0.06738281367):\n if siaf is None:\n siaf = pysiaf.Siaf('fgs')\n\n instrument = 'FGS'\n\n pre_delivery_dir = os.path.join(JWST_DELIVERY_DATA_ROOT, instrument)\n if not os.path.isdir(pre_delivery_dir):\n os.makedirs(pre_delivery_dir)\n\n for aperture_name in ['FGS1_FULL_OSS', 'FGS2_FULL_OSS']:\n\n aperture = siaf[aperture_name]\n\n # center_offset_x = 1023.5\n # center_offset_y = 1023.5\n center_offset_x = aperture.XSciRef - 1.\n center_offset_y = aperture.YSciRef - 1.\n\n if verbose:\n print('External scale {}'.format(scale))\n print(aperture.get_polynomial_scales())\n\n # get SIAF coefficients\n coefficients = aperture.get_polynomial_coefficients()\n\n ar = coefficients['Sci2IdlX']\n br = coefficients['Sci2IdlY']\n cr = coefficients['Idl2SciX']\n dr = coefficients['Idl2SciY']\n\n a_fsw, b_fsw, c_fsw, d_fsw = polynomial.rescale(ar, br, cr, dr, 1. / scale)\n factor = -1.\n\n if 'FGS1' in aperture_name:\n b_fsw *= -1\n c_fsw = polynomial.flip_y(c_fsw)\n d_fsw = polynomial.flip_y(d_fsw)\n\n a_fsw = polynomial.shift_coefficients(a_fsw, factor * center_offset_x,\n factor * center_offset_y)\n b_fsw = polynomial.shift_coefficients(b_fsw, factor * center_offset_x,\n factor * center_offset_y)\n c_fsw = polynomial.shift_coefficients(c_fsw, factor * center_offset_x,\n factor * center_offset_y)\n d_fsw = polynomial.shift_coefficients(d_fsw, factor * center_offset_x,\n factor * center_offset_y)\n\n a_fsw[0] += center_offset_x\n b_fsw[0] += center_offset_y\n c_fsw[0] += center_offset_x\n d_fsw[0] += center_offset_y\n\n # print FSW coefficients to screen\n fsw_coefficients = Table((c_fsw, d_fsw, a_fsw, b_fsw), names=(\n 'IDEALPTOREALPXCOE', 'IDEALPTOREALPYCOE', 'REALPTOIDEALPXCOE', 'REALPTOIDEALPYCOE'))\n if verbose:\n fsw_coefficients.pprint()\n\n table = Table(names=('parameter_name', 'value'), dtype=(object, float))\n table.add_row(['XOFFSET', center_offset_x])\n table.add_row(['YOFFSET', center_offset_y])\n table.add_row(['PLATESCALE', scale])\n for colname in fsw_coefficients.colnames:\n for i in range(len(fsw_coefficients[colname])):\n table.add_row(['{}_{}'.format(colname, i), fsw_coefficients[colname][i]])\n table['parameter_name'] = np.array(table['parameter_name']).astype(str)\n\n # write to file\n fsw_distortion_file = os.path.join(pre_delivery_dir, 'ifgs{}_distortion_tbl.txt'.format(aperture_name[3]))\n comments = []\n comments.append('FGS distortion coefficients for FSW')\n comments.append('')\n comments.append('Derived from SIAF distortion coefficients.')\n comments.append('')\n comments.append('Generated {} {}'.format(timestamp.isot, timestamp.scale))\n comments.append('by {}'.format(username))\n comments.append('')\n table.meta['comments'] = comments\n formats={'parameter_name': '%-20s', 'value': '%+2.6e'}\n table.write(fsw_distortion_file, format='ascii.fixed_width',\n delimiter=',', delimiter_pad=' ', bookend=False,\n overwrite=True, formats=formats)","def Rescale(self):\r\n picWidth,picHeight = self.oldSize = self.GetSizeTuple()\r\n bitmap = self.scaled = self.bitmap\r\n if not bitmap: return\r\n imgWidth,imgHeight = bitmap.GetWidth(),bitmap.GetHeight()\r\n if self.scaling == 2 or (self.scaling == 1 and (imgWidth > picWidth or imgHeight > picHeight)):\r\n image = bitmap.ConvertToImage()\r\n factor = min(1.0*picWidth/imgWidth,1.0*picHeight/imgHeight)\r\n newWidth,newHeight = int(factor*imgWidth),int(factor*imgHeight)\r\n self.scaled = image.Scale(newWidth,newHeight).ConvertToBitmap()\r\n #self.scaled = image.Scale(newWidth,newHeight,wx.IMAGE_QUALITY_HIGH ).ConvertToBitmap()\r","def fRes(self, mag, size, ps):\n x = 2 * np.pi * mag / (size[0] * ps[0])\n y = 2 * np.pi * mag / (size[1] * ps[1])\n return [x, y]","def __call__(self, results):\n\n for key in results.get('seg_fields', []):\n if self.scale_factor != 1:\n results[key] = general_ocr.imrescale(\n results[key],\n self.scale_factor,\n interpolation='nearest',\n backend=self.backend)\n return results","def fitfunc_2G1Ysq(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7):\n \n# if (a_x != 0.0):\n if (True):\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\n a_p5 * (1.0 - exp(-a_p6 * a_x**2))**2 * exp(-2.0 * a_p7 * a_x) / a_x**2)\n else:\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))","def fitfunc_2G1Y1Ysq(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7, a_p8, a_p9, a_p10):\n \n# if (a_x != 0.0):\n if (True):\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(- a_p7 * a_x) / a_x +\n a_p8 * (1.0 - exp(-a_p9 * a_x**2))**2 * exp(-2.0 * a_p10 * a_x) / a_x**2)\n else:\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))","def GCASFit(self):\r\n\t\t#run the scatteringPeakInfo method to retrieve various peak attributes \r\n\t\tself.scatteringPeakInfo()\r\n\t\t\r\n\t\t#set parameters for fitting\r\n\t\tbaseline = self.scatteringBaseline\r\n\t\tx_vals = np.array(self.getAcqPoints())\r\n\t\ty_vals = np.array(self.getScatteringSignal()\t)\r\n\t\t\r\n\t\t#initial values for amplitude(a) center(u) and gauss width(sig)\r\n\t\tguess_a = self.scatteringMax \r\n\t\tguess_u = self.scatteringMaxPos\r\n\t\tguess_sig = 10\r\n\t\tp_guess = [53000,73,17, -0.031,-0.1]\r\n\t\t\r\n\t\tdef GCAS(x, a, xc, w, a3, a4):\r\n\t\t\treturn baseline + (a /(w*math.sqrt(2*math.pi)))*np.exp(-((x-xc)/w)**2/2.)*(1+np.abs((a3/6)*(((x-xc)/w)**3-3.*((x-xc)/w))+ (a4/24)*( ((x-xc)/w)**4 -6.*((x-xc)/w)**3 + 3 ) ))\r\n\t\t\t\t\t\t\r\n\t\t#run the fitting\r\n\t\t#try:\r\n\t\tpopt, pcov = curve_fit(GCAS, x_vals, y_vals, p0=p_guess)\r\n\t\t#except:\r\n\t\t#\tpopt, pcov = [np.nan, np.nan, np.nan, np.nan, np.nan], [np.nan, np.nan, np.nan, np.nan, np.nan] \r\n\t\t\r\n\t\tself.FF_scattering_amp = popt[0]\r\n\t\tself.FF_peak_pos = popt[1] \r\n\t\tself.FF_width = popt[2]\r\n\t\tfit_result = []\r\n\t\tfor x in x_vals:\r\n\t\t\tfit_result.append(GCAS(x,popt[0],popt[1],popt[2],popt[3],popt[4]))\r\n\t\tself.FF_results = fit_result","def aug_test(self, imgs, img_metas, templates, proposals=None, rescale=False):\n # recompute feats to save memory\n #y = self.extract_feats(imgs, templates)\n proposal_list = self.aug_test_rpn(self.extract_feats(imgs, templates), img_metas, self.test_cfg.rpn)\n rcnn_test_cfg = self.test_cfg.rcnn\n aug_bboxes = []\n aug_scores = []\n for x, img_meta in zip(self.extract_feats(imgs, templates), img_metas):\n # only one image in the batch\n img_shape = img_meta[0]['img_shape']\n scale_factor = img_meta[0]['scale_factor']\n flip = img_meta[0]['flip']\n\n proposals = bbox_mapping(proposal_list[0][:, :4], img_shape, scale_factor, flip)\n # \"ms\" in variable names means multi-stage\n ms_scores = []\n\n rois = bbox2roi([proposals])\n for i in range(self.num_stages):\n bbox_head = self.bbox_head[i]\n cls_score, bbox_pred = self._bbox_forward_test(i, x, rois)\n ms_scores.append(cls_score)\n\n if i < self.num_stages - 1:\n bbox_label = cls_score.argmax(dim=1)\n rois = bbox_head.regress_by_class(rois, bbox_label, bbox_pred, img_meta[0])\n\n cls_score = sum(ms_scores) / float(len(ms_scores))\n bboxes, scores = self.bbox_head[-1].get_det_bboxes(rois, cls_score, bbox_pred, img_shape, scale_factor, rescale=False, cfg=None)\n aug_bboxes.append(bboxes)\n aug_scores.append(scores)\n\n # after merging, bboxes will be rescaled to the original image size\n merged_bboxes, merged_scores = merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)\n det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,\n rcnn_test_cfg.score_thr,\n rcnn_test_cfg.nms,\n rcnn_test_cfg.max_per_img)\n\n bbox_result = bbox2result(det_bboxes, det_labels, self.bbox_head[-1].num_classes)\n return bbox_result","def calibrate(self,(minX,minY,minZ),(maxX,maxY,maxZ),duration = 5,integer = True):\n\t\tt0 = time.time()\n\t\tminXYZ,maxXYZ = [2*31]*3,[-2**31]*3##+- inf...not nice but it will do...\n\t\twhile time.time() - t0 < duration: ## Probably not the best guard\n\t\t\tself.refresh()\n\t\t\tpoints = self.coordinateTracker.getListOfCartesianCoordinates()\n\t\t\tminXYZ = [ min ([minXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\n\t\t\tmaxXYZ = [ max ([maxXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\n\t\tfactor = max([abs(maxXYZ[i] - minXYZ[i]) for i in [0,1,2]])\n\t\t\n\t\tdef scale((x,y,z)):\n\t\t\t## Yeah, I know this /could/ be re-factored.\n\t\t\t## But this is simpler. \n\t\t\tif factor != 0:\n\t\t\t\tx = float(x) - (minXYZ[0]+maxXYZ[0])/2 \n\t\t\t\tx = x/factor\n\t\t\t\tx = x*abs(maxX - minX)\n\t\t\t\tx = x+(maxX + minX)/2\n\t\t\t\n\t\t\t\ty = float(y) - (maxXYZ[1] + minXYZ[1])/2\n\t\t\t\ty = y/factor\n\t\t\t\ty = y*abs(maxY - minY)\n\t\t\t\ty = y+(maxY + minY)/2\n\n\t\t\t\tz = float(z) - (maxXYZ[2]+ minXYZ[2])/2\n\t\t\t\tz = z/factor\n\t\t\t\tz = z*abs(maxZ - minZ)\n\t\t\t\tz = z+(maxZ + minZ)/2\n\t\t\tif integer: return map(int,(x,y,z))\n\t\t\telse: return x,y,z\n\t\tself.scale = scale","def fullGaussFit(self):\r\n\r\n\t\t#run the scatteringPeakInfo method to retrieve various peak attributes \r\n\t\tself.scatteringPeakInfo()\r\n\t\t\r\n\t\t#set parameters for fitting\r\n\t\tbaseline = self.scatteringBaseline\r\n\t\tx_vals = self.getAcqPoints()\r\n\t\ty_vals = self.getScatteringSignal()\t\r\n\t\t\r\n\t\t#initial values for amplitude(a) center(u) and gauss width(sig)\r\n\t\tguess_a = self.scatteringMax \r\n\t\tguess_u = self.scatteringMaxPos\r\n\t\tguess_sig = 10\r\n\t\tp_guess = [guess_a,guess_u,guess_sig]\r\n\t\t\r\n\t\tdef fullGauss(x, a, u, sig):\r\n\t\t\treturn baseline+a*np.exp((-(x-u)**2)/(2*sig**2)) #Gaussian\r\n\t\t\t#return baseline + (2*a/math.pi)*(sig/(4*(x-u)**2 + sig**2)) #Lorentzian - not good!\r\n\t\t\t\r\n\t\t#run the fitting\r\n\t\ttry:\r\n\t\t\tpopt, pcov = curve_fit(fullGauss, x_vals, y_vals, p0=p_guess)\r\n\t\texcept:\r\n\t\t\tpopt, pcov = [np.nan, np.nan, np.nan], [np.nan, np.nan, np.nan] \r\n\t\t\r\n\t\tself.FF_scattering_amp = popt[0]\r\n\t\tself.FF_peak_pos = popt[1] \r\n\t\tself.FF_width = popt[2]\r\n\t\tfit_result = []\r\n\t\tfor x in x_vals:\r\n\t\t\tfit_result.append(fullGauss(x,popt[0],popt[1],popt[2]))\r\n\t\tself.FF_results = fit_result","def _interp_aberrations_bilinear(aberrations, x_pos, y_pos, SCA_pos):\n min_x = np.min(x_pos)\n min_y = np.min(y_pos)\n max_x = np.max(x_pos)\n max_y = np.max(y_pos)\n x_frac = (SCA_pos.x - min_x) / (max_x - min_x)\n y_frac = (SCA_pos.y - min_y) / (max_y - min_y)\n lower_x_lower_y_ab = aberrations[(x_pos==min_x) & (y_pos==min_y), :]\n lower_x_upper_y_ab = aberrations[(x_pos==min_x) & (y_pos==max_y), :]\n upper_x_lower_y_ab = aberrations[(x_pos==max_x) & (y_pos==min_y), :]\n upper_x_upper_y_ab = aberrations[(x_pos==max_x) & (y_pos==max_y), :]\n interp_ab = (1.0-x_frac)*(1.0-y_frac)*lower_x_lower_y_ab + \\\n (1.0-x_frac)*y_frac*lower_x_upper_y_ab + \\\n x_frac*(1.0-y_frac)*upper_x_lower_y_ab + \\\n x_frac*y_frac*upper_x_upper_y_ab\n\n return interp_ab.flatten()","def _interpolation(self, video):\n self.F_int = []\n self.mgrid_0 = []\n self.mgrid_1 = []\n for p in range(video.points.shape[0]):\n _m_0, _m_1 = np.meshgrid(self.extended_points_0[p], self.extended_points_1[p])\n _F_int = interp2d(self.extended_points_0[p], self.extended_points_1[p], video.mraw[0, _m_0, _m_1], kind='cubic')\n self.F_int.append(_F_int)\n\n m_0, m_1 = np.meshgrid(self.extended_points_0[p, self.pad:-self.pad], self.extended_points_1[p, self.pad:-self.pad])\n self.mgrid_0.append(m_0)\n self.mgrid_1.append(m_1)","def preprocess(self):\n\n if self.x_range == None:\n x_min = min(np.min(self.fx), np.min(self.gx))\n x_max = max(np.max(self.fx), np.max(self.gx))\n self.x_range = [x_min,x_max]\n\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\n fy_new = f_inter(fgx_new)\n gy_new = g_inter(fgx_new)\n\n self.fx, self.fy = fgx_new, fy_new\n self.gx, self.gy = fgx_new, gy_new","def __getPressureCalibrationCoefficients(self):\n src13 = self.read_byte_data(self.address, 0x13)\n src14 = self.read_byte_data(self.address, 0x14)\n src15 = self.read_byte_data(self.address, 0x15)\n src16 = self.read_byte_data(self.address, 0x16)\n src17 = self.read_byte_data(self.address, 0x17)\n src18 = self.read_byte_data(self.address, 0x18)\n src19 = self.read_byte_data(self.address, 0x19)\n src1A = self.read_byte_data(self.address, 0x1A)\n src1B = self.read_byte_data(self.address, 0x1B)\n src1C = self.read_byte_data(self.address, 0x1C)\n src1D = self.read_byte_data(self.address, 0x1D)\n src1E = self.read_byte_data(self.address, 0x1E)\n src1F = self.read_byte_data(self.address, 0x1F)\n src20 = self.read_byte_data(self.address, 0x20)\n src21 = self.read_byte_data(self.address, 0x21)\n c00 = (src13 << 12) | (src14 << 4) | (src15 >> 4)\n c00 = getTwosComplement(c00, 20)\n c10 = ((src15 & 0x0F) << 16) | (src16 << 8) | src17\n c10 = getTwosComplement(c10, 20)\n c20 = (src1C << 8) | src1D\n c20 = getTwosComplement(c20, 16)\n c30 = (src20 << 8) | src21\n c30 = getTwosComplement(c30, 16)\n c01 = (src18 << 8) | src19\n c01 = getTwosComplement(c01, 16)\n c11 = (src1A << 8) | src1B\n c11 = getTwosComplement(c11, 16)\n c21 = (src1E < 8) | src1F\n c21 = getTwosComplement(c21, 16)\n return c00, c10, c20, c30, c01, c11, c21","def _batch_resize(self, ims, res, strategy='nearest'):\n order = {'nearest': 0, 'bilinear': 1, 'bicubic': 3}[strategy]\n bs = ims.shape[0]\n out = []\n log.info('Input ims shape: %s' % repr(ims.shape))\n has_extra_dim = len(ims.shape) == 4\n if not has_extra_dim:\n ims = ims[..., np.newaxis]\n h, w = ims.shape[1:3]\n for i in range(bs):\n o = interpolation.zoom(\n ims[i, ...], [res[0] / h, res[1] / w, 1.0], np.float32, order=order)\n out.append(o)\n out = np.stack(out)\n if not has_extra_dim:\n out = np.reshape(out, out.shape[:-1])\n return out","def optscl(args=None):\n\n parser = argparse.ArgumentParser(description=optscl.__doc__)\n\n # positional\n parser.add_argument('map', help='name of the input map')\n parser.add_argument('data', help='data file')\n parser.add_argument('scaled', help='scaled output map')\n\n # optional\n parser.add_argument(\n '-i', dest='iscale', action='store_true',\n help='individual scaling (else a single global scale)'\n )\n\n # OK, done with arguments.\n args = parser.parse_args()\n\n # load map and data\n dmap = doppler.Map.rfits(doppler.afits(args.map))\n data = doppler.Data.rfits(doppler.afits(args.data))\n\n nscale = 0\n for image in dmap.data:\n nscale += len(image.wave)\n\n if args.iscale and nscale > 1:\n # in this option we try to individually scale the images\n mtemp = copy.deepcopy(dmap)\n flux, ferr = retarr(data)\n wgt = np.empty_like(ferr)\n ok = ferr > 0\n wgt[ok] = 1./ferr[ok]**2\n\n # create indices to access the scale factors\n # save old scale factors\n sindices = []\n osfacs = []\n for ni, image in enumerate(dmap.data):\n for ns in range(len(image.scale)):\n sindices.append((ni,ns))\n osfacs.append(image.scale[ns])\n image.scale[ns] = 0.\n\n # compute a set of data vectors with each scale factor\n # set to 1 with all others set = 0, one by one\n dvecs = []\n for ni, ns in sindices:\n dmap.data[ni].scale[ns] = 1.0\n\n # compute data equivelent to data\n dvec = copy.deepcopy(data)\n doppler.comdat(dmap, dvec)\n dvecs.append(retarr(dvec)[0])\n\n dmap.data[ni].scale[ns] = 0.0\n\n # compile least-squares matrix & right-hand vector\n nvec = len(dvecs)\n A = np.empty((nvec,nvec))\n b = np.empty((nvec))\n for j in range(nvec):\n b[j] = (wgt[ok]*dvecs[j]*flux[ok]).sum()\n for i in range(j+1):\n A[j][i] = (wgt[ok]*dvecs[j]*dvecs[i]).sum()\n A[i][j] = A[j][i]\n\n nsfacs = linalg.solve(A,b)\n ocalc = np.zeros_like(flux)\n ncalc = np.zeros_like(flux)\n for j in range(nvec):\n ocalc += osfacs[j]*dvecs[j]\n ncalc += nsfacs[j]*dvecs[j]\n\n ndata = flux.size\n cold = (wgt*(flux-ocalc)**2).sum()/ndata\n cnew = (wgt*(flux-ncalc)**2).sum()/ndata\n print('Chi**2/ndata (before) =',cold,' (after) =',cnew)\n\n # set the new scale factors in place\n i = 0\n for ni, ns in sindices:\n dmap.data[ni].scale[ns] = nsfacs[i]\n i += 1\n\n # set the new scale factors in place\n i = 0\n for ni, ns in sindices:\n dmap.data[ni].scale[ns] = nsfacs[i]\n i += 1\n\n # set the singleton scale factors = 1 by\n # re-scaling the corresponding images instead.\n for ni, image in enumerate(dmap.data):\n if len(image.scale) == 1:\n image.data *= image.scale[0]\n image.scale[0] = 1\n\n else:\n # compute data equivalent to data\n dcalc = copy.deepcopy(data)\n doppler.comdat(dmap, dcalc)\n\n # compute optimum scale factor.\n sum0 = 0.\n sum1 = 0.\n sum2 = 0.\n ndata = 0\n for cspec, dspec in zip(dcalc.data, data.data):\n ok = dspec.ferr > 0.\n sum0 += ((dspec.flux[ok]/dspec.ferr[ok])**2).sum()\n sum1 += ((cspec.flux[ok]/dspec.ferr[ok])*(dspec.flux[ok]/dspec.ferr[ok])).sum()\n sum2 += ((cspec.flux[ok]/dspec.ferr[ok])**2).sum()\n ndata += dspec.ferr.size\n\n scale = sum1 / sum2\n cold = cnew = 0\n for cspec, dspec in zip(dcalc.data, data.data):\n ok = dspec.ferr > 0.\n cold += (((dspec.flux[ok]-cspec.flux[ok])/dspec.ferr[ok])**2).sum()\n cnew += (((dspec.flux[ok]-scale*cspec.flux[ok])/dspec.ferr[ok])**2).sum()\n\n print('ndata =',ndata)\n print('Optimum scale factor =',scale)\n print('Chi**2/ndata (before) =',cold/ndata,' (after) =',cnew/ndata)\n\n # scale images and write out\n for image in dmap.data:\n image.data *= scale\n\n # Write to a fits file\n dmap.wfits(doppler.afits(args.scaled))","def _psf_grid(self, xg, yg, r_max=1.):\n ratio = self.params['ratio']\n s = self.params['s']\n\n ng = xg.size\n ne = self.element.shape[0]\n d_mat = np.zeros((ng, ne))\n r_mat = r_max * ratio\n # loop over all elements\n for i in range(ne):\n ei = self.element[i, :]\n xy = np.mean(self.node[ei], axis=0)\n # there may be bias between grid and center of a element\n r = self._distance2d(xg, yg, center=xy)\n f = 1./(1.+np.exp(s*np.abs(r))/np.exp(s*r_mat))\n d_mat[:, i] = f\n return d_mat","def get_scaled_image(self, min_width=1024):\n self.dispersion = self.image.getCalibration().pixelWidth\n self.offset = self.image.getCalibration().xOrigin\n binning = 1\n while binning * min_width < self.image.getWidth():\n binning *= 2\n if binning > 1:\n binning /= 2\n IJ.run(self.image, 'Select None', '')\n new_image = self.image.crop()\n IJ.run(new_image, 'Bin...', 'x=%d y=%d binning=Average' %\n (binning, binning))\n self.dispersion *= binning\n self.offset /= binning\n self.image = new_image\n return new_image","def scale_data(x, y, x_scale_f = '../saved_models/scalers/9_params_21_2_x_scaler.pkl', y_scale_f = '../saved_models/scalers/9_params_21_2_y_scaler.pkl', par_slice = range(7) + range(8,9)):\n\tx_scaler = sklearn.externals.joblib.load(x_scale_f)\n\ty_scaler = sklearn.externals.joblib.load(y_scale_f)\n\tx_scaler.transform(x)\n\ty_scaler.transform(y)\n\tx = x[:,par_slice] \n\treturn x, y, x_scaler, y_scaler","def testScaleZeroPoint(self):\n\n ZEROPOINT = 27\n self.sctrl = afwMath.StatisticsControl()\n self.sctrl.setNanSafe(True)\n\n config = SpatialScaleZeroPointTask.ConfigClass()\n config.zeroPoint = ZEROPOINT\n config.interpStyle = \"CONSTANT\"\n config.selectFluxMag0.retarget(SelectLsstSimFluxMag0Task)\n config.selectFluxMag0.database = \"test_select_lsst_images\"\n zpScaler = SpatialScaleZeroPointTask(config=config)\n\n \"\"\" Note: this order does not properly retarget\n zpScaler = ScaleZeroPointTask()\n zpScaler.config.doInterpScale = True\n zpScaler.config.zeroPoint = ZEROPOINT\n zpScaler.config.interpStyle = \"CONSTANT\"\n zpScaler.config.selectFluxMag0.retarget(SelectLsstSimFluxMag0Task)\n zpScaler.config.selectFluxMag0.database = \"test_select_lsst_images\"\n \"\"\"\n\n outCalib = zpScaler.getCalib()\n self.assertAlmostEqual(outCalib.getMagnitude(1.0), ZEROPOINT)\n\n exposure = self.makeTestExposure(10, 10)\n # create dataId for exposure. Visit is only field needed. Others ignored.\n exposureId = {'ignore_fake_key': 1234, 'visit': 882820621}\n\n # API for computImageScale() takes a dataRef not a dataId.\n exposureFakeDataRef = WrapDataId(exposureId)\n # test methods: computeImageScale(), scaleMaskedImage(), getInterpImage()\n imageScaler = zpScaler.computeImageScaler(exposure, exposureFakeDataRef)\n scaleFactorIm = imageScaler.getInterpImage(exposure.getBBox())\n predScale = np.mean(imageScaler._scaleList) # 0.011125492863357\n\n self.assertAlmostEqual(afwMath.makeStatistics(scaleFactorIm, afwMath.VARIANCE, self.sctrl).getValue(),\n 0.0)\n self.assertAlmostEqual(afwMath.makeStatistics(scaleFactorIm, afwMath.MEAN, self.sctrl).getValue(),\n predScale)\n\n mi = exposure.getMaskedImage()\n imageScaler.scaleMaskedImage(mi)\n self.assertAlmostEqual(mi.get(1, 1)[0], predScale) # check image plane scaled\n self.assertAlmostEqual(mi.get(1, 1)[2], predScale**2) # check variance plane scaled\n\n exposure.setCalib(zpScaler.getCalib())\n self.assertAlmostEqual(exposure.getCalib().getFlux(ZEROPOINT), 1.0)","def scale_psf_fluxes(frame, psf):\n scale_factor = (max_flux(frame) / max_flux(psf))\n return psf.profile * scale_factor, psf.fluxes * scale_factor","def __call__(self, features: List[List[float]]) -> List[List[float]]:\n self.count += 1\n if self.count <= 1:\n self.feature_fix = features\n self.gmin = np.amin(features, axis=0) \n self.gmax = np.amax(features, axis=0) \n self.gdiff = np.subtract(self.gmax,self.gmin)\n \n features_scale = np.full((np.array(features).shape[0],np.array(features).shape[1]), np.nan)\n for i in range(np.array(features).shape[0]):\n for j in range(np.array(features).shape[1]):\n features_scale[i,j] = (np.array(features)[i,j] - self.gmin[j])/self.gdiff[j]\n \n return features_scale","def rescale(self):\n # forecast on real data, don't need this anymore\n pass","def ex2d(image, ivar, psf, specrange, wavelengths, xyrange=None,\n full_output=False, regularize=0.0):\n\n #- Range of image to consider\n waverange = (wavelengths[0], wavelengths[-1])\n \n if xyrange is None:\n xmin, xmax, ymin, ymax = xyrange = psf.xyrange(specrange, waverange)\n image = image[ymin:ymax, xmin:xmax]\n ivar = ivar[ymin:ymax, xmin:xmax]\n else:\n xmin, xmax, ymin, ymax = xyrange\n\n nx, ny = xmax-xmin, ymax-ymin\n npix = nx*ny\n \n nspec = specrange[1] - specrange[0]\n nwave = len(wavelengths)\n \n #- Solve AT W pix = (AT W A) flux\n \n #- Projection matrix and inverse covariance\n A = psf.projection_matrix(specrange, wavelengths, xyrange)\n\n #- Pixel weights matrix\n w = ivar.ravel()\n W = spdiags(ivar.ravel(), 0, npix, npix)\n\n #-----\n #- Extend A with an optional regularization term to limit ringing.\n #- If any flux bins don't contribute to these pixels,\n #- also use this term to constrain those flux bins to 0.\n \n #- Original: exclude flux bins with 0 pixels contributing\n # ibad = (A.sum(axis=0).A == 0)[0]\n \n #- Identify fluxes with very low weights of pixels contributing \n fluxweight = W.dot(A).sum(axis=0).A[0]\n minweight = 0.01*np.max(fluxweight)\n ibad = fluxweight < minweight\n \n #- Add regularization of low weight fluxes\n I = regularize*scipy.sparse.identity(nspec*nwave)\n I.data[0,ibad] = minweight - fluxweight[ibad]\n \n #- Only need to extend A if regularization is non-zero\n if np.any(I.data):\n pix = np.concatenate( (image.ravel(), np.zeros(nspec*nwave)) )\n Ax = scipy.sparse.vstack( (A, I) )\n wx = np.concatenate( (w, np.ones(nspec*nwave)) )\n else:\n pix = image.ravel()\n Ax = A\n wx = w\n\n #- Inverse covariance\n Wx = spdiags(wx, 0, len(wx), len(wx))\n iCov = Ax.T.dot(Wx.dot(Ax))\n \n #- Solve (image = A flux) weighted by Wx:\n #- A^T W image = (A^T W A) flux = iCov flux \n y = Ax.T.dot(Wx.dot(pix))\n \n xflux = spsolve(iCov, y).reshape((nspec, nwave))\n\n #- Solve for Resolution matrix\n try:\n R, fluxivar = resolution_from_icov(iCov)\n except np.linalg.linalg.LinAlgError, err:\n outfile = 'LinAlgError_{}-{}_{}-{}.fits'.format(specrange[0], specrange[1], waverange[0], waverange[1])\n print \"ERROR: Linear Algebra didn't converge\"\n print \"Dumping {} for debugging\".format(outfile)\n import fitsio\n fitsio.write(outfile, image, clobber=True)\n fitsio.write(outfile, ivar, extname='IVAR')\n fitsio.write(outfile, A.data, extname='ADATA') \n fitsio.write(outfile, A.indices, extname='AINDICES')\n fitsio.write(outfile, A.indptr, extname='AINDPTR')\n fitsio.write(outfile, iCov.toarray(), extname='ICOV')\n raise err\n \n #- Convolve with Resolution matrix to decorrelate errors\n fluxivar = fluxivar.reshape((nspec, nwave))\n rflux = R.dot(xflux.ravel()).reshape(xflux.shape)\n\n if full_output:\n results = dict(flux=rflux, ivar=fluxivar, R=R, xflux=xflux, A=A)\n results['iCov'] = iCov\n return results\n else:\n return rflux, fluxivar, R","def apply_gaussian_resolution(self,params,data,fwhm=1,dE=0.01,E_max=100):\n print('\\n################### CONVOLUTION #####################\\n')\n print(f'\\n\\tConvolution with Gaussian function, FWHM = {fwhm} meV\\n')\n\n data.fwhm = fwhm\n c = fwhm/2.35482\n\n data.dE = dE\n data.E_max = E_max\n data.spectra_E = np.arange(0,data.E_max+data.dE,data.dE)\n data.spectra_num_E = len(data.spectra_E)\n data.spectra = np.zeros((data.spectra_num_E,params.num_Qpoints))\n data.smooth_spectra = np.zeros((data.spectra_num_E,params.num_Qpoints))\n structure_factors = []\n energies = []\n\n ### sum intensity of degenerate bands\n if params.sum_degenerate_bands == True:\n print('\\n\\tSumming degenerate bands before convolution (using convolution dE as tolerance)\\n')\n for q in range(params.num_Qpoints):\n sfac = data.structure_factors[:,q]\n energy = data.frequencies[f'{q}']\n reduced_energies = []\n summed_sfac = []\n while True:\n if len(energy) == 0:\n break\n test_energy = energy[0]\n reduced_energies.append(test_energy)\n indicies = np.intersect1d(np.argwhere(energy <= (test_energy+data.dE)),\n np.argwhere(energy > (test_energy-data.dE)))\n summed_sfac.append(sfac[indicies].sum())\n sfac = np.delete(sfac,indicies)\n energy = np.delete(energy,indicies)\n energies.append(reduced_energies)\n structure_factors.append(summed_sfac)\n else:\n print('\\n\\tWARNING: You should definitely sum degenerate bands!!!\\n')\n for q in range(params.num_Qpoints):\n energies.append(data.frequencies[f'{q}'])\n structure_factors.append(data.structure_factors[:,q])\n\n ### populate array for heatmap\n ### try statement takes care of negative energies\n for q in range(params.num_Qpoints):\n for b in range(len(structure_factors[q][:])):\n try: # if there are negative modes, argwhere returns an empty vector and the slice crashes\n data.spectra[np.argwhere(data.spectra_E <= \n energies[q][b]).max(),q] = structure_factors[q][b]\n except:\n continue\n\n if params.bose_factor == True:\n print('\\n\\tWARNING: Bose factor isnt verified. Need to compare to SNAXS.\\n')\n if params.temperature < 5:\n temperature = 5\n else:\n temperature = params.temperature\n inds = np.argwhere(data.spectra_E <= 0.5)\n tmp_e = np.copy(data.spectra_E)\n tmp_e[inds] = 0.5\n bose = 1+1/(np.exp(tmp_e/(constants.kb*1000*temperature))-1)\n bose = np.tile(bose.reshape((data.spectra_num_E,1)),reps=(1,params.num_Qpoints))\n data.spectra = np.multiply(data.spectra,bose)\n data.spectra = data.spectra/np.max(data.spectra)\n\n ### gaussian convolution using for loops, slow but very little memory utilization\n g_energy = np.append(data.spectra_E-data.spectra_E.max(),data.spectra_E[1:])\n gaussian = np.exp(-0.5*g_energy**2/c**2)/c/np.sqrt(2*np.pi)\n gaussian = np.tile(gaussian.reshape((gaussian.shape[0],1)),(1,data.num_Qpoints))\n tmp = np.append(data.spectra,data.spectra,axis=0)[1:,:]\n for e in range(data.spectra_num_E):\n if e%50 == 0:\n print(f'\\t------ {e}/{data.spectra_num_E} -------')\n data.smooth_spectra[e,:] = np.trapz(tmp*np.roll(gaussian,shift=e,axis=0),g_energy,axis=0)\n print('\\n\\tDone convolving!\\n')\n data.smooth_spectra = data.smooth_spectra/np.max(data.smooth_spectra)\n\n# if params.random_background == True:\n# data.smooth_spectra = data.smooth_spectra+(np.random.normal(0,1,\n# (data.smooth_spectra.shape[0],data.smooth_spectra.shape[1])))*0.001\n \n plt.imshow(data.smooth_spectra,origin='lower',aspect='auto',cmap='hot')\n plt.show()","def fitfunc_2G2Y(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7, a_p8, a_p9, a_p10):\n \n# if (a_x != 0.0):\n if (True):\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(-a_p7 * a_x) / a_x +\n a_p8 * (1.0 - exp(-a_p9 * a_x**2)) * exp(-a_p10 * a_x) / a_x)\n else:\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))","def scale(self):","def getBeamplotRes(pBeam, mapper, PALC_config, SFP_config, gamma_n, plt_ranges, f, ind_f):\n # Calculation\n p_SPL, X, Y = calcBeamplot(PALC_config, gamma_n, plt_ranges, f, \\\n np.array(SFP_config.dir_meas[:,ind_f]), \\\n np.array(SFP_config.dir_meas_deg[:,1]))\n high_ind = np.argwhere(p_SPL > 100)\n low_ind = np.argwhere(p_SPL < 50)\n for n in range(np.shape(high_ind)[0]):\n p_SPL[high_ind[n,0], high_ind[n,1]] = 100\n for n in range(np.shape(low_ind)[0]):\n p_SPL[low_ind[n,0], low_ind[n,1]] = 50\n mapper.low = np.amin(p_SPL)\n mapper.high = np.amax(p_SPL) \n return p_SPL","def read_images_gen_cal(self, path: str) -> dict:\n image_files = []\n # read in all image paths (for png and jpgs)\n image_files.extend(glob.glob(os.path.join(path, '*.png')))\n image_files.extend(glob.glob(os.path.join(path, '*.jpg')))\n\n if len(image_files) <= 0:\n raise FileNotFoundError('Could not find any image files for camera calibration (png, jppgs supported!')\n\n # preparation of the 'real world' points like in CarND-Camera-Calibration repository ipynb!\n syn_objp = np.zeros((self._chessboard_shape[1] * self._chessboard_shape[0], 3), np.float32)\n syn_objp[:, :2] = np.mgrid[0:self._chessboard_shape[0], 0:self._chessboard_shape[1]].T.reshape(-1, 2)\n\n # Arrays to store all points pairs from the images. They will be used for calibration computation.\n objpoints = []\n imgpoints = []\n img_size = None\n\n for file_name in image_files:\n img = cv2.imread(file_name)\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # remember shape of images\n if img_size is None:\n img_size = (gray.shape[1], gray.shape[0])\n\n # Chessboard detection\n res, chess_pts = cv2.findChessboardCorners(gray, self._chessboard_shape, None)\n # Debug\n # painted = cv2.drawChessboardCorners(img, self._chessboard_shape, chess_pts, res)\n if res:\n objpoints.append(syn_objp)\n imgpoints.append(chess_pts)\n\n if len(objpoints) <= 0:\n raise ValueError('No Chessboard detected on images.')\n\n # Do camera calibration given object points and image points\n ret, mtx, dist, _, _ = cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)\n if not ret:\n raise ValueError('cv2.calibrateCamera() failed.')\n\n # prepare return value dictionary\n ret = {'mtx': mtx, 'dist': dist}\n return ret","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def RBFLS(rbfParam, pd, x, y, f, X, Y \\\n, xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\n \n if (len(xmc) < 2) and (len(ymc) < 2) :\n \n raise ValueError(\"Need at least 4 subregions (total) for RBF-LS.\")\n \n else :\n \n approx = np.zeros(len(X), float)\n approx_sparse = np.zeros(len(x), float)\n \n for i in range(len(xmc)) :\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\n p = poly(x[IND], y[IND], pd)\n ind = inSquare(x[IND], y[IND], xmc[i], ymc[i], ell, w)\n xc = x[IND][ind]\n yc = y[IND][ind]\n A = rbf(x[IND], y[IND], xc, yc, rbfParam)\n A = np.hstack((A, p))\n lam = np.linalg.lstsq(A, f[IND], rcond=None)[0]\n approx_sparse[IND] = A.dot(lam).flatten()\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\n A = rbf(X[IND], Y[IND], xc, yc, rbfParam)\n B = poly(X[IND], Y[IND], pd)\n B = np.hstack((A, B))\n approx[IND] = B.dot(lam).flatten()\n \n return approx, approx_sparse, lam","def fit(self, GRFData):\n\n self.__is_valid_dict(GRFData)\n for component in self.comp_list:\n self.scaler[component].fit(np.reshape(GRFData[component], (-1, 1)))\n self.isFitted = True","def get_scale(self, fe_params, cov_re):\n\n try:\n cov_re_inv = np.linalg.inv(cov_re)\n except np.linalg.LinAlgError:\n cov_re_inv = None\n\n qf = 0.\n for k in range(self.n_groups):\n\n exog = self.exog_li[k]\n ex_r = self.exog_re_li[k]\n ex2_r = self.exog_re2_li[k]\n\n # The residuals\n expval = np.dot(exog, fe_params)\n resid = self.endog_li[k] - expval\n\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\n resid)\n qf += np.dot(resid, mat)\n\n if self.reml:\n qf /= (self.n_totobs - self.k_fe)\n else:\n qf /= self.n_totobs\n\n return qf","def _run_rbf_interpolation(out_dir, layer, bounds, function, smooth):\n # if running scipy methods prepend root dir to out path\n out_dir = OPJ(path_root, out_dir)\n if not os.path.isdir(out_dir):\n print(\n os.path.abspath(out_dir),\n ' does not exist, creating directory.\\n'\n )\n Path(out_dir).mkdir(parents=True, exist_ok=True)\n\n out_file = OPJ(\n out_dir, \n '{time_agg}.tiff'.format(time_agg=layer)\n )\n print(\n '\\nInterpolating {g} point bias ratios for: {t}\\n'.\\\n format(g=grid_var, t=layer),\n 'Using the \"{}\" method\\n'.format(function),\n 'Resolution (pixel size) of output raster: {} degrees'.format(res)\n )\n print( \n 'GeoTIFF raster will be saved to: \\n',\n os.path.abspath(out_file)\n )\n\n\n # get grid extent based on station locations in CSV\n if not bounds:\n bounds = get_subgrid_bounds(in_path, buffer=buffer, grid_res=CS) \n lon_min, lon_max, lat_min, lat_max = bounds\n # fix any minor adjustments to make raster fit gridMET fishnet extent\n # if scale_factor=1 make sure raster pixels align exactly w/gridcells\n # raster extent may exceed fishnet grid to fill gaps for zonal stats\n if scale_factor:\n nxcells = abs(lon_min-lon_max) / (CS*scale_factor)\n nycells = abs(lat_min-lat_max) / (CS*scale_factor)\n remainder_x = int(nxcells) - nxcells\n remainder_y = int(nycells) - nycells\n if abs(remainder_x) > CS:\n remainder_x -= CS * (remainder_x / CS) \n if abs(remainder_y) > CS:\n remainder_y -= CS * (remainder_y / CS)\n lon_min -= remainder_x\n lon_max += CS\n lat_min -= remainder_y\n lat_min -= CS\n \n # check if layer is in summary CSV \n existing_layers = pd.read_csv(in_path).columns\n if not layer in existing_layers:\n print('Column {} does not exist in input CSV:\\n {}'.format(\n layer, in_path),\n '\\nSkipping interpolation.'\n )\n return\n \n # get point station data from summary CSV\n in_df = pd.read_csv(in_path, na_values=[-999])\n lon_pts, lat_pts = in_df.STATION_LON.values, in_df.STATION_LAT.values\n values = in_df[layer].values\n \n # mask out stations with missing data\n if in_df[layer].isnull().sum() > 0:\n mask = in_df[layer].notnull()\n n_missing = in_df[layer].isna().sum()\n # if one point or less data points exists exit\n if len(mask) == n_missing or len(values) - n_missing == 1:\n print('Missing sufficient point data for variable: {} {}'.\\\n format(grid_var, layer),\n '\\nNeed at least two stations with data, skipping.')\n return\n print('Warning:\\n',\n 'Data missing for {} of {} stations for variable: {} {}'.\\\n format(n_missing, len(values), grid_var, layer),\n '\\nproceeding with interpolation.')\n # get locations where ratio is not nan\n values = values[mask]\n lon_pts = lon_pts[mask]\n lat_pts = lat_pts[mask]\n\n nx_cells = int(np.round(np.abs((lon_min - lon_max) / CS)))\n ny_cells = int(np.round(np.abs((lat_min - lat_max) / CS)))\n # rbf requires uniform grid (n X n) so \n # extend short dimension and clip later \n nx_cells_out = copy.copy(nx_cells)\n ny_cells_out = copy.copy(ny_cells)\n # gdal requires \"upper left\" corner coordinates\n lat_max_out = copy.copy(lat_max)\n lon_max_out = copy.copy(lon_max)\n # extend short dimension to make square grid\n if not nx_cells == ny_cells:\n diff = np.abs(nx_cells - ny_cells)\n if nx_cells > ny_cells:\n lat_max += diff * CS\n ny_cells += diff\n else:\n lon_max += diff * CS\n nx_cells += diff\n\n if scale_factor == 1:\n # make finer/coarse grid by scale factor\n lons = np.linspace(lon_min, lon_max, \n int(np.round(nx_cells/scale_factor))-1)\n lats = np.linspace(lat_min, lat_max, \n int(np.round(ny_cells/scale_factor))-1)\n # extent for original created by spatial.build_subgrid\n # add one to make sure raster covers full extent\n lons_out = np.linspace(lon_min, lon_max_out, \n int(np.round(nx_cells_out/scale_factor))-1)\n lats_out = np.linspace(lat_min, lat_max_out, \n int(np.round(ny_cells_out/scale_factor))-1)\n\n else:\n # add one extra cell to cover grid buffer extent for upscaling\n # raster extent always >= grid buffer\n lons = np.linspace(lon_min, lon_max, \n int(np.round(nx_cells/scale_factor)))\n lats = np.linspace(lat_min, lat_max, \n int(np.round(ny_cells/scale_factor)))\n lons_out = np.linspace(lon_min, lon_max_out, \n int(np.round(nx_cells_out/scale_factor)))\n lats_out = np.linspace(lat_min, lat_max_out, \n int(np.round(ny_cells_out/scale_factor)))\n\n # if function was 'linear_rbf' \n function = function.replace('_rbf', '')\n # make sampling square grid\n XI, YI = np.meshgrid(lons, lats)\n # apply rbf interpolation\n rbf = Rbf(lon_pts, lat_pts, values, function=function, smooth=smooth)\n ZI = rbf(XI, YI)\n # clip to original extent, rbf array flips axes, and row order... \n ZI_out = ZI[0:len(lats_out),0:len(lons_out)]\n ZI_out = np.flip(ZI_out,axis=0)\n\n #### save scipy interpolated data as raster \n pixel_size = CS * scale_factor\n # number of pixels in each direction\n x_size = len(lons_out)\n y_size = len(lats_out)\n # set geotransform info\n gt = [\n lon_min,\n pixel_size,\n 0,\n lat_max_out,\n 0,\n -pixel_size\n ]\n # make geotiff raster\n driver = gdal.GetDriverByName('GTiff')\n ds = driver.Create(\n out_file,\n x_size, \n y_size, \n 1, \n gdal.GDT_Float32, \n )\n # set projection geographic lat/lon WGS 84\n srs = osr.SpatialReference()\n srs.ImportFromEPSG(4326)\n ds.SetProjection(srs.ExportToWkt())\n # assign spatial dimensions \n ds.SetGeoTransform(gt)\n outband = ds.GetRasterBand(1)\n # save rbf interpolated array as geotiff raster close\n outband.WriteArray(ZI_out)\n ds = None\n\n # calc residuals add to shapefile and in_path CSV, move shape to out_dir\n # only residuals for bias ratios, i.e. not for std dev, etc\n if layer in InterpGdal.default_layers:\n calc_pt_error(in_path, out_dir, layer, grid_var, \n grid_id_name=grid_id_name\n )\n # calculate zonal statistics save means for each gridMET cell\n if z_stats:\n zonal_stats(in_path, out_file, grid_id_name=grid_id_name)\n \n # plot layer's interpolated residuals as bar plot witheach Wx station \n # only produce residual plots for bias ratios, i.e. not for std dev, etc\n if res_plot and layer in InterpGdal.default_layers:\n layer = InterpGdal.var_residual_names.get(\n layer, \n layer.replace('mean','res')\n )\n y_label = 'residual (interpolated minus station value)'\n title = 'layer: {} algorithm: {} (RBF) resolution: {} deg.'.format(\n layer, function ,res)\n res_plot_dir = Path(out_dir)/'residual_plots'\n subtitle='parameters: smooth={}'.format(smooth)\n source_file = Path(out_dir)/Path(in_path).name\n\n station_bar_plot(source_file, layer, out_dir=res_plot_dir, \n y_label=y_label, title=title, subtitle=subtitle)","def __call__(self,activation_mask):\n assert self.grid.shape == activation_mask.shape\n self.mask = cv2.dilate(activation_mask, self.dilation_kernel, iterations=1)\n phosphenes = self.grid * self.mask\n phosphenes = cv2.GaussianBlur(phosphenes,(self.k_size,self.k_size),self.sigma)\n return phosphenes","def preprocess_RSofia(img):\n for i in range(480):\n for j in range(200):\n img[i,j]=0\n for i in range(150):\n for j in range(500):\n img[i,j]=0 \n for i in range(475):\n for j in range(90):\n img[i,img.shape[1]-1-j]=0\n for i in range(90):\n for j in range(465):\n img[i,img.shape[1]-1-j]=0\n return img","def scale(self, X_train, X_test):\n\n #X_train, X_test, y_train, y_test = self.split_X_y_sets()\n self.scaler.fit(X_train)\n X_train_sc = self.scaler.transform(X_train)\n X_test_sc = self.scaler.transform(X_test)\n\n return X_train_sc, X_test_sc #, y_train, y_test","def fitfunc(self, x, p):\n S = np.zeros(self.npt)\n for i in range(0, len(p), self.maxparm):\n ptyp = self.peakTyp[int(i/self.maxparm)]\n xm = p[i]\n amp = p[i+1]\n w = p[i+2]\n a = p[i+3]\n m = p[i+4]\n if ptyp == 'G':\n # peak type = Gaussian\n S = S + self.gauss(x, xm, amp, w)\n elif ptyp == 'L':\n # peak type = Lorentzian\n S = S + self.lorentz(x, xm, amp, w)\n elif ptyp == 'P':\n # peak type = Pseudo-Voigt\n S = S + self.psVoigt(x, xm, amp, w, m)\n elif ptyp == 'AG':\n # peak type = Asymmetric Gaussian\n S = S + self.agauss(x, xm, amp, w, a)\n elif ptyp == 'AL':\n # peak type = Asymmetric Lorentzian\n S = S + self.alorentz(x, xm, amp, w, a)\n elif ptyp == 'AP':\n # peak type = Asymmetric Pseudo-Voigt\n S = S + self.aPsVoigt(x, xm, amp, w, a, m)\n return S","def test_roundtrip():\n # Based heavily on test_sbinterpolatedimage() in test_SBProfile.py!\n import time\n t1 = time.time()\n\n # for each type, try to make an SBInterpolatedImage, and check that when we draw an image from\n # that SBInterpolatedImage that it is the same as the original\n ftypes = [np.float32, np.float64]\n ref_array = np.array([\n [0.01, 0.08, 0.07, 0.02],\n [0.13, 0.38, 0.52, 0.06],\n [0.09, 0.41, 0.44, 0.09],\n [0.04, 0.11, 0.10, 0.01] ]) \n\n for array_type in ftypes:\n image_in = galsim.ImageView[array_type](ref_array.astype(array_type))\n np.testing.assert_array_equal(\n ref_array.astype(array_type),image_in.array,\n err_msg=\"Array from input Image differs from reference array for type %s\"%\n array_type)\n interp = galsim.InterpolatedImage(image_in, dx=test_dx)\n test_array = np.zeros(ref_array.shape, dtype=array_type)\n image_out = galsim.ImageView[array_type](test_array)\n image_out.setScale(test_dx)\n interp.draw(image_out)\n np.testing.assert_array_equal(\n ref_array.astype(array_type),image_out.array,\n err_msg=\"Array from output Image differs from reference array for type %s\"%\n array_type)\n \n # Lanczos doesn't quite get the flux right. Wrong at the 5th decimal place.\n # Gary says that's expected -- Lanczos isn't technically flux conserving. \n # He applied the 1st order correction to the flux, but expect to be wrong at around\n # the 10^-5 level.\n # Anyway, Quintic seems to be accurate enough.\n quint = galsim.Quintic(1.e-4)\n quint_2d = galsim.InterpolantXY(quint)\n interp = galsim.InterpolatedImage(image_in, interpolant=quint_2d, dx=test_dx, flux=1.)\n do_shoot(interp,image_out,\"InterpolatedImage\")\n\n t2 = time.time()\n print 'time for %s = %.2f'%(funcname(),t2-t1)","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def preprocess(N, sigma2, R, f_def, params):\n\n #\n if 'scale' in params:\n if params['scale']:\n\n #\n N0 = np.sum(R * f_def, axis=1)\n\n #\n f_def *= np.average(N / N0)\n\n return N, sigma2, R, f_def, params","def calcSFP(gamma_tilt_deg, created_pal, SFP_config, Tech_res):\n # general\n gamma_n = gamma_tilt_deg / 180 * np.pi\n N = SFP_config.N\n \n ########################## SIMULATION SETUP ###############################\n # reference pressure\n p0 = 2 * 10**(-5)\n # frequencies\n f = get_freq_vec(N_freq=120, step_freq=1/12, freq_range=[20,20000])\n f_xy = np.array([100, 200, 400, 800, 1000, 2000, 5000, 10000, 16000])\n\n # initialize variables\n omega = 2 * np.pi * f\n omega_xy = 2 * np.pi * f_xy\n D_opt_LSA = np.ones([N, np.shape(f)[0]])\n P_LSA = np.zeros([np.shape(created_pal.xline)[0],np.shape(f)[0]], dtype=complex)\n\n # air attenuation\n alpha, c = AirAbsorptionCoefficient(f, T=293.15, p=101.325*10**(3), h=50)\n\n # directivity\n # if PALC_config.directivity not in ['Measured Loudspeaker Data']:\n # dire_meas_LSA = np.ones([np.shape(f)[0],np.shape(f)[0]])\n # dire_meas_deg = np.ones([np.shape(f)[0],np.shape(f)[0]])\n \n ######################### SPL CALCULATION #################################\n x_start, y_start, x_stop, y_stop, x_c_n, y_c_n, x_S, y_S = source_pos(gamma_n, SFP_config)\n\n for n in range(np.shape(f)[0]):\n G_LSA_vert = CalcGreenFunctions(created_pal.xline, created_pal.yline, np.array([0]), \\\n x_c_n, y_c_n, 0.82, SFP_config.directivity, \\\n SFP_config.Lambda_y, gamma_n, c, omega[n], 1, \\\n np.array(SFP_config.dir_meas[:,n]), \\\n np.array(SFP_config.dir_meas_deg[:,1]), \\\n alpha[n], f, n )\n\n P_LSA[:,n] = G_LSA_vert @ D_opt_LSA[:,n] # D_opt_LSA possibility to include driving functions\n p_SPL = 20 * np.log10(np.abs(P_LSA) / p0)\n Tech_res.update_tech_meas(p_SPL=p_SPL, f=f)\n return x_S, y_S","def scale(img, scales):\n outputs = []\n for sc in scales:\n outputs.append(\n cv2.resize(img, None, fx=sc, fy=sc, interpolation=cv2.INTER_CUBIC)\n )\n return outputs","def fitfunc_2G1Y(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7):\n \n# if (a_x != 0.0):\n if (True):\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(-a_p7 * a_x) / a_x)\n else:\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))","def map_all_sig_p(limitregion=False, region=\"allsky\"):\n \n # Get ids of all pixels that contain RHT data\n rht_cursor, tablename = get_rht_cursor(region = region)\n all_ids = get_all_rht_ids(rht_cursor, tablename)\n \n planck_tqu_db = sqlite3.connect(\"planck_TQU_gal_2048_db.sqlite\")\n planck_tqu_cursor = planck_tqu_db.cursor()\n planck_cov_db = sqlite3.connect(\"planck_cov_gal_2048_db.sqlite\")\n planck_cov_cursor = planck_cov_db.cursor()\n \n if limitregion is True:\n print(\"Loading all allsky data points that are in the SC_241 region\")\n # Get all ids that are in both allsky data and SC_241\n all_ids_SC = pickle.load(open(\"SC_241_healpix_ids.p\", \"rb\"))\n all_ids = list(set(all_ids).intersection(all_ids_SC))\n \n all_sigpGsq = np.zeros(len(all_ids))\n\n update_progress(0.0)\n for i, hp_index in enumerate(all_ids):\n #likelihood = Likelihood(_id[0], planck_tqu_cursor, planck_cov_cursor, p0_all, psi0_all, adaptivep0 = adaptivep0)\n (hp_index, T, Q, U) = planck_tqu_cursor.execute(\"SELECT * FROM Planck_Nside_2048_TQU_Galactic WHERE id = ?\", hp_index).fetchone()\n (hp_index, TT, TQ, TU, TQa, QQ, QU, TUa, QUa, UU) = planck_cov_cursor.execute(\"SELECT * FROM Planck_Nside_2048_cov_Galactic WHERE id = ?\", (hp_index,)).fetchone()\n \n # sigma_p as defined in arxiv:1407.0178v1 Eqn 3.\n sigma_p = np.zeros((2, 2), np.float_) # [sig_Q^2, sig_QU // sig_QU, UU]\n sigma_p[0, 0] = (1.0/T**2)*QQ #QQ\n sigma_p[0, 1] = (1.0/T**2)*QU #QU\n sigma_p[1, 0] = (1.0/T**2)*QU #QU\n sigma_p[1, 1] = (1.0/T**2)*UU #UU\n \n # det(sigma_p) = sigma_p,G^4\n det_sigma_p = np.linalg.det(sigma_p)\n sigpGsq = np.sqrt(det_sigma_p)\n \n all_sigpGsq[i] = sigpGsq\n \n update_progress((i+1.0)/len(all_ids), message='Calculating: ', final_message='Finished Calculating: ')\n \n # Place into healpix map\n hp_sigpGsq = make_hp_map(all_sigpGsq, all_ids, Nside = 2048, nest = True)\n \n out_root = \"/disks/jansky/a/users/goldston/susan/Wide_maps/\"\n if limitregion:\n hp.fitsfunc.write_map(out_root + \"planck_sigpGsq_SC_241.fits\", hp_sigpGsq, coord = \"G\", nest = True) \n else:\n hp.fitsfunc.write_map(out_root + \"planck_sigpGsq_DR2sky.fits\", hp_sigpGsq, coord = \"G\", nest = True)","def residLike(self):\n\n # --------------------------------------------------------------------------------------------- #\n # Compute the residuals\n if self.csys == 'GAL':\n # Redo some file computations with this coordinate system\n self.outbinexp = os.path.join(self.workpath, 'BinExpMapGAL'+self.suffix+'.fits')\n self.outbincub = os.path.join(self.workpath, 'BinCubeGAL'+self.suffix+'.fits')\n self.outsrcmap = os.path.join(self.workpath, 'SrcMapsGAL'+self.suffix+'.fits')\n self.outresid = os.path.join(self.workpath, 'ResidGAL'+self.suffix+'.fits')\n self.outresig = os.path.join(self.workpath, 'ResSigmaGAL'+self.suffix+'.fits')\n\n self._gtExpmap()\n self._gtBincube()\n self._gtSrcmap()\n else:\n # Nothing to add\n pass\n \n self._gtBinmap()\n self._gtModel()\n # Create the residual count map (count_map - model_map)\n if not os.path.isfile(self.outresid):\n os.popen(\"farith {} {} {} ops=SUB\".format(self.outbinmap, self.outgtmod,\n self.outresid))\n # Create the sigma-residual map (residual_map/sqrt(model_map))\n if not os.path.isfile(self.outresig):\n os.popen(\"ftpixcalc {} '(a-b)/sqrt(b)' a={} b={}\".format(self.outresig,\n self.outbinmap, self.outgtmod))\n\n # --------------------------------------------------------------------------------------------- #\n # Get the sources to overplot\n srcs = self.getSrc()\n srcs = srcs[(srcs['Separation'] <= 3.) & ([not i.endswith('c') for i in srcs['Name']])]\n # Plot the residuals\n resplt1 = FermiMap()\n resplt1.savepath = self.workpath\n resplt1.image = self.outresig\n resplt1.figname = 'ResSigma.pdf'\n dmin, dmax = np.abs(resplt1.datamin), resplt1.datamax\n resplt1.datamin = - min(dmin, dmax)\n resplt1.datamax = + min(dmin, dmax)\n resplt1.cbarlabel = r'Residual $\\sigma$/pixel'\n resplt1.mapSky()\n resplt1.srcSky(srcs['RA'], srcs['DEC'], srcs['Name'])\n resplt1.save()\n print(\"\\t=== Figure '{}' created ===\".format( os.path.join(resplt1.savepath, resplt1.figname) ))\n\n resplt2 = FermiMap()\n resplt2.savepath = self.workpath\n resplt2.image = self.outresid\n resplt2.figname = 'Residuals.pdf'\n dmin, dmax = np.abs(resplt2.datamin), resplt2.datamax\n resplt2.datamin = - min(dmin, dmax)\n resplt2.datamax = + min(dmin, dmax)\n resplt2.cbarlabel = r'Residual counts/pixel'\n resplt2.mapSky()\n resplt2.srcSky(srcs['RA'], srcs['DEC'], srcs['Name'])\n resplt2.save()\n print(\"\\t=== Figure '{}' created ===\".format( os.path.join(resplt2.savepath, resplt2.figname) ))\n return","def gaussExpand(img: np.ndarray, gs_k: np.ndarray) -> np.ndarray:\r\n gs_k = (gs_k / gs_k.sum()) * 4\r\n if img.ndim == 3:\r\n h, w, d = img.shape[:3]\r\n newImg = np.zeros((2 * h, 2 * w, d))\r\n else:\r\n h, w = img.shape[:2]\r\n newImg = np.zeros((2 * h, 2 * w))\r\n newImg[::2, ::2] = img\r\n image = cv2.filter2D(newImg, -1, gs_k, cv2.BORDER_REPLICATE)\r\n return image","def scale(self, smin=0.6, smax=2.0, N=20):\n scaled_geoms = []\n for s in np.linspace(smin, smax, N):\n scaled_atomlist = []\n for (Zi,[xi,yi,zi]) in self.atomlist0:\n scaled_atomlist.append( (Zi, (xi*s,yi*s,zi*s)) )\n scaled_geoms.append(scaled_atomlist)\n return scaled_geoms","def calibration(self) -> int:","def InterpolationFunctions(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\n ...","def __call__(self, results):\n if 'scale' not in results:\n if 'scale_factor' in results:\n img_shape = results['img'].shape[:2]\n scale_factor = results['scale_factor']\n assert isinstance(scale_factor, float)\n results['scale'] = tuple([int(x * scale_factor) for x in img_shape][::-1])\n else:\n self._random_scale(results)\n else:\n if not self.override:\n assert 'scale_factor' not in results, 'scale and scale_factor cannot be both set.'\n else:\n results.pop('scale')\n if 'scale_factor' in results:\n results.pop('scale_factor')\n self._random_scale(results)\n\n self._resize_img(results)\n self._resize_bboxes(results)\n self._resize_cbboxes(results)\n self._resize_masks(results)\n self._resize_seg(results)\n\n return results","def transform(self, GRFData):\n \n if not self.isFitted:\n raise NotFittedError(\"The scaler has n ot been fitted to data. Call 'fit()' before calling 'transform()'.\")\n\n self.__is_valid_dict(GRFData)\n transformed_GRFData = {}\n for component in self.comp_list:\n len_series = GRFData[component].shape[1]\n transformed_data = self.scaler[component].transform(np.reshape(GRFData[component], (-1, 1)))\n transformed_GRFData[component] = np.reshape(transformed_data, (-1, len_series))\n\n return transformed_GRFData","def scaling(self):\n return self.__scaling","def standardization (x_train,x_test):\n scaler = StandardScaler()\n ## reshape training data to 2D, fit and transform scaler\n scaler.fit(np.reshape(x_train, [x_train.shape[0], x_train.shape[1]*x_train.shape[2]*x_train.shape[3]]))\n x_train = scaler.transform(np.reshape(x_train, [x_train.shape[0], x_train.shape[1]*x_train.shape[2]*x_train.shape[3]]))\n ## reshape training data to 3D (n * frequencyrate * number of channels)\n x_train = np.reshape(x_train, [x_train.shape[0],x_test.shape[1],x_test.shape[2],x_test.shape[3]])\n x_test = scaler.transform(np.reshape(x_test, [x_test.shape[0], x_test.shape[1]*x_test.shape[2]*x_test.shape[3]]))\n x_test = np.reshape(x_test,[x_test.shape[0], x_train.shape[1], x_train.shape[2], x_train.shape[3]])\n return x_train, x_test, scaler","def _scale_bkg(self, input_irf_file, config):\n\n # Reading the Background parameters.\n self._bkg = dict()\n self._bkg['dxlow'] = input_irf_file['BACKGROUND'].data['detx_lo'][0].copy()\n self._bkg['dxhigh'] = input_irf_file['BACKGROUND'].data['detx_hi'][0].copy()\n self._bkg['dylow'] = input_irf_file['BACKGROUND'].data['dety_lo'][0].copy()\n self._bkg['dyhigh'] = input_irf_file['BACKGROUND'].data['dety_hi'][0].copy()\n self._bkg['Elow'] = input_irf_file['BACKGROUND'].data['energ_lo'][0].copy()\n self._bkg['Ehigh'] = input_irf_file['BACKGROUND'].data['energ_hi'][0].copy()\n self._bkg['bckgnd'] = input_irf_file['BACKGROUND'].data['bgd'][0].transpose().copy()\n \n self._bkg['detx'] = (self._bkg['dxlow'] + self._bkg['dxhigh']) / 2.0\n self._bkg['dety'] = (self._bkg['dylow'] + self._bkg['dyhigh']) / 2.0\n self._bkg['enrg'] = scipy.sqrt(self._bkg['Elow'] * self._bkg['Ehigh'])\n\n # Creating the [detx - dety - energy] mesh grid.\n detx, dety, energy = scipy.meshgrid(self._bkg['detx'], self._bkg['dety'], self._bkg['enrg'], indexing='ij')\n \n # ----------------------------------\n # Scaling the Background Energy dependence.\n\n # Constant error function\n if config['energy_scaling']['err_func_type'] == \"constant\":\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * config['energy_scaling']['constant']['scale']\n\n # Gradients error function\n elif config['energy_scaling']['err_func_type'] == \"gradient\":\n scaling_params = config['energy_scaling']['gradient']\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * (\n 1 + scaling_params['scale'] * gradient(scipy.log10(energy),\n scipy.log10(scaling_params['range_min']),\n scipy.log10(scaling_params['range_max']))\n )\n \n # Step error function\n elif config['energy_scaling']['err_func_type'] == \"step\":\n scaling_params = config['energy_scaling']['step']\n break_points = list(zip(scipy.log10(scaling_params['transition_pos']),\n scaling_params['transition_widths']))\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * (\n 1 + scaling_params['scale'] * step(scipy.log10(energy), break_points)\n )\n else:\n raise ValueError(\"Background energy scaling: unknown scaling function type '{:s}'\"\n .format(config['energy_scaling']['err_func_type']))\n\n # -------------------------------------------\n # Scaling the Background Angular dependence\n\n # Angular (FOV coordinate X-axis binning)\n # Constant error function\n if config['angular_scaling']['err_func_type'] == \"constant\":\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * config['angular_scaling']['constant']['scale']\n\n # Gradients error function\n elif config['angular_scaling']['err_func_type'] == \"gradient\":\n scaling_params = config['angular_scaling']['gradient']\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\n 1. + scaling_params['scale'] * gradient(detx,\n scaling_params['range_min'],\n scaling_params['range_max']) \n )\n # Step error function\n elif config['angular_scaling']['err_func_type'] == \"step\":\n scaling_params = config['angular_scaling']['step']\n break_points = list(zip(scaling_params['transition_pos'],\n scaling_params['transition_widths']))\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\n 1 + scaling_params['scale'] * step(detx, break_points)\n )\n else:\n raise ValueError(\"Background angular scaling: unknown scaling function type '{:s}'\"\n .format(config['angular_scaling']['err_func_type'])\n )\n\n # Angular (FOV coordinate Y-axis binning)\n # Constant error function\n if config['angular_scaling']['err_func_type'] == \"constant\":\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * config['angular_scaling']['constant']['scale']\n\n # Gradients error function\n elif config['angular_scaling']['err_func_type'] == \"gradient\":\n scaling_params = config['angular_scaling']['gradient']\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\n 1. + scaling_params['scale'] * gradient(dety,\n scaling_params['range_min'],\n scaling_params['range_max']) \n )\n # Step error function\n elif config['angular_scaling']['err_func_type'] == \"step\":\n scaling_params = config['angular_scaling']['step']\n break_points = list(zip(scaling_params['transition_pos'],\n scaling_params['transition_widths']))\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\n 1 + scaling_params['scale'] * step(dety, break_points)\n )\n else:\n raise ValueError(\"Background angular scaling: unknown scaling function type '{:s}'\"\n .format(config['angular_scaling']['err_func_type'])\n )\n\n # ----------------------------------\n # Recording the scaled Background\n input_irf_file['BACKGROUND'].data['bgd'][0] = self._bkg['bckgnd_new'].transpose()","def get_scale_parameter(self):\n\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\n gamma_func = special.gamma(shape_in_gamma_func)\n self._scale_parameter = self._mean_fire_recurrence / gamma_func","def test_fluxnorm():\n import time\n t1 = time.time()\n\n # define values\n im_lin_scale = 5 # make an image with this linear scale\n im_fill_value = 3. # fill it with this number\n im_scale = 1.3\n\n # First, make some Image with some total flux value (sum of pixel values) and scale\n im = galsim.ImageF(im_lin_scale, im_lin_scale)\n im.fill(im_fill_value)\n im.setScale(im_scale)\n total_flux = im_fill_value*(im_lin_scale**2)\n np.testing.assert_equal(total_flux, im.array.sum(),\n err_msg='Created array with wrong total flux')\n\n # Check that if we make an InterpolatedImage with flux normalization, it keeps that flux\n interp = galsim.InterpolatedImage(im) # note, flux normalization is the default\n np.testing.assert_equal(total_flux, interp.getFlux(),\n err_msg='Did not keep flux normalization')\n # Check that this is preserved when drawing\n im2 = interp.draw(dx = im_scale)\n np.testing.assert_equal(total_flux, im2.array.sum(),\n err_msg='Drawn image does not have expected flux normalization')\n\n # Now make an InterpolatedImage but tell it sb normalization\n interp_sb = galsim.InterpolatedImage(im, normalization = 'sb')\n # Check that when drawing, the sum is equal to what we expect if the original image had been\n # surface brightness\n im3 = interp_sb.draw(dx = im_scale)\n np.testing.assert_almost_equal(total_flux*(im_scale**2)/im3.array.sum(), 1.0, decimal=6,\n err_msg='Did not use surface brightness normalization')\n # Check that when drawing with sb normalization, the sum is the same as the original\n im4 = interp_sb.draw(dx = im_scale, normalization = 'sb')\n np.testing.assert_almost_equal(total_flux/im4.array.sum(), 1.0, decimal=6,\n err_msg='Failed roundtrip for sb normalization')\n\n # Finally make an InterpolatedImage but give it some other flux value\n interp_flux = galsim.InterpolatedImage(im, flux=test_flux)\n # Check that it has that flux\n np.testing.assert_equal(test_flux, interp_flux.getFlux(),\n err_msg = 'InterpolatedImage did not use flux keyword')\n # Check that this is preserved when drawing\n im5 = interp_flux.draw(dx = im_scale)\n np.testing.assert_almost_equal(test_flux/im5.array.sum(), 1.0, decimal=6,\n err_msg = 'Drawn image does not reflect flux keyword')\n\n t2 = time.time()\n print 'time for %s = %.2f'%(funcname(),t2-t1)","def calibration(self) -> tuple[int, int, int, int, int]:","def get_image(self, psf, atms, rmax, nx, pixelshift=[0,0,0], scalefactor=1.0):\n\n try:\n rank = MPI.COMM_WORLD.Get_rank()\n except:\n rank = 0\n\n psf2d = numpy.fft.fft2(psf)\n\n pot = self.stempot(rmax,rmax,len(psf),len(psf[0]),atms,pixelshift,scalefactor)\n\n potft = numpy.fft.fft2(pot)\n\n potm = potft*psf2d\n\n zcon_im = numpy.fft.ifft2(potm,axes=(0,1)).real\n\n return zcon_im","def get_scaling(self):\n if self.constrain_navigation:\n self.activate_navigation_constrain()\n return self.sx, self.sy","def guider_fit(fibres, observatory='APO'):\n\n dRA = fibres.dRA\n dDec = fibres.dDec\n raCenter = fibres.xFocal\n decCenter = fibres.yFocal\n\n arcsec_mm = 3600 / PLUGPLATESCALE[observatory]\n guideRMS = np.sqrt((fibres.dx**2 + fibres.dy**2).sum() / len(fibres)) * arcsec_mm\n\n bb = np.zeros(3, dtype=np.float64)\n AA = np.zeros((3, 3), dtype=np.float64)\n\n bb[0] = dRA.sum()\n bb[1] = dDec.sum()\n bb[2] = (raCenter * dDec - decCenter * dRA).sum()\n\n AA[0, 0] = len(fibres)\n AA[0, 1] = 0\n AA[0, 2] = -decCenter.sum()\n\n AA[1, 0] = 0\n AA[1, 1] = len(fibres)\n AA[1, 2] = raCenter.sum()\n\n AA[2, 2] = (raCenter * raCenter + decCenter * decCenter).sum()\n\n AA[2, 0] = AA[0, 2]\n AA[2, 1] = AA[1, 2]\n\n b3 = (raCenter * dRA + decCenter * dDec).sum()\n\n xx = np.linalg.solve(AA, bb)\n\n mRA = xx[0] / PLUGPLATESCALE[observatory]\n mDec = xx[1] / PLUGPLATESCALE[observatory]\n mRot = -np.rad2deg(xx[2])\n\n mScale = b3 / AA[2, 2] + 1.\n\n p0 = fibres[['xCenter', 'yCenter']].as_matrix()\n p1 = p0 - fibres[['dRA', 'dDec']].as_matrix()\n\n pos_error = get_position_error(p0, p1, [xx[0], xx[1]], -mRot, mScale)\n pos_error /= PLUGPLATESCALE[observatory]\n\n n_points = len(fibres)\n\n return pd.Series({'mRA': mRA, 'mDec': mDec, 'mRot': mRot,\n 'mScale': mScale, 'guideRMS': guideRMS,\n 'pos_error': pos_error, 'n_points': n_points})","def fit_gauss(x, y):\n nx = numpy.array(x)\n ny = numpy.array(y)\n ne = numpy.ones(len(ny))\n#\n#--- we need to give an initial guess\n#\n ymax = numpy.max(ny)\n med = find_med(y)\n p0 = [ymax, med, 10, 0]\n\n fitobj = kmpfit.Fitter(residuals=residualsG, data=(nx,ny,ne))\n fitobj.fit(params0=p0)\n [amp, cent, width, floor] = fitobj.params\n\n return [amp, cent, width]","def test_scaling(self):\n def runs_successfully(use_scal, coeffs):\n prob = om.Problem()\n prob.model.add_subsystem('row1', ScalingTestComp(row=1, coeffs=coeffs,\n use_scal=use_scal))\n prob.model.add_subsystem('row2', ScalingTestComp(row=2, coeffs=coeffs,\n use_scal=use_scal))\n prob.model.connect('row1.y', 'row2.x')\n prob.model.connect('row2.y', 'row1.x')\n prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False, maxiter=2, atol=1e-5, rtol=0)\n prob.model.nonlinear_solver.linear_solver = om.ScipyKrylov(maxiter=1)\n\n prob.set_solver_print(level=0)\n\n prob.setup()\n prob.run_model()\n\n return np.linalg.norm(prob.model._residuals.asarray()) < 1e-5\n\n # ---------------------------\n # coeffs: r1, r2, c1, c2\n coeffs = [1.e0, 1.e0, 1.e0, 1.e0]\n\n # Don't use scaling - but there's no need\n use_scal = False\n self.assertTrue(runs_successfully(use_scal, coeffs))\n # Use scaling - but there's no need\n use_scal = True\n self.assertTrue(runs_successfully(use_scal, coeffs))\n\n # ---------------------------\n # coeffs: r1, r2, c1, c2 - test output scaling:\n coeffs = [1.e0, 1.e0, 1.e10, 1.e0]\n\n # Don't use scaling - but output scaling needed\n use_scal = False\n self.assertTrue(not runs_successfully(use_scal, coeffs))\n # Use scaling - output scaling works successfully\n use_scal = True\n self.assertTrue(runs_successfully(use_scal, coeffs))\n\n # ---------------------------\n # coeffs: r1, r2, c1, c2 - test residual scaling:\n coeffs = [1.e10, 1.e0, 1.e10, 1.e0]\n\n # Don't use scaling - but residual scaling needed\n use_scal = False\n self.assertTrue(not runs_successfully(use_scal, coeffs))\n # Use scaling - residual scaling works successfully\n use_scal = True\n self.assertTrue(runs_successfully(use_scal, coeffs))","def _ssim_for_multiscale(img1, img2, max_val=255, filter_size=11,\n filter_sigma=1.5, k1=0.01, k2=0.03):\n\n _, height, width, _ = img1.shape\n\n # Filter size can't be larger than height or width of images.\n #size = tf.min(filter_size, height, width)\n size = filter_size\n\n # Scale down sigma if a smaller filter size is used.\n sigma = size * filter_sigma / filter_size if filter_size else 0\n\n if filter_size:\n window = broadcast_to(tf.reshape(_f_special_gauss(size, sigma),\n (size, size, 1, 1)), (size, size, 3,1))\n mu1 = conv(img1, window)\n mu2 = conv(img2, window)\n sigma11 = conv(img1 * img1, window)\n sigma22 = conv(img2 * img2, window)\n sigma12 = conv(img1 * img2, window)\n else:\n # Empty blur kernel so no need to convolve.\n mu1, mu2 = img1, img2\n sigma11 = img1 * img1\n sigma22 = img2 * img2\n sigma12 = img1 * img2\n\n mu11 = mu1 * mu1\n mu22 = mu2 * mu2\n mu12 = mu1 * mu2\n sigma11 -= mu11\n sigma22 -= mu22\n sigma12 -= mu12\n\n # Calculate intermediate values used by both ssim and cs_map.\n c1 = (k1 * max_val) ** 2\n c2 = (k2 * max_val) ** 2\n v1 = 2.0 * sigma12 + c2\n v2 = sigma11 + sigma22 + c2\n ssim = tf.reduce_mean((((2.0 * mu12 + c1) * v1) / ((mu11 + mu22 + c1) * v2)))\n cs = tf.reduce_mean(v1 / v2)\n return ssim, cs","def smooth_scipy(self, mri_data):\n\n # image dimension\n if hasattr(mri_data.img_header, 'info'):\n dx, dy, dz = np.abs(mri_data.img_header.info['DELTA'])\n elif hasattr(mri_data.img_header, 'get_zooms'):\n dx, dy, dz = mri_data.img_header.get_zooms()[:3]\n else:\n self.errmsg(\"No voxel size information in mri_data header\")\n\n # Set gaussian sigma in image dimension\n sigma = (self.blur_fwhm / np.array((dx, dy, dz))) / 2.354820\n imgdata = mri_data.img_data.astype(np.float64)\n\n # Apply mask\n if hasattr(self, 'maskV'):\n imgdata[~self.maskV] = 0\n\n # Apply Gaussian filter\n filt_img = gaussian_filter(imgdata, sigma, mode='constant')\n\n if hasattr(self, 'maskV'):\n # Adjust voxels with out of the mask (0) convolution\n aux_img = np.ones_like(imgdata)\n aux_img[~self.maskV] = 0\n filt_aux_img = gaussian_filter(aux_img, sigma, mode='constant')\n filt_img[self.maskV] /= filt_aux_img[self.maskV]\n\n return filt_img.astype(mri_data.img_data.dtype)","def scaling(self):\n return self._scaling","def scaling(self):\n return self._scaling","def fit_psf_to_gaussian(self, xx, yy, psf_data, x0, y0, sigmax0, sigmay0):\n peak0, offset0 = 1.0, 0.0 # Guesses\n # # We guess that the FWHM will be around 2 detector pixels [30 microns]\n # # Using the formula for a Gaussian FWHM = 2 sqrt(2 ln(2)) Sigma\n # sigma_fwhm = 100e-3 / 2 * np.sqrt(2 * np.log(2))\n # sigmax0, sigmay0 = sigma_fwhm, sigma_fwhm\n\n guess_param = [x0, y0, sigmax0, sigmay0, peak0, offset0]\n bounds = ([-np.inf, -np.inf, 0.0, 0.0, 0, -np.inf],\n [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf])\n\n while True:\n # The Gaussian fit can sometimes fail if our guess for the size of the PSF is very wrong\n try:\n pars, cov = curve_fit(self.gaussian2d, (xx.ravel(), yy.ravel()), psf_data.ravel(),\n p0=guess_param, bounds=bounds)\n # Results of the fit for the sigmaX, sigmaY\n sigmaX, sigmaY = pars[2], pars[3]\n # print(\"Successful Guassian Fit\")\n break\n\n except RuntimeError: # If it fails to converge, repeat with a randomly perturbed guess\n # sigmaX, sigmaY = np.nan, np.nan\n print(\"\\n[WARNING] Gaussian Fit of the PSF failed!\")\n\n # try with other guesses\n deltax = np.random.uniform(low=-1.0, high=1.0)\n deltay = np.random.uniform(low=-1.0, high=1.0)\n new_sigmax0 = (1 + deltax) * sigmax0\n new_sigmay0 = (1 + deltay) * sigmay0\n print(\"Trying with new Sigmas: X %.3f & Y %.3f microns\" % (1e3 * new_sigmax0, 1e3 * new_sigmay0))\n guess_param = [x0, y0, new_sigmax0, new_sigmay0, peak0, offset0]\n\n # Use the formula for the Gaussian FWHM to transform the sigmas into FWHM values\n fwhm_x = 2 * np.sqrt(2 * np.log(2)) * sigmaX * 1000\n fwhm_y = 2 * np.sqrt(2 * np.log(2)) * sigmaY * 1000\n\n return fwhm_x, fwhm_y","def peak_PSF(self):\n im, strehl = self.compute_PSF(np.zeros(self.N_act))\n return strehl","def scale(self):\n return self._gev_bijector.scale","def __call__(self, results):\n\n if 'scale' not in results:\n if 'scale_factor' in results:\n img_shape = results['img'].shape[:2]\n scale_factor = results['scale_factor']\n assert isinstance(scale_factor, float)\n results['scale'] = tuple(\n [int(x * scale_factor) for x in img_shape][::-1])\n else:\n self._random_scale(results)\n else:\n if not self.override:\n assert 'scale_factor' not in results, (\n 'scale and scale_factor cannot be both set.')\n else:\n results.pop('scale')\n if 'scale_factor' in results:\n results.pop('scale_factor')\n self._random_scale(results)\n\n self._resize_img(results)\n self._resize_bboxes(results)\n self._resize_masks(results)\n self._resize_seg(results)\n return results","def __call__(self, results):\n\n if 'scale' not in results:\n if 'scale_factor' in results:\n img_shape = results['img'].shape[:2]\n scale_factor = results['scale_factor']\n assert isinstance(scale_factor, float)\n results['scale'] = tuple(\n [int(x * scale_factor) for x in img_shape][::-1])\n else:\n self._random_scale(results)\n else:\n if not self.override:\n assert 'scale_factor' not in results, (\n 'scale and scale_factor cannot be both set.')\n else:\n results.pop('scale')\n if 'scale_factor' in results:\n results.pop('scale_factor')\n self._random_scale(results)\n\n self._resize_img(results)\n self._resize_bboxes(results)\n self._resize_masks(results)\n self._resize_seg(results)\n return results","def coral_image_resize(im, scaling_method, scaling_factor, height_cm):\n\n if scaling_method == 'scale':\n scale = float(scaling_factor) # here scaling_factor is the desired image scaling.\n elif scaling_method == 'ratio':\n scale = float(scaling_factor) * height_cm / im.shape[0] # here scaling_factor is the desited px_cm_ratio.\n im = scipy.misc.imresize(im, scale)\n return (im, scale)","def initialise_calibration(self):\n for i in range(0, self.NUM_SENSORS):\n self.calibratedMax[i] = 0\n self.calibratedMin[i] = self.READING_TIMEOUT","def scale4x(self) -> 'BaseImage':\n return self.scale2x().scale2x()","def GetParameters(ParamsFile, QualityFile, Bands, NumberOfParameters, RelativeUncert, ScaleFactor, ProcessSnow = 0):\n\n FillValue = 32767\n NumberOfBands = Bands.shape[0]\n\n # Get dimensions\n rows, cols = GetDimSubDataset( ParamsFile )\n\n Parameters = np.zeros((rows, cols, NumberOfBands, NumberOfParameters), np.float32)\n Uncertainties = np.zeros((rows, cols, NumberOfBands), np.float32)\n\n # Get Snow\n # 1 Snow albedo retrieved\n # 0 Snow-free albedo retrieved\n # 255 Fill Value\n print \"Reading Snow QA:\", QualityFile\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\"' + QualityFile + '\":MOD_Grid_BRDF:Snow_BRDF_Albedo'\n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\n SnowQA = SubDataset.GetRasterBand(1).ReadAsArray()\n if ProcessSnow == 0:\n SnowQA = np.where( SnowQA == 0, 1, 0)\n else:\n SnowQA = np.where( SnowQA == 1, 1, 0)\n\n # Load BRDF parameters\n print \"Reading BRDF parameters...\"\n for Band in range( Bands.shape[0] ):\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\"' + ParamsFile + '\":MOD_Grid_BRDF:BRDF_Albedo_Parameters_Band' + str( Bands[Band] )\n print SubDatasetName \n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\n\n for Parameter in range(NumberOfParameters):\n print \"Getting BRDF parameter\", Parameter\n Parameters[:,:,Band,Parameter] = SubDataset.GetRasterBand( Parameter + 1 ).ReadAsArray()\n\n # Snow mask\n Parameters[:,:,Band,Parameter] = Parameters[:,:,Band,Parameter] * SnowQA\n\n # Filter out fill values\n Parameters[:,:,Band,Parameter] = np.where(Parameters[:,:,Band,Parameter] == FillValue, 0.,\n Parameters[:,:,Band,Parameter] * ScaleFactor )\n\n # Get QA\n print \"Reading QA:\", QualityFile\n for Band in range( Bands.shape[0] ):\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\"' + QualityFile + '\":MOD_Grid_BRDF:BRDF_Albedo_Band_Quality_Band' + str( Bands[Band] )\n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\n QA = SubDataset.GetRasterBand(1).ReadAsArray()\n\n # https://ladsweb.nascom.nasa.gov/api/v1/filespec/collection=6&product=MCD43A2\n # BRDF_Albedo_Band_Quality_BandN ( N is 1 to 7 )> \n # 0 = best quality, full inversion (WoDs, RMSE majority good)\n # 1 = good quality, full inversion (also including the cases that no clear sky\n # observations over the day of interest or the Solar Zenith Angle is too \n # large even WoDs, RMSE majority good)\n # 2 = Magnitude inversion (numobs >=7)\n # 3 = Magnitude inversion (numobs >=2&<7)\n # 4 = Fill value\n\n QA_flags = np.array( [ 0,1,2,3 ] )\n\n for i, QA_flag in enumerate( QA_flags ) :\n indices = np.where( QA == QA_flag )\n Uncertainties[ indices[0], indices[1], Band ] = RelativeUncert[ i ]\n\n Uncertainties[:,:,Band] = Uncertainties[:,:,Band] * SnowQA \n\n SubDataset = None\n return Parameters, Uncertainties","def _get_params(self, input):\n transforms = []\n \n if self.brightness is not None:\n brightness = random.uniform(self.brightness[0], self.brightness[1])\n f = lambda img: F.adjust_brightness(img, brightness)\n transforms.append(f)\n\n if self.contrast is not None:\n contrast = random.uniform(self.contrast[0], self.contrast[1])\n f = lambda img: F.adjust_contrast(img, contrast)\n transforms.append(f)\n\n if self.saturation is not None:\n saturation = random.uniform(self.saturation[0], self.saturation[1])\n f = lambda img: F.adjust_saturation(img, saturation)\n transforms.append(f)\n\n if self.hue is not None:\n hue = random.uniform(self.hue[0], self.hue[1])\n f = lambda img: F.adjust_hue(img, hue)\n transforms.append(f)\n\n random.shuffle(transforms)\n return transforms","def __scale(data, max_value_list, min_value_list, scale_value_list, process_cols_list):\n features = np.array(data.features, dtype=float)\n for i in process_cols_list:\n value = features[i]\n if value > max_value_list[i]:\n value = max_value_list[i]\n elif value < min_value_list[i]:\n value = min_value_list[i]\n\n features[i] = (value - min_value_list[i]) / scale_value_list[i]\n _data = copy.deepcopy(data)\n _data.features = features\n return _data","def _gf_gray(I, p, r, eps, s=None):\n if s is not None:\n Isub = sp.ndimage.zoom(I, 1/s, order=1)\n Psub = sp.ndimage.zoom(p, 1/s, order=1)\n r = round(r / s)\n else:\n Isub = I\n Psub = p\n\n\n (rows, cols) = Isub.shape\n\n N = box(np.ones([rows, cols]), r)\n\n meanI = box(Isub, r) / N\n meanP = box(Psub, r) / N\n corrI = box(Isub * Isub, r) / N\n corrIp = box(Isub * Psub, r) / N\n varI = corrI - meanI * meanI\n covIp = corrIp - meanI * meanP\n\n\n a = covIp / (varI + eps)\n b = meanP - a * meanI\n\n meanA = box(a, r) / N\n meanB = box(b, r) / N\n\n if s is not None:\n meanA = sp.ndimage.zoom(meanA, s, order=1)\n meanB = sp.ndimage.zoom(meanB, s, order=1)\n\n q = meanA * I + meanB\n return q","def fit_gaussian_rl(img_dataset,image_data_variable_to_fit='PSF',beam_set_name='RESTORE_PARMS',fit_method='rm_fit',npix_window=[21,21],sampling=[401,401],cutoff=0.5,cutoff_sensitivity=0.003):\n import xarray as xr\n import matplotlib.pyplot as plt\n import dask.array as da\n from scipy.interpolate import interpn\n \n sampling = np.array(sampling)\n npix_window = np.array(npix_window)\n delta = np.array(img_dataset.incr[0:2])*3600*180/np.pi\n chunks = img_dataset[image_data_variable_to_fit].data.chunks[2:] + (3,)\n ellipse_parms = da.map_blocks(rm_fit,img_dataset[image_data_variable_to_fit].data,npix_window,sampling,cutoff,cutoff_sensitivity,delta,dtype=np.double,drop_axis=[0,1],new_axis=[2],chunks=chunks)\n\n img_dataset[beam_set_name] = xr.DataArray(ellipse_parms,dims=['chan','pol','elps_index'])\n return img_dataset","def calibrate(cap, location):\n\n #Poisition and size of sensor\n [x, y, h, w] = location\n\n #show square to user and wait for key\n print(\"please, step away to clear the blue square displayed on screen and press q to continue\")\n while True:\n ret, frame = cap.read()\n cv2.namedWindow('Calibrate',cv2.WINDOW_NORMAL)\n show = cv2.rectangle(frame, (x,y), (x+w,y+h), (255, 0, 0) , 5)\n cv2.imshow('Calibrate', show)\n key = cv2.waitKey(1)\n if key == ord('q'):\n break\n\n #get first image, process and define window previous for iteration\n ret, frame = cap.read()\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n frame = cv2.GaussianBlur(frame, (7,7), 0)\n previous = frame[y:y+w,x:x+h]\n\n #set parameters for mean value of sensor, kernel of erode function,\n sampleNbMean = 50\n xi = np.empty((0, sampleNbMean))\n kernel = np.ones((5,5), np.uint8)\n\n #iterate over each frame until sample number\n for iteration in range(sampleNbMean):\n\n # Capture frame, draw the window and display to the user\n ret, frame = cap.read()\n # Image operation\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n frame = cv2.GaussianBlur(frame, (7,7), 0)\n\n #get present window\n present = frame[y:y+w,x:x+h]\n\n #add sample for mean, add diference of window with prieviuos\n xi = np.append(xi,\n np.sum(\n cv2.erode(\n cv2.bitwise_xor(present,previous), kernel, iterations=1)))\n\n #present image becomes previous before steping into next image\n previous = present\n\n #mean\n mean = np.sum(xi)/len(xi)\n\n #sigma\n sum = 0\n for sample in xi:\n sum += np.power(sample - mean, 2)\n sigma = np.sqrt(sum/len(xi))\n\n #close window\n cv2.destroyWindow('Calibrate')\n\n return mean, sigma","def extractScale(self,groups):\n self.scaleX = float(groups[0])\n self.scaleY = float(groups[0])\n if len(groups) == 2 and groups[1]:\n self.scaleY = float(groups[1])\n self.matrix = [[self.scaleX, 0.0, 0.0], \\\n [0.0, self.scaleY, 0.0]]","def fit_gp(self):\n self.gpf_core.fit_gp_for_gp_bandit(num_samples=self.options.hp_samples)","def _resize_masks(self, results):\n for key in results.get('mask_fields', []):\n if results[key] is None:\n continue\n if self.keep_ratio:\n results[key] = results[key].rescale(results['scale'])\n else:\n results[key] = results[key].resize(results['img_shape'][:2])","def _resize_masks(self, results):\n for key in results.get('mask_fields', []):\n if results[key] is None:\n continue\n if self.keep_ratio:\n results[key] = results[key].rescale(results['scale'])\n else:\n results[key] = results[key].resize(results['img_shape'][:2])","def fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w):\n h, w, c = im.shape\n scale = float(target_h) / h\n im = cv2.resize(im, (target_w, target_h))\n mask = cv2.resize(mask, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\n if inst_masks.size > 0:\n inst_masks = np.transpose(inst_masks, (1, 2, 0)) # to (h, w, n)\n inst_masks = cv2.resize(inst_masks, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\n try:\n if inst_masks.ndim > 2:\n inst_masks = np.transpose(inst_masks, (2, 0, 1)) # to (n, h, w)\n else:\n inst_masks = inst_masks.reshape((1, target_h, target_w))\n except ValueError:\n print (inst_masks.ndim, inst_masks.shape)\n raise\n else:\n inst_masks = np.zeros((0, h, w), inst_masks.dtype)\n boxes[:, 0:4:2] = boxes[:, 0:4:2] * float(target_w) / w\n boxes[:, 1:4:2] = boxes[:, 1:4:2] * float(target_h) / h\n\n return im, inst_masks, mask, boxes, classes"],"string":"[\n \"def _scale_psf(self, input_irf_file, config):\\n\\n # Find all \\\"sigma\\\" values - tells how many PSF components we have in the IRF file\\n column_names = [col.name.lower() for col in input_irf_file['POINT SPREAD FUNCTION'].columns]\\n sigma_columns = list(filter(lambda s: \\\"sigma\\\" in s.lower(), column_names))\\n\\n # --------------------------\\n # Reading the PSF parameters\\n self._psf = dict()\\n self._psf['Elow'] = input_irf_file['POINT SPREAD FUNCTION'].data['Energ_lo'][0].copy()\\n self._psf['Ehigh'] = input_irf_file['POINT SPREAD FUNCTION'].data['Energ_hi'][0].copy()\\n self._psf['ThetaLow'] = input_irf_file['POINT SPREAD FUNCTION'].data['Theta_lo'][0].copy()\\n self._psf['ThetaHi'] = input_irf_file['POINT SPREAD FUNCTION'].data['Theta_hi'][0].copy()\\n\\n for i in range(0, len(sigma_columns)):\\n sigma_name = 'sigma_{:d}'.format(i + 1)\\n self._psf[sigma_name] = input_irf_file['POINT SPREAD FUNCTION'].data[sigma_name][0].transpose().copy()\\n\\n self._psf['E'] = scipy.sqrt(self._psf['Elow'] * self._psf['Ehigh'])\\n self._psf['Theta'] = (self._psf['ThetaLow'] + self._psf['ThetaHi']) / 2.0\\n # --------------------------\\n\\n # Creating the energy-theta mesh grid\\n energy, theta = scipy.meshgrid(self._psf['E'], self._psf['Theta'], indexing='ij')\\n\\n # ---------------------------------\\n # Scaling the PSF energy dependence\\n\\n # Constant error function\\n if config['energy_scaling']['err_func_type'] == \\\"constant\\\":\\n scale_params = config['energy_scaling'][\\\"constant\\\"]\\n # Constant scaling. Loop over all \\\"sigma\\\" values and scale them by the same factor.\\n for sigma_column in sigma_columns:\\n self._psf[sigma_column + '_new'] = scale_params['scale'] * self._psf[sigma_column]\\n\\n # Gradients error function\\n elif config['energy_scaling']['err_func_type'] == \\\"gradient\\\":\\n scale_params = config['energy_scaling'][\\\"gradient\\\"]\\n for sigma_column in sigma_columns:\\n self._psf[sigma_column + '_new'] = self._psf[sigma_column] * (\\n 1 + scale_params['scale'] * gradient(scipy.log10(energy),\\n scipy.log10(scale_params['range_min']),\\n scipy.log10(scale_params['range_max']))\\n )\\n\\n # Step error function\\n elif config['energy_scaling']['err_func_type'] == \\\"step\\\":\\n scale_params = config['energy_scaling'][\\\"step\\\"]\\n break_points = list(zip(scipy.log10(scale_params['transition_pos']),\\n scale_params['transition_widths']))\\n\\n for sigma_column in sigma_columns:\\n self._psf[sigma_column + '_new'] = self._psf[sigma_column] * (\\n 1 + scale_params['scale'] * step(scipy.log10(energy), break_points)\\n )\\n\\n else:\\n raise ValueError(\\\"Unknown PSF scaling function {:s}\\\"\\n .format(config['energy_scaling']['err_func_type']))\\n # ---------------------------------\\n\\n # ---------------------------------\\n # Scaling the PSF angular dependence\\n\\n # Constant error function\\n if config['angular_scaling']['err_func_type'] == \\\"constant\\\":\\n scale_params = config['angular_scaling'][\\\"constant\\\"]\\n # Constant scaling. Loop over all \\\"sigma\\\" values and scale them by the same factor.\\n for sigma_column in sigma_columns:\\n # input_irf_file['POINT SPREAD FUNCTION'].data[sigma_column] *= scale_params['scale']\\n self._psf[sigma_column + '_new'] = scale_params['scale'] * self._psf[sigma_column + '_new']\\n\\n # Gradients error function\\n elif config['angular_scaling']['err_func_type'] == \\\"gradient\\\":\\n scale_params = config['angular_scaling'][\\\"gradient\\\"]\\n for sigma_column in sigma_columns:\\n self._psf[sigma_column + '_new'] = self._psf[sigma_column + '_new'] * (\\n 1 + scale_params['scale'] * gradient(theta,\\n scale_params['range_min'],\\n scale_params['range_max'])\\n )\\n\\n # Step error function\\n elif config['angular_scaling']['err_func_type'] == \\\"step\\\":\\n scale_params = config['angular_scaling'][\\\"step\\\"]\\n break_points = list(zip(scale_params['transition_pos'],\\n scale_params['transition_widths']))\\n\\n for sigma_column in sigma_columns:\\n self._psf[sigma_column + '_new'] = self._psf[sigma_column + '_new'] * (\\n 1 + scale_params['scale'] * step(theta, break_points)\\n )\\n\\n else:\\n raise ValueError(\\\"Unknown PSF scaling function {:s}\\\"\\n .format(config['angular_scaling']['err_func_type']))\\n # ---------------------------------\\n\\n # Recording the scaled PSF\\n for i in range(0, len(sigma_columns)):\\n sigma_name = 'sigma_{:d}'.format(i + 1)\\n\\n input_irf_file['POINT SPREAD FUNCTION'].data[sigma_name][0] = self._psf[sigma_name + '_new'].transpose()\",\n \"def photometric_calibration():\\n pass\",\n \"def scaling():\\n \\n for i in range(cfg.nfea):\\n dm = 0\\n var = 0\\n for j in range(cfg.ntrain):\\n dm += cfg.a[j,i]\\n dm = dm/cfg.ntrain\\n \\n for j in range(cfg.ntrain):\\n var += (cfg.a[j,i]-dm)**2\\n\\n var = var/cfg.ntrain\\n var = np.sqrt(var)\\n \\n if var >= 10**(-5):\\n cfg.clin[i] = 1.0/var \\n cfg.dlin[i] = -dm/var \\n \\n else: \\n if np.abs(dm)<=1.0:\\n cfg.clin[i] = 1.0\\n cfg.dlin[i] = 0.0 \\n else: \\n cfg.clin[i] = 1.0/dm\\n cfg.dlin[i] = 0.0 \\n \\n for j in range(cfg.ntrain):\\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\\n \\n return\",\n \"def get_psf_scale_map(self):\\n\\n scale_map = dict()\\n\\n scale_map['E_edges'] = scipy.concatenate((self._psf['Elow'], [self._psf['Ehigh'][-1]]))\\n scale_map['Theta_edges'] = scipy.concatenate((self._psf['ThetaLow'], [self._psf['ThetaHi'][-1]]))\\n\\n # Find all \\\"sigma\\\" values - tells how many PSF components we have in the IRF file\\n column_names = self._psf.keys()\\n sigma_columns = list(filter(lambda s: (\\\"sigma\\\" in s.lower()) and not (\\\"new\\\" in s.lower()),\\n column_names))\\n\\n for sigma_column in sigma_columns:\\n # Avoiding division by zero\\n can_divide = self._psf[sigma_column] > 0\\n\\n scale_map[sigma_column] = scipy.zeros_like(self._psf[sigma_column])\\n scale_map[sigma_column][can_divide] = self._psf[sigma_column + '_new'][can_divide] / self._psf[sigma_column][can_divide]\\n\\n wh_nan = scipy.where(scipy.isnan(scale_map[sigma_column]))\\n scale_map[sigma_column][wh_nan] = 0\\n scale_map[sigma_column] -= 1\\n\\n return scale_map\",\n \"def run_python_psf_fitting(input_images, psf_model_file=None, hmin=5, fmin=1E3,\\n pmax=7E4, qmax=.5, cmin=-1., cmax=.1,\\n ncpu=None, focus_only=False):\\n filt = check_images(input_images)\\n if psf_model_file is None:\\n psf_model_file = get_standard_psf('./', filt)\\n det = fits.getval(input_images[0], 'DETECTOR')\\n exts = [1] if det == 'IR' else [1,2]\\n\\n mods = make_models(psf_model_file)\\n\\n all_tbls = []\\n for im in input_images:\\n print(im)\\n im_tbls = []\\n sub_flag = fits.getval(im, 'SUBARRAY')\\n if sub_flag:\\n raise ValueError('Subarray images are not yet supported \\\\\\n in the python fitting engine.')\\n\\n for ext in exts:\\n data = fits.getdata(im , extname='SCI', extver=ext)\\n tbl = measure_stars(data, mods[ext-1], hmin, fmin, pmax,\\n qmax, cmin, cmax, ncpu, focus_only)\\n\\n tbl['x'] += 1.\\n tbl['y'] += 1.\\n make_sky_coord_cat(tbl, im, sci_ext=ext)\\n im_tbls.append(tbl)\\n print('='*40)\\n # break\\n all_tbls.append(im_tbls)\\n return all_tbls\",\n \"def rescale_all(self):\\n for param_code in self.parameters.keys():\\n self.rescale_parameter(param_code)\",\n \"def _eta_sfr_scaling(self,x,q):\\n i = self.enum[q]\\n A = self.scaling_params['A'][i]\\n b = self.scaling_params['b'][i]\\n return A*x**b\",\n \"def run(self):\\n #calculate platescale of first input image\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.cd)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n try:\\n det = np.linalg.det(wcs.WCS(self.datain[0].header).wcs.pc)\\n pscale = np.sqrt(np.abs(det))*3600.\\n except:\\n pscale = self.datain[0].header['PIXSCAL']\\n #filtering out images which are too far away from the others\\n #passing images added to a list of (image, WCS) tuples\\n '''\\n image_centers = []\\n for f in self.datain:\\n image_centers.append((f.header['CRVAL1'], f.header['CRVAL2']))\\n filtered_datain = []\\n dist_list = [[[0]*(len(image_centers)-1)]*len(image_centers)]\\n for i in range(len(image_centers)):\\n for j in range(len(image_centers)-1):\\n dist_list[i][j+1] = np.sqrt((image_)**2+()**2)\\n '''\\n #calculations necessary for updating wcs information\\n px = []\\n py = []\\n \\n #in order to avoid NaN interactions, creating weight map\\n weights=[]\\n for f in self.datain:\\n weights.append((np.where(np.isnan(f.image) == True, 0, 1)))\\n \\n for f in self.datain:\\n px.extend(wcs.WCS(f.header).calc_footprint()[:,0])\\n py.extend(wcs.WCS(f.header).calc_footprint()[:,1])\\n x0 = (max(px)+min(px))/2.\\n y0 = (max(py)+min(py))/2.\\n sx = (max(px)-min(px))*np.cos(y0/180*np.pi) # arcsec\\n sy = (max(py)-min(py)) # arcsec\\n size = (sx*3600+self.getarg('pad')*2, sy*3600+self.getarg('pad')*2)\\n xpix = size[0]//pscale\\n ypix = size[1]//pscale\\n cdelt = [pscale/3600.]*2\\n \\n #create self.dataout and give it a copy of an input's header\\n self.dataout = DataFits(config = self.config)\\n self.dataout.header = self.datain[0].header.copy()\\n \\n #update header wcs information\\n self.log.info('Creating new WCS header')\\n \\n self.dataout.header['CRPIX1'] = xpix/2\\n self.dataout.header['CRPIX2'] = ypix/2\\n self.dataout.header['CRVAL1'] = x0\\n self.dataout.header['CRVAL2'] = y0\\n self.dataout.header['CD1_1'] = -cdelt[0]\\n self.dataout.header['CD1_2'] = self.dataout.header['CD2_1'] = 0.\\n self.dataout.header['CD2_2'] = cdelt[1]\\n self.dataout.header['NAXIS1'] = int(xpix)\\n self.dataout.header['NAXIS2'] = int(ypix)\\n self.dataout.header['CTYPE1'] = 'RA---TAN-SIP'\\n self.dataout.header['CTYPE2'] = 'DEC--TAN-SIP'\\n self.dataout.header['RADESYS'] = 'ICRS'\\n self.dataout.header['EQUINOX'] = 2000\\n self.dataout.header['LATPOLE'] = self.datain[0].header['CRVAL2']\\n self.dataout.header['LONPOLE'] = 180\\n self.dataout.header['PIXASEC'] = pscale\\n \\n theta_rad = np.deg2rad(self.getarg('outangle'))\\n rot_matrix = np.array([[np.cos(theta_rad), -np.sin(theta_rad)], \\n [np.sin(theta_rad), np.cos(theta_rad)]])\\n rot_cd = np.dot(rot_matrix, np.array([[self.dataout.header['CD1_1'], 0.],[0., self.dataout.header['CD2_2']]]))\\n for i in [0,1]:\\n for j in [0,1]:\\n self.dataout.header['CD{0:d}_{1:d}'.format(i+1, j+1)] = rot_cd[i,j]\\n \\n #check drizzle arguments\\n if self.getarg('kernel') == 'smoothing':\\n kernel = 'lanczos3'\\n elif self.getarg('kernel') in ['square', 'point', 'gaussian', 'tophat']:\\n kernel = self.getarg('kernel')\\n else:\\n self.log.error('Kernel name not recognized, using default')\\n kernel = 'square'\\n if self.getarg('drizzleweights') == 'uniform':\\n driz_wt = ''\\n elif self.getarg('drizzleweights') in ['exptime', 'expsq']:\\n driz_wt = self.getarg('drizzleweights')\\n else:\\n self.log.error('Drizzle weighting not recognized, using default')\\n driz_wt = ''\\n \\n #create drizzle object and add input images\\n fullwcs = wcs.WCS(self.dataout.header)\\n self.log.info('Starting drizzle')\\n driz = drz.Drizzle(outwcs = fullwcs, pixfrac=self.getarg('pixfrac'), \\\\\\n kernel=kernel, fillval='10000', wt_scl=driz_wt)\\n for i,f in enumerate(self.datain):\\n self.log.info('Adding %s to drizzle stack' % f.filename)\\n driz.add_image(f.imgdata[0], wcs.WCS(f.header), inwht=weights[i])\\n \\n try:\\n fillval=float(self.getarg('fillval'))\\n except:\\n fillval=np.nan\\n self.log.error('Fillvalue not recognized or missing, using default')\\n \\n #creates output fits file from drizzle output\\n self.dataout.imageset(np.where(driz.outsci == 10000, fillval, driz.outsci))\\n self.dataout.imageset(driz.outwht,'OutWeight', self.dataout.header)\\n self.dataout.filename = self.datain[0].filename\\n\\n #add history\\n self.dataout.setheadval('HISTORY','Coadd: %d files combined with %s kernel, pixfrac %f at %f times resolution' \\\\\\n % (len(self.datain), kernel, self.getarg('pixfrac'), self.getarg('resolution')))\",\n \"def createIntegratedPsf(self):\\n\\n (wavelengths, weights) = self.filter\\n for i in range(len(wavelengths)):\\n\\n wavelength = wavelengths[i]\\n weight = weights[i]\\n self.convertToOpd(wavelength) # creates self.opd\\n opd = self.embedOpd()\\n zf = numpy.fft.fft2(opd)\\n del opd\\n # Compute the amplitude squared.\\n # (psf is not really the point spread function yet)\\n psf = np.conjugate(zf)\\n # psf will now be the point spread function, but still complex\\n np.multiply(psf, zf, psf)\\n del zf\\n # normalize the PSF, and convert to single precision\\n psf = psf.real / psf.size\\n psf = psf.astype(np.float32)\\n\\n self.center(psf)\\n\\n # This describes the image scale if no resampling is done.\\n cdelt_before_resampling = (wavelength * MICRONStoMETERS) / \\\\\\n (self.D * self.oversample) * RADIANStoDEGREES\\n if self.pixel_size is None:\\n # we won't resample the output image\\n self.cdelt = cdelt_before_resampling\\n # Extract a subset.\\n if self.output_size < self.npix:\\n o_npix = self.output_size\\n n0 = (self.npix - o_npix) // 2\\n self.integrated_psf += \\\\\\n (psf[n0:n0 + o_npix, n0:n0 + o_npix] * weight)\\n else:\\n self.integrated_psf += (psf * weight)\\n else:\\n # we'll resample to this image scale\\n self.cdelt = self.pixel_size / self.oversample * ARCSECtoDEGREES\\n # These three parameters are only used by mapPsf and for\\n # normalizing the weight after resampling.\\n self.rescale = self.cdelt / cdelt_before_resampling\\n self.input_center = (self.npix + 1) // 2\\n self.output_center = (self.output_size + 1) // 2\\n sub_psf = np.zeros((self.output_size, self.output_size),\\n dtype=np.float32)\\n # Do the resampling, writing the output to sub_psf.\\n ndimage.geometric_transform(psf, self.mapPsf,\\n output_shape=(self.output_size, self.output_size),\\n output=sub_psf, prefilter=True)\\n weight = weight * self.rescale**2\\n self.integrated_psf += (sub_psf * weight)\\n del sub_psf\\n\\n if self.verbose:\\n print(\\\"PSF for wavelength %g has been computed\\\" % wavelength)\",\n \"def sgd(self):\\n for i, j, r in self.samples:\\n # Computer prediction and error\\n if (self.type=='bias'):\\n prediction = self.get_rating_bias(i, j)\\n elif(self.type=='nonbias') :\\n prediction = self.get_rating(i, j)\\n # print(i, j, r,prediction)\\n e = (r - prediction)\\n\\n # Update biases\\n self.b_u[i] =self.b_u[i]+ self.alpha * (e - self.beta * self.b_u[i])\\n self.b_i[j] = self.b_i[j] + self.alpha * (e - self.beta * self.b_i[j])\\n\\n # Create copy of row of P since we need to update it but use older values for update on Q\\n P_i = self.P[i, :][:]\\n\\n # Update user and item latent feature matrices\\n # print(self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :]))\\n # print(self.P[i, :])\\n self.P[i, :] =self.P[i, :] + self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :])\\n # print(self.P[i, :],\\\"&&&&&&\\\")\\n self.Q[j, :] = self.Q[j, :] + self.alpha * (e * P_i - self.beta * self.Q[j, :])\\n # print(self.Q[j, :])\",\n \"def __init__(self, psf,\\n wave_array=[487, 625, 770, 870, 1020, 1250, 1650, 2120],\\n grid_shape=[11,11]):\\n self.img_scale = 0.10 # arcseconds per pixel\\n \\n # Fix wave_array to be a float\\n wave_array = np.array(wave_array, dtype=float)\\n wave_shape = psf.shape[0]\\n\\n if wave_shape != len(wave_array):\\n print 'Problem with PSF shape and wave_array shape'\\n \\n # Reshape the array to get the X and Y positions\\n psf = psf.reshape((wave_shape, grid_shape[0], grid_shape[1],\\n psf.shape[2], psf.shape[3]))\\n psf = np.swapaxes(psf, 1, 2)\\n\\n # scale array = lambda / 2D (Nyquist sampled)\\n tel_diam = 2.235 # meters\\n psf_scale = wave_array * (206264.8 * 1e-9) / (2.0 * tel_diam) # arcsec / pixel\\n \\n # Calculate the positions of all these PSFs. We assume that the\\n # outermost PSFs are at the corners such that all observed stars\\n # are internal to these corners.\\n x_pos = np.mgrid[0:grid_shape[0]]\\n y_pos = np.mgrid[0:grid_shape[1]]\\n\\n # Need to multiply by some of the array size properties.\\n # Note that this assumes a pixel scale.\\n fov = 10. # arcmin\\n fov *= 60. # arcsec\\n fov /= self.img_scale # pixels\\n\\n x_pos *= fov / x_pos[-1]\\n y_pos *= fov / y_pos[-1]\\n\\n \\n self.psf = psf\\n self.psf_x = x_pos\\n self.psf_y = y_pos\\n self.psf_wave = wave_array\\n self.wave_shape = wave_shape\\n self.grid_shape = grid_shape\\n self.psf_scale = psf_scale\\n\\n return\",\n \"def rescale_intrinsic(self):\\n # scale focal length and principal points wrt image resizeing\\n if self.downscale > 1:\\n self.K = self.K_orig.copy()\\n self.K[0, 0] /= float(self.downscale)\\n self.K[1, 1] /= float(self.downscale)\\n self.K[0, 2] /= float(self.downscale)\\n self.K[1, 2] /= float(self.downscale)\\n self.intrinsic = self.K\\n else:\\n self.K = self.intrinsic = self.K_orig.copy()\",\n \"def findScalingCoeffsMultiExp(self, PFC, lqCN, lqCF, lqPN, lqPF):\\n # Get R and Z vectors at the midplane\\n R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\\n R_omp_min = R_omp_sol - 5.0*(lqPN + lqPF) #already in m\\n R_omp_max = R_omp_sol + 20.0*(lqCN + lqCF) #already in m\\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\\n if R_omp_max > max(PFC.ep.g['R']):\\n R_omp_max = max(PFC.ep.g['R']) #in meters now\\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\\n Z_omp = np.zeros(R_omp.shape)\\n\\n\\n # Evaluate B at outboard midplane\\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\\n\\n #Find coordinate transformation vector at midplane\\n psiaxis = PFC.ep.g['psiAxis']\\n psiedge = PFC.ep.g['psiSep']\\n deltaPsi = np.abs(psiedge - psiaxis)\\n gradPsi = Bp_omp*R_omp\\n xfm = gradPsi / deltaPsi\\n # transform hf width into flux space\\n lqPN_hat = lqPN*xfm\\n lqPF_hat = lqPF*xfm\\n lqCN_hat = lqCN*xfm\\n lqCF_hat = lqCF*xfm\\n\\n #Calculate flux at midplane using gfile\\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\\n psi = psiN*(psiedge - psiaxis) + psiaxis\\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\\n s_hat = psiN - PFC.psiMinLCFS\\n\\n #find locations in Private vs Common flux regions\\n useP = np.where(s_hat < 0.0)[0]\\n useC = np.where(s_hat >= 0.0)[0]\\n\\n #integral for SOL in flux space\\n if len(useP)>0:\\n qPN_hat = np.exp( s_hat[useP] / lqPN_hat[useP])\\n qPF_hat = np.exp( s_hat[useP] / lqPF_hat[useP])\\n #reinke method\\n #intPN = simps(qPN_hat / B_omp[useP], psi[useP])\\n #intPF = simps(qPF_hat / B_omp[useP], psi[useP])\\n #menard method\\n intPN = simps(qPN_hat, psi[useP])\\n intPF = simps(qPF_hat, psi[useP])\\n else:\\n qPN_hat = 0.0\\n qPF_hat = 0.0\\n intPN = 0.0\\n intPF = 0.0\\n\\n if len(useC)>0:\\n qCN_hat = np.exp(-s_hat[useC] / lqCN_hat[useC])\\n qCF_hat = np.exp(-s_hat[useC] / lqCF_hat[useC])\\n #reinke method\\n #intCN = simps(qCN_hat / B_omp[useC], psi[useC])\\n #intCF = simps(qCF_hat / B_omp[useC], psi[useC])\\n #menard method\\n intCN = simps(qCN_hat, psi[useC])\\n intCF = simps(qCF_hat, psi[useC])\\n else:\\n qCN_hat = 0.0\\n qCF_hat = 0.0\\n intCN = 0.0\\n intCF = 0.0\\n\\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF +\\n intPN*self.fracPN + intPF*self.fracPF)\\n #account for nonphysical power\\n if P0 < 0: P0 = -P0\\n #Scale to input power\\n q0 = self.Psol/P0\\n\\n #old method left for reference (same math)\\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF +\\n # intPN*self.fracPN + intPF*self.fracPF)\\n\\n return q0\",\n \"def fit_gp(self):\\n raise NotImplementedError('Abstract Method')\",\n \"def scale_irf(self, config):\\n\\n if self.am_ok:\\n # Opening the IRF input file\\n input_irf_file = pyfits.open(self.input_irf_file_name, 'readonly')\\n\\n # Scaling the PSF\\n self._scale_psf(input_irf_file, config['psf'])\\n\\n # Scaling the Aeff\\n self._scale_aeff(input_irf_file, config['aeff'])\\n \\n # Scaling the Background\\n self._scale_bkg(input_irf_file, config['bkg'])\\n \\n # Scaling the Edisp\\n self._scale_edisp(input_irf_file, config['edisp'])\\n\\n # Getting the new IRF and output file names\\n # IRF name\\n output_irf_name = config['general']['output_irf_name']\\n # Output file name\\n output_irf_file_name = config['general']['output_irf_file_name']\\n\\n # Figuring out the output path\\n output_path = '{path:s}/data/cta/{caldb:s}/bcf/{irf:s}'.format(path=self.caldb_path,\\n caldb=self.caldb_name,\\n irf=self.irf)\\n\\n # Writing the scaled IRF\\n input_irf_file.writeto(output_path + \\\"/\\\" + output_irf_file_name, overwrite=True)\\n\\n # Updating the calibration data base with the new IRF\\n self._append_irf_to_db(output_irf_name, output_irf_file_name)\\n else:\\n print(\\\"ERROR: something's wrong with the CALDB/IRF names. So can not update the data base.\\\")\",\n \"def generate_fgs_fsw_coefficients(siaf=None, verbose=False, scale=0.06738281367):\\n if siaf is None:\\n siaf = pysiaf.Siaf('fgs')\\n\\n instrument = 'FGS'\\n\\n pre_delivery_dir = os.path.join(JWST_DELIVERY_DATA_ROOT, instrument)\\n if not os.path.isdir(pre_delivery_dir):\\n os.makedirs(pre_delivery_dir)\\n\\n for aperture_name in ['FGS1_FULL_OSS', 'FGS2_FULL_OSS']:\\n\\n aperture = siaf[aperture_name]\\n\\n # center_offset_x = 1023.5\\n # center_offset_y = 1023.5\\n center_offset_x = aperture.XSciRef - 1.\\n center_offset_y = aperture.YSciRef - 1.\\n\\n if verbose:\\n print('External scale {}'.format(scale))\\n print(aperture.get_polynomial_scales())\\n\\n # get SIAF coefficients\\n coefficients = aperture.get_polynomial_coefficients()\\n\\n ar = coefficients['Sci2IdlX']\\n br = coefficients['Sci2IdlY']\\n cr = coefficients['Idl2SciX']\\n dr = coefficients['Idl2SciY']\\n\\n a_fsw, b_fsw, c_fsw, d_fsw = polynomial.rescale(ar, br, cr, dr, 1. / scale)\\n factor = -1.\\n\\n if 'FGS1' in aperture_name:\\n b_fsw *= -1\\n c_fsw = polynomial.flip_y(c_fsw)\\n d_fsw = polynomial.flip_y(d_fsw)\\n\\n a_fsw = polynomial.shift_coefficients(a_fsw, factor * center_offset_x,\\n factor * center_offset_y)\\n b_fsw = polynomial.shift_coefficients(b_fsw, factor * center_offset_x,\\n factor * center_offset_y)\\n c_fsw = polynomial.shift_coefficients(c_fsw, factor * center_offset_x,\\n factor * center_offset_y)\\n d_fsw = polynomial.shift_coefficients(d_fsw, factor * center_offset_x,\\n factor * center_offset_y)\\n\\n a_fsw[0] += center_offset_x\\n b_fsw[0] += center_offset_y\\n c_fsw[0] += center_offset_x\\n d_fsw[0] += center_offset_y\\n\\n # print FSW coefficients to screen\\n fsw_coefficients = Table((c_fsw, d_fsw, a_fsw, b_fsw), names=(\\n 'IDEALPTOREALPXCOE', 'IDEALPTOREALPYCOE', 'REALPTOIDEALPXCOE', 'REALPTOIDEALPYCOE'))\\n if verbose:\\n fsw_coefficients.pprint()\\n\\n table = Table(names=('parameter_name', 'value'), dtype=(object, float))\\n table.add_row(['XOFFSET', center_offset_x])\\n table.add_row(['YOFFSET', center_offset_y])\\n table.add_row(['PLATESCALE', scale])\\n for colname in fsw_coefficients.colnames:\\n for i in range(len(fsw_coefficients[colname])):\\n table.add_row(['{}_{}'.format(colname, i), fsw_coefficients[colname][i]])\\n table['parameter_name'] = np.array(table['parameter_name']).astype(str)\\n\\n # write to file\\n fsw_distortion_file = os.path.join(pre_delivery_dir, 'ifgs{}_distortion_tbl.txt'.format(aperture_name[3]))\\n comments = []\\n comments.append('FGS distortion coefficients for FSW')\\n comments.append('')\\n comments.append('Derived from SIAF distortion coefficients.')\\n comments.append('')\\n comments.append('Generated {} {}'.format(timestamp.isot, timestamp.scale))\\n comments.append('by {}'.format(username))\\n comments.append('')\\n table.meta['comments'] = comments\\n formats={'parameter_name': '%-20s', 'value': '%+2.6e'}\\n table.write(fsw_distortion_file, format='ascii.fixed_width',\\n delimiter=',', delimiter_pad=' ', bookend=False,\\n overwrite=True, formats=formats)\",\n \"def Rescale(self):\\r\\n picWidth,picHeight = self.oldSize = self.GetSizeTuple()\\r\\n bitmap = self.scaled = self.bitmap\\r\\n if not bitmap: return\\r\\n imgWidth,imgHeight = bitmap.GetWidth(),bitmap.GetHeight()\\r\\n if self.scaling == 2 or (self.scaling == 1 and (imgWidth > picWidth or imgHeight > picHeight)):\\r\\n image = bitmap.ConvertToImage()\\r\\n factor = min(1.0*picWidth/imgWidth,1.0*picHeight/imgHeight)\\r\\n newWidth,newHeight = int(factor*imgWidth),int(factor*imgHeight)\\r\\n self.scaled = image.Scale(newWidth,newHeight).ConvertToBitmap()\\r\\n #self.scaled = image.Scale(newWidth,newHeight,wx.IMAGE_QUALITY_HIGH ).ConvertToBitmap()\\r\",\n \"def fRes(self, mag, size, ps):\\n x = 2 * np.pi * mag / (size[0] * ps[0])\\n y = 2 * np.pi * mag / (size[1] * ps[1])\\n return [x, y]\",\n \"def __call__(self, results):\\n\\n for key in results.get('seg_fields', []):\\n if self.scale_factor != 1:\\n results[key] = general_ocr.imrescale(\\n results[key],\\n self.scale_factor,\\n interpolation='nearest',\\n backend=self.backend)\\n return results\",\n \"def fitfunc_2G1Ysq(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7):\\n \\n# if (a_x != 0.0):\\n if (True):\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\\n a_p5 * (1.0 - exp(-a_p6 * a_x**2))**2 * exp(-2.0 * a_p7 * a_x) / a_x**2)\\n else:\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))\",\n \"def fitfunc_2G1Y1Ysq(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7, a_p8, a_p9, a_p10):\\n \\n# if (a_x != 0.0):\\n if (True):\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(- a_p7 * a_x) / a_x +\\n a_p8 * (1.0 - exp(-a_p9 * a_x**2))**2 * exp(-2.0 * a_p10 * a_x) / a_x**2)\\n else:\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))\",\n \"def GCASFit(self):\\r\\n\\t\\t#run the scatteringPeakInfo method to retrieve various peak attributes \\r\\n\\t\\tself.scatteringPeakInfo()\\r\\n\\t\\t\\r\\n\\t\\t#set parameters for fitting\\r\\n\\t\\tbaseline = self.scatteringBaseline\\r\\n\\t\\tx_vals = np.array(self.getAcqPoints())\\r\\n\\t\\ty_vals = np.array(self.getScatteringSignal()\\t)\\r\\n\\t\\t\\r\\n\\t\\t#initial values for amplitude(a) center(u) and gauss width(sig)\\r\\n\\t\\tguess_a = self.scatteringMax \\r\\n\\t\\tguess_u = self.scatteringMaxPos\\r\\n\\t\\tguess_sig = 10\\r\\n\\t\\tp_guess = [53000,73,17, -0.031,-0.1]\\r\\n\\t\\t\\r\\n\\t\\tdef GCAS(x, a, xc, w, a3, a4):\\r\\n\\t\\t\\treturn baseline + (a /(w*math.sqrt(2*math.pi)))*np.exp(-((x-xc)/w)**2/2.)*(1+np.abs((a3/6)*(((x-xc)/w)**3-3.*((x-xc)/w))+ (a4/24)*( ((x-xc)/w)**4 -6.*((x-xc)/w)**3 + 3 ) ))\\r\\n\\t\\t\\t\\t\\t\\t\\r\\n\\t\\t#run the fitting\\r\\n\\t\\t#try:\\r\\n\\t\\tpopt, pcov = curve_fit(GCAS, x_vals, y_vals, p0=p_guess)\\r\\n\\t\\t#except:\\r\\n\\t\\t#\\tpopt, pcov = [np.nan, np.nan, np.nan, np.nan, np.nan], [np.nan, np.nan, np.nan, np.nan, np.nan] \\r\\n\\t\\t\\r\\n\\t\\tself.FF_scattering_amp = popt[0]\\r\\n\\t\\tself.FF_peak_pos = popt[1] \\r\\n\\t\\tself.FF_width = popt[2]\\r\\n\\t\\tfit_result = []\\r\\n\\t\\tfor x in x_vals:\\r\\n\\t\\t\\tfit_result.append(GCAS(x,popt[0],popt[1],popt[2],popt[3],popt[4]))\\r\\n\\t\\tself.FF_results = fit_result\",\n \"def aug_test(self, imgs, img_metas, templates, proposals=None, rescale=False):\\n # recompute feats to save memory\\n #y = self.extract_feats(imgs, templates)\\n proposal_list = self.aug_test_rpn(self.extract_feats(imgs, templates), img_metas, self.test_cfg.rpn)\\n rcnn_test_cfg = self.test_cfg.rcnn\\n aug_bboxes = []\\n aug_scores = []\\n for x, img_meta in zip(self.extract_feats(imgs, templates), img_metas):\\n # only one image in the batch\\n img_shape = img_meta[0]['img_shape']\\n scale_factor = img_meta[0]['scale_factor']\\n flip = img_meta[0]['flip']\\n\\n proposals = bbox_mapping(proposal_list[0][:, :4], img_shape, scale_factor, flip)\\n # \\\"ms\\\" in variable names means multi-stage\\n ms_scores = []\\n\\n rois = bbox2roi([proposals])\\n for i in range(self.num_stages):\\n bbox_head = self.bbox_head[i]\\n cls_score, bbox_pred = self._bbox_forward_test(i, x, rois)\\n ms_scores.append(cls_score)\\n\\n if i < self.num_stages - 1:\\n bbox_label = cls_score.argmax(dim=1)\\n rois = bbox_head.regress_by_class(rois, bbox_label, bbox_pred, img_meta[0])\\n\\n cls_score = sum(ms_scores) / float(len(ms_scores))\\n bboxes, scores = self.bbox_head[-1].get_det_bboxes(rois, cls_score, bbox_pred, img_shape, scale_factor, rescale=False, cfg=None)\\n aug_bboxes.append(bboxes)\\n aug_scores.append(scores)\\n\\n # after merging, bboxes will be rescaled to the original image size\\n merged_bboxes, merged_scores = merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)\\n det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,\\n rcnn_test_cfg.score_thr,\\n rcnn_test_cfg.nms,\\n rcnn_test_cfg.max_per_img)\\n\\n bbox_result = bbox2result(det_bboxes, det_labels, self.bbox_head[-1].num_classes)\\n return bbox_result\",\n \"def calibrate(self,(minX,minY,minZ),(maxX,maxY,maxZ),duration = 5,integer = True):\\n\\t\\tt0 = time.time()\\n\\t\\tminXYZ,maxXYZ = [2*31]*3,[-2**31]*3##+- inf...not nice but it will do...\\n\\t\\twhile time.time() - t0 < duration: ## Probably not the best guard\\n\\t\\t\\tself.refresh()\\n\\t\\t\\tpoints = self.coordinateTracker.getListOfCartesianCoordinates()\\n\\t\\t\\tminXYZ = [ min ([minXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\\n\\t\\t\\tmaxXYZ = [ max ([maxXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\\n\\t\\tfactor = max([abs(maxXYZ[i] - minXYZ[i]) for i in [0,1,2]])\\n\\t\\t\\n\\t\\tdef scale((x,y,z)):\\n\\t\\t\\t## Yeah, I know this /could/ be re-factored.\\n\\t\\t\\t## But this is simpler. \\n\\t\\t\\tif factor != 0:\\n\\t\\t\\t\\tx = float(x) - (minXYZ[0]+maxXYZ[0])/2 \\n\\t\\t\\t\\tx = x/factor\\n\\t\\t\\t\\tx = x*abs(maxX - minX)\\n\\t\\t\\t\\tx = x+(maxX + minX)/2\\n\\t\\t\\t\\n\\t\\t\\t\\ty = float(y) - (maxXYZ[1] + minXYZ[1])/2\\n\\t\\t\\t\\ty = y/factor\\n\\t\\t\\t\\ty = y*abs(maxY - minY)\\n\\t\\t\\t\\ty = y+(maxY + minY)/2\\n\\n\\t\\t\\t\\tz = float(z) - (maxXYZ[2]+ minXYZ[2])/2\\n\\t\\t\\t\\tz = z/factor\\n\\t\\t\\t\\tz = z*abs(maxZ - minZ)\\n\\t\\t\\t\\tz = z+(maxZ + minZ)/2\\n\\t\\t\\tif integer: return map(int,(x,y,z))\\n\\t\\t\\telse: return x,y,z\\n\\t\\tself.scale = scale\",\n \"def fullGaussFit(self):\\r\\n\\r\\n\\t\\t#run the scatteringPeakInfo method to retrieve various peak attributes \\r\\n\\t\\tself.scatteringPeakInfo()\\r\\n\\t\\t\\r\\n\\t\\t#set parameters for fitting\\r\\n\\t\\tbaseline = self.scatteringBaseline\\r\\n\\t\\tx_vals = self.getAcqPoints()\\r\\n\\t\\ty_vals = self.getScatteringSignal()\\t\\r\\n\\t\\t\\r\\n\\t\\t#initial values for amplitude(a) center(u) and gauss width(sig)\\r\\n\\t\\tguess_a = self.scatteringMax \\r\\n\\t\\tguess_u = self.scatteringMaxPos\\r\\n\\t\\tguess_sig = 10\\r\\n\\t\\tp_guess = [guess_a,guess_u,guess_sig]\\r\\n\\t\\t\\r\\n\\t\\tdef fullGauss(x, a, u, sig):\\r\\n\\t\\t\\treturn baseline+a*np.exp((-(x-u)**2)/(2*sig**2)) #Gaussian\\r\\n\\t\\t\\t#return baseline + (2*a/math.pi)*(sig/(4*(x-u)**2 + sig**2)) #Lorentzian - not good!\\r\\n\\t\\t\\t\\r\\n\\t\\t#run the fitting\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tpopt, pcov = curve_fit(fullGauss, x_vals, y_vals, p0=p_guess)\\r\\n\\t\\texcept:\\r\\n\\t\\t\\tpopt, pcov = [np.nan, np.nan, np.nan], [np.nan, np.nan, np.nan] \\r\\n\\t\\t\\r\\n\\t\\tself.FF_scattering_amp = popt[0]\\r\\n\\t\\tself.FF_peak_pos = popt[1] \\r\\n\\t\\tself.FF_width = popt[2]\\r\\n\\t\\tfit_result = []\\r\\n\\t\\tfor x in x_vals:\\r\\n\\t\\t\\tfit_result.append(fullGauss(x,popt[0],popt[1],popt[2]))\\r\\n\\t\\tself.FF_results = fit_result\",\n \"def _interp_aberrations_bilinear(aberrations, x_pos, y_pos, SCA_pos):\\n min_x = np.min(x_pos)\\n min_y = np.min(y_pos)\\n max_x = np.max(x_pos)\\n max_y = np.max(y_pos)\\n x_frac = (SCA_pos.x - min_x) / (max_x - min_x)\\n y_frac = (SCA_pos.y - min_y) / (max_y - min_y)\\n lower_x_lower_y_ab = aberrations[(x_pos==min_x) & (y_pos==min_y), :]\\n lower_x_upper_y_ab = aberrations[(x_pos==min_x) & (y_pos==max_y), :]\\n upper_x_lower_y_ab = aberrations[(x_pos==max_x) & (y_pos==min_y), :]\\n upper_x_upper_y_ab = aberrations[(x_pos==max_x) & (y_pos==max_y), :]\\n interp_ab = (1.0-x_frac)*(1.0-y_frac)*lower_x_lower_y_ab + \\\\\\n (1.0-x_frac)*y_frac*lower_x_upper_y_ab + \\\\\\n x_frac*(1.0-y_frac)*upper_x_lower_y_ab + \\\\\\n x_frac*y_frac*upper_x_upper_y_ab\\n\\n return interp_ab.flatten()\",\n \"def _interpolation(self, video):\\n self.F_int = []\\n self.mgrid_0 = []\\n self.mgrid_1 = []\\n for p in range(video.points.shape[0]):\\n _m_0, _m_1 = np.meshgrid(self.extended_points_0[p], self.extended_points_1[p])\\n _F_int = interp2d(self.extended_points_0[p], self.extended_points_1[p], video.mraw[0, _m_0, _m_1], kind='cubic')\\n self.F_int.append(_F_int)\\n\\n m_0, m_1 = np.meshgrid(self.extended_points_0[p, self.pad:-self.pad], self.extended_points_1[p, self.pad:-self.pad])\\n self.mgrid_0.append(m_0)\\n self.mgrid_1.append(m_1)\",\n \"def preprocess(self):\\n\\n if self.x_range == None:\\n x_min = min(np.min(self.fx), np.min(self.gx))\\n x_max = max(np.max(self.fx), np.max(self.gx))\\n self.x_range = [x_min,x_max]\\n\\n f_inter = interpolate.interp1d(self.fx, self.fy, 'cubic', fill_value = 'extrapolate')\\n g_inter = interpolate.interp1d(self.gx, self.gy, 'cubic', fill_value = 'extrapolate')\\n fgx_new = np.linspace(self.x_range[0], self.x_range[1], self.N)\\n fy_new = f_inter(fgx_new)\\n gy_new = g_inter(fgx_new)\\n\\n self.fx, self.fy = fgx_new, fy_new\\n self.gx, self.gy = fgx_new, gy_new\",\n \"def __getPressureCalibrationCoefficients(self):\\n src13 = self.read_byte_data(self.address, 0x13)\\n src14 = self.read_byte_data(self.address, 0x14)\\n src15 = self.read_byte_data(self.address, 0x15)\\n src16 = self.read_byte_data(self.address, 0x16)\\n src17 = self.read_byte_data(self.address, 0x17)\\n src18 = self.read_byte_data(self.address, 0x18)\\n src19 = self.read_byte_data(self.address, 0x19)\\n src1A = self.read_byte_data(self.address, 0x1A)\\n src1B = self.read_byte_data(self.address, 0x1B)\\n src1C = self.read_byte_data(self.address, 0x1C)\\n src1D = self.read_byte_data(self.address, 0x1D)\\n src1E = self.read_byte_data(self.address, 0x1E)\\n src1F = self.read_byte_data(self.address, 0x1F)\\n src20 = self.read_byte_data(self.address, 0x20)\\n src21 = self.read_byte_data(self.address, 0x21)\\n c00 = (src13 << 12) | (src14 << 4) | (src15 >> 4)\\n c00 = getTwosComplement(c00, 20)\\n c10 = ((src15 & 0x0F) << 16) | (src16 << 8) | src17\\n c10 = getTwosComplement(c10, 20)\\n c20 = (src1C << 8) | src1D\\n c20 = getTwosComplement(c20, 16)\\n c30 = (src20 << 8) | src21\\n c30 = getTwosComplement(c30, 16)\\n c01 = (src18 << 8) | src19\\n c01 = getTwosComplement(c01, 16)\\n c11 = (src1A << 8) | src1B\\n c11 = getTwosComplement(c11, 16)\\n c21 = (src1E < 8) | src1F\\n c21 = getTwosComplement(c21, 16)\\n return c00, c10, c20, c30, c01, c11, c21\",\n \"def _batch_resize(self, ims, res, strategy='nearest'):\\n order = {'nearest': 0, 'bilinear': 1, 'bicubic': 3}[strategy]\\n bs = ims.shape[0]\\n out = []\\n log.info('Input ims shape: %s' % repr(ims.shape))\\n has_extra_dim = len(ims.shape) == 4\\n if not has_extra_dim:\\n ims = ims[..., np.newaxis]\\n h, w = ims.shape[1:3]\\n for i in range(bs):\\n o = interpolation.zoom(\\n ims[i, ...], [res[0] / h, res[1] / w, 1.0], np.float32, order=order)\\n out.append(o)\\n out = np.stack(out)\\n if not has_extra_dim:\\n out = np.reshape(out, out.shape[:-1])\\n return out\",\n \"def optscl(args=None):\\n\\n parser = argparse.ArgumentParser(description=optscl.__doc__)\\n\\n # positional\\n parser.add_argument('map', help='name of the input map')\\n parser.add_argument('data', help='data file')\\n parser.add_argument('scaled', help='scaled output map')\\n\\n # optional\\n parser.add_argument(\\n '-i', dest='iscale', action='store_true',\\n help='individual scaling (else a single global scale)'\\n )\\n\\n # OK, done with arguments.\\n args = parser.parse_args()\\n\\n # load map and data\\n dmap = doppler.Map.rfits(doppler.afits(args.map))\\n data = doppler.Data.rfits(doppler.afits(args.data))\\n\\n nscale = 0\\n for image in dmap.data:\\n nscale += len(image.wave)\\n\\n if args.iscale and nscale > 1:\\n # in this option we try to individually scale the images\\n mtemp = copy.deepcopy(dmap)\\n flux, ferr = retarr(data)\\n wgt = np.empty_like(ferr)\\n ok = ferr > 0\\n wgt[ok] = 1./ferr[ok]**2\\n\\n # create indices to access the scale factors\\n # save old scale factors\\n sindices = []\\n osfacs = []\\n for ni, image in enumerate(dmap.data):\\n for ns in range(len(image.scale)):\\n sindices.append((ni,ns))\\n osfacs.append(image.scale[ns])\\n image.scale[ns] = 0.\\n\\n # compute a set of data vectors with each scale factor\\n # set to 1 with all others set = 0, one by one\\n dvecs = []\\n for ni, ns in sindices:\\n dmap.data[ni].scale[ns] = 1.0\\n\\n # compute data equivelent to data\\n dvec = copy.deepcopy(data)\\n doppler.comdat(dmap, dvec)\\n dvecs.append(retarr(dvec)[0])\\n\\n dmap.data[ni].scale[ns] = 0.0\\n\\n # compile least-squares matrix & right-hand vector\\n nvec = len(dvecs)\\n A = np.empty((nvec,nvec))\\n b = np.empty((nvec))\\n for j in range(nvec):\\n b[j] = (wgt[ok]*dvecs[j]*flux[ok]).sum()\\n for i in range(j+1):\\n A[j][i] = (wgt[ok]*dvecs[j]*dvecs[i]).sum()\\n A[i][j] = A[j][i]\\n\\n nsfacs = linalg.solve(A,b)\\n ocalc = np.zeros_like(flux)\\n ncalc = np.zeros_like(flux)\\n for j in range(nvec):\\n ocalc += osfacs[j]*dvecs[j]\\n ncalc += nsfacs[j]*dvecs[j]\\n\\n ndata = flux.size\\n cold = (wgt*(flux-ocalc)**2).sum()/ndata\\n cnew = (wgt*(flux-ncalc)**2).sum()/ndata\\n print('Chi**2/ndata (before) =',cold,' (after) =',cnew)\\n\\n # set the new scale factors in place\\n i = 0\\n for ni, ns in sindices:\\n dmap.data[ni].scale[ns] = nsfacs[i]\\n i += 1\\n\\n # set the new scale factors in place\\n i = 0\\n for ni, ns in sindices:\\n dmap.data[ni].scale[ns] = nsfacs[i]\\n i += 1\\n\\n # set the singleton scale factors = 1 by\\n # re-scaling the corresponding images instead.\\n for ni, image in enumerate(dmap.data):\\n if len(image.scale) == 1:\\n image.data *= image.scale[0]\\n image.scale[0] = 1\\n\\n else:\\n # compute data equivalent to data\\n dcalc = copy.deepcopy(data)\\n doppler.comdat(dmap, dcalc)\\n\\n # compute optimum scale factor.\\n sum0 = 0.\\n sum1 = 0.\\n sum2 = 0.\\n ndata = 0\\n for cspec, dspec in zip(dcalc.data, data.data):\\n ok = dspec.ferr > 0.\\n sum0 += ((dspec.flux[ok]/dspec.ferr[ok])**2).sum()\\n sum1 += ((cspec.flux[ok]/dspec.ferr[ok])*(dspec.flux[ok]/dspec.ferr[ok])).sum()\\n sum2 += ((cspec.flux[ok]/dspec.ferr[ok])**2).sum()\\n ndata += dspec.ferr.size\\n\\n scale = sum1 / sum2\\n cold = cnew = 0\\n for cspec, dspec in zip(dcalc.data, data.data):\\n ok = dspec.ferr > 0.\\n cold += (((dspec.flux[ok]-cspec.flux[ok])/dspec.ferr[ok])**2).sum()\\n cnew += (((dspec.flux[ok]-scale*cspec.flux[ok])/dspec.ferr[ok])**2).sum()\\n\\n print('ndata =',ndata)\\n print('Optimum scale factor =',scale)\\n print('Chi**2/ndata (before) =',cold/ndata,' (after) =',cnew/ndata)\\n\\n # scale images and write out\\n for image in dmap.data:\\n image.data *= scale\\n\\n # Write to a fits file\\n dmap.wfits(doppler.afits(args.scaled))\",\n \"def _psf_grid(self, xg, yg, r_max=1.):\\n ratio = self.params['ratio']\\n s = self.params['s']\\n\\n ng = xg.size\\n ne = self.element.shape[0]\\n d_mat = np.zeros((ng, ne))\\n r_mat = r_max * ratio\\n # loop over all elements\\n for i in range(ne):\\n ei = self.element[i, :]\\n xy = np.mean(self.node[ei], axis=0)\\n # there may be bias between grid and center of a element\\n r = self._distance2d(xg, yg, center=xy)\\n f = 1./(1.+np.exp(s*np.abs(r))/np.exp(s*r_mat))\\n d_mat[:, i] = f\\n return d_mat\",\n \"def get_scaled_image(self, min_width=1024):\\n self.dispersion = self.image.getCalibration().pixelWidth\\n self.offset = self.image.getCalibration().xOrigin\\n binning = 1\\n while binning * min_width < self.image.getWidth():\\n binning *= 2\\n if binning > 1:\\n binning /= 2\\n IJ.run(self.image, 'Select None', '')\\n new_image = self.image.crop()\\n IJ.run(new_image, 'Bin...', 'x=%d y=%d binning=Average' %\\n (binning, binning))\\n self.dispersion *= binning\\n self.offset /= binning\\n self.image = new_image\\n return new_image\",\n \"def scale_data(x, y, x_scale_f = '../saved_models/scalers/9_params_21_2_x_scaler.pkl', y_scale_f = '../saved_models/scalers/9_params_21_2_y_scaler.pkl', par_slice = range(7) + range(8,9)):\\n\\tx_scaler = sklearn.externals.joblib.load(x_scale_f)\\n\\ty_scaler = sklearn.externals.joblib.load(y_scale_f)\\n\\tx_scaler.transform(x)\\n\\ty_scaler.transform(y)\\n\\tx = x[:,par_slice] \\n\\treturn x, y, x_scaler, y_scaler\",\n \"def testScaleZeroPoint(self):\\n\\n ZEROPOINT = 27\\n self.sctrl = afwMath.StatisticsControl()\\n self.sctrl.setNanSafe(True)\\n\\n config = SpatialScaleZeroPointTask.ConfigClass()\\n config.zeroPoint = ZEROPOINT\\n config.interpStyle = \\\"CONSTANT\\\"\\n config.selectFluxMag0.retarget(SelectLsstSimFluxMag0Task)\\n config.selectFluxMag0.database = \\\"test_select_lsst_images\\\"\\n zpScaler = SpatialScaleZeroPointTask(config=config)\\n\\n \\\"\\\"\\\" Note: this order does not properly retarget\\n zpScaler = ScaleZeroPointTask()\\n zpScaler.config.doInterpScale = True\\n zpScaler.config.zeroPoint = ZEROPOINT\\n zpScaler.config.interpStyle = \\\"CONSTANT\\\"\\n zpScaler.config.selectFluxMag0.retarget(SelectLsstSimFluxMag0Task)\\n zpScaler.config.selectFluxMag0.database = \\\"test_select_lsst_images\\\"\\n \\\"\\\"\\\"\\n\\n outCalib = zpScaler.getCalib()\\n self.assertAlmostEqual(outCalib.getMagnitude(1.0), ZEROPOINT)\\n\\n exposure = self.makeTestExposure(10, 10)\\n # create dataId for exposure. Visit is only field needed. Others ignored.\\n exposureId = {'ignore_fake_key': 1234, 'visit': 882820621}\\n\\n # API for computImageScale() takes a dataRef not a dataId.\\n exposureFakeDataRef = WrapDataId(exposureId)\\n # test methods: computeImageScale(), scaleMaskedImage(), getInterpImage()\\n imageScaler = zpScaler.computeImageScaler(exposure, exposureFakeDataRef)\\n scaleFactorIm = imageScaler.getInterpImage(exposure.getBBox())\\n predScale = np.mean(imageScaler._scaleList) # 0.011125492863357\\n\\n self.assertAlmostEqual(afwMath.makeStatistics(scaleFactorIm, afwMath.VARIANCE, self.sctrl).getValue(),\\n 0.0)\\n self.assertAlmostEqual(afwMath.makeStatistics(scaleFactorIm, afwMath.MEAN, self.sctrl).getValue(),\\n predScale)\\n\\n mi = exposure.getMaskedImage()\\n imageScaler.scaleMaskedImage(mi)\\n self.assertAlmostEqual(mi.get(1, 1)[0], predScale) # check image plane scaled\\n self.assertAlmostEqual(mi.get(1, 1)[2], predScale**2) # check variance plane scaled\\n\\n exposure.setCalib(zpScaler.getCalib())\\n self.assertAlmostEqual(exposure.getCalib().getFlux(ZEROPOINT), 1.0)\",\n \"def scale_psf_fluxes(frame, psf):\\n scale_factor = (max_flux(frame) / max_flux(psf))\\n return psf.profile * scale_factor, psf.fluxes * scale_factor\",\n \"def __call__(self, features: List[List[float]]) -> List[List[float]]:\\n self.count += 1\\n if self.count <= 1:\\n self.feature_fix = features\\n self.gmin = np.amin(features, axis=0) \\n self.gmax = np.amax(features, axis=0) \\n self.gdiff = np.subtract(self.gmax,self.gmin)\\n \\n features_scale = np.full((np.array(features).shape[0],np.array(features).shape[1]), np.nan)\\n for i in range(np.array(features).shape[0]):\\n for j in range(np.array(features).shape[1]):\\n features_scale[i,j] = (np.array(features)[i,j] - self.gmin[j])/self.gdiff[j]\\n \\n return features_scale\",\n \"def rescale(self):\\n # forecast on real data, don't need this anymore\\n pass\",\n \"def ex2d(image, ivar, psf, specrange, wavelengths, xyrange=None,\\n full_output=False, regularize=0.0):\\n\\n #- Range of image to consider\\n waverange = (wavelengths[0], wavelengths[-1])\\n \\n if xyrange is None:\\n xmin, xmax, ymin, ymax = xyrange = psf.xyrange(specrange, waverange)\\n image = image[ymin:ymax, xmin:xmax]\\n ivar = ivar[ymin:ymax, xmin:xmax]\\n else:\\n xmin, xmax, ymin, ymax = xyrange\\n\\n nx, ny = xmax-xmin, ymax-ymin\\n npix = nx*ny\\n \\n nspec = specrange[1] - specrange[0]\\n nwave = len(wavelengths)\\n \\n #- Solve AT W pix = (AT W A) flux\\n \\n #- Projection matrix and inverse covariance\\n A = psf.projection_matrix(specrange, wavelengths, xyrange)\\n\\n #- Pixel weights matrix\\n w = ivar.ravel()\\n W = spdiags(ivar.ravel(), 0, npix, npix)\\n\\n #-----\\n #- Extend A with an optional regularization term to limit ringing.\\n #- If any flux bins don't contribute to these pixels,\\n #- also use this term to constrain those flux bins to 0.\\n \\n #- Original: exclude flux bins with 0 pixels contributing\\n # ibad = (A.sum(axis=0).A == 0)[0]\\n \\n #- Identify fluxes with very low weights of pixels contributing \\n fluxweight = W.dot(A).sum(axis=0).A[0]\\n minweight = 0.01*np.max(fluxweight)\\n ibad = fluxweight < minweight\\n \\n #- Add regularization of low weight fluxes\\n I = regularize*scipy.sparse.identity(nspec*nwave)\\n I.data[0,ibad] = minweight - fluxweight[ibad]\\n \\n #- Only need to extend A if regularization is non-zero\\n if np.any(I.data):\\n pix = np.concatenate( (image.ravel(), np.zeros(nspec*nwave)) )\\n Ax = scipy.sparse.vstack( (A, I) )\\n wx = np.concatenate( (w, np.ones(nspec*nwave)) )\\n else:\\n pix = image.ravel()\\n Ax = A\\n wx = w\\n\\n #- Inverse covariance\\n Wx = spdiags(wx, 0, len(wx), len(wx))\\n iCov = Ax.T.dot(Wx.dot(Ax))\\n \\n #- Solve (image = A flux) weighted by Wx:\\n #- A^T W image = (A^T W A) flux = iCov flux \\n y = Ax.T.dot(Wx.dot(pix))\\n \\n xflux = spsolve(iCov, y).reshape((nspec, nwave))\\n\\n #- Solve for Resolution matrix\\n try:\\n R, fluxivar = resolution_from_icov(iCov)\\n except np.linalg.linalg.LinAlgError, err:\\n outfile = 'LinAlgError_{}-{}_{}-{}.fits'.format(specrange[0], specrange[1], waverange[0], waverange[1])\\n print \\\"ERROR: Linear Algebra didn't converge\\\"\\n print \\\"Dumping {} for debugging\\\".format(outfile)\\n import fitsio\\n fitsio.write(outfile, image, clobber=True)\\n fitsio.write(outfile, ivar, extname='IVAR')\\n fitsio.write(outfile, A.data, extname='ADATA') \\n fitsio.write(outfile, A.indices, extname='AINDICES')\\n fitsio.write(outfile, A.indptr, extname='AINDPTR')\\n fitsio.write(outfile, iCov.toarray(), extname='ICOV')\\n raise err\\n \\n #- Convolve with Resolution matrix to decorrelate errors\\n fluxivar = fluxivar.reshape((nspec, nwave))\\n rflux = R.dot(xflux.ravel()).reshape(xflux.shape)\\n\\n if full_output:\\n results = dict(flux=rflux, ivar=fluxivar, R=R, xflux=xflux, A=A)\\n results['iCov'] = iCov\\n return results\\n else:\\n return rflux, fluxivar, R\",\n \"def apply_gaussian_resolution(self,params,data,fwhm=1,dE=0.01,E_max=100):\\n print('\\\\n################### CONVOLUTION #####################\\\\n')\\n print(f'\\\\n\\\\tConvolution with Gaussian function, FWHM = {fwhm} meV\\\\n')\\n\\n data.fwhm = fwhm\\n c = fwhm/2.35482\\n\\n data.dE = dE\\n data.E_max = E_max\\n data.spectra_E = np.arange(0,data.E_max+data.dE,data.dE)\\n data.spectra_num_E = len(data.spectra_E)\\n data.spectra = np.zeros((data.spectra_num_E,params.num_Qpoints))\\n data.smooth_spectra = np.zeros((data.spectra_num_E,params.num_Qpoints))\\n structure_factors = []\\n energies = []\\n\\n ### sum intensity of degenerate bands\\n if params.sum_degenerate_bands == True:\\n print('\\\\n\\\\tSumming degenerate bands before convolution (using convolution dE as tolerance)\\\\n')\\n for q in range(params.num_Qpoints):\\n sfac = data.structure_factors[:,q]\\n energy = data.frequencies[f'{q}']\\n reduced_energies = []\\n summed_sfac = []\\n while True:\\n if len(energy) == 0:\\n break\\n test_energy = energy[0]\\n reduced_energies.append(test_energy)\\n indicies = np.intersect1d(np.argwhere(energy <= (test_energy+data.dE)),\\n np.argwhere(energy > (test_energy-data.dE)))\\n summed_sfac.append(sfac[indicies].sum())\\n sfac = np.delete(sfac,indicies)\\n energy = np.delete(energy,indicies)\\n energies.append(reduced_energies)\\n structure_factors.append(summed_sfac)\\n else:\\n print('\\\\n\\\\tWARNING: You should definitely sum degenerate bands!!!\\\\n')\\n for q in range(params.num_Qpoints):\\n energies.append(data.frequencies[f'{q}'])\\n structure_factors.append(data.structure_factors[:,q])\\n\\n ### populate array for heatmap\\n ### try statement takes care of negative energies\\n for q in range(params.num_Qpoints):\\n for b in range(len(structure_factors[q][:])):\\n try: # if there are negative modes, argwhere returns an empty vector and the slice crashes\\n data.spectra[np.argwhere(data.spectra_E <= \\n energies[q][b]).max(),q] = structure_factors[q][b]\\n except:\\n continue\\n\\n if params.bose_factor == True:\\n print('\\\\n\\\\tWARNING: Bose factor isnt verified. Need to compare to SNAXS.\\\\n')\\n if params.temperature < 5:\\n temperature = 5\\n else:\\n temperature = params.temperature\\n inds = np.argwhere(data.spectra_E <= 0.5)\\n tmp_e = np.copy(data.spectra_E)\\n tmp_e[inds] = 0.5\\n bose = 1+1/(np.exp(tmp_e/(constants.kb*1000*temperature))-1)\\n bose = np.tile(bose.reshape((data.spectra_num_E,1)),reps=(1,params.num_Qpoints))\\n data.spectra = np.multiply(data.spectra,bose)\\n data.spectra = data.spectra/np.max(data.spectra)\\n\\n ### gaussian convolution using for loops, slow but very little memory utilization\\n g_energy = np.append(data.spectra_E-data.spectra_E.max(),data.spectra_E[1:])\\n gaussian = np.exp(-0.5*g_energy**2/c**2)/c/np.sqrt(2*np.pi)\\n gaussian = np.tile(gaussian.reshape((gaussian.shape[0],1)),(1,data.num_Qpoints))\\n tmp = np.append(data.spectra,data.spectra,axis=0)[1:,:]\\n for e in range(data.spectra_num_E):\\n if e%50 == 0:\\n print(f'\\\\t------ {e}/{data.spectra_num_E} -------')\\n data.smooth_spectra[e,:] = np.trapz(tmp*np.roll(gaussian,shift=e,axis=0),g_energy,axis=0)\\n print('\\\\n\\\\tDone convolving!\\\\n')\\n data.smooth_spectra = data.smooth_spectra/np.max(data.smooth_spectra)\\n\\n# if params.random_background == True:\\n# data.smooth_spectra = data.smooth_spectra+(np.random.normal(0,1,\\n# (data.smooth_spectra.shape[0],data.smooth_spectra.shape[1])))*0.001\\n \\n plt.imshow(data.smooth_spectra,origin='lower',aspect='auto',cmap='hot')\\n plt.show()\",\n \"def fitfunc_2G2Y(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7, a_p8, a_p9, a_p10):\\n \\n# if (a_x != 0.0):\\n if (True):\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(-a_p7 * a_x) / a_x +\\n a_p8 * (1.0 - exp(-a_p9 * a_x**2)) * exp(-a_p10 * a_x) / a_x)\\n else:\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))\",\n \"def scale(self):\",\n \"def getBeamplotRes(pBeam, mapper, PALC_config, SFP_config, gamma_n, plt_ranges, f, ind_f):\\n # Calculation\\n p_SPL, X, Y = calcBeamplot(PALC_config, gamma_n, plt_ranges, f, \\\\\\n np.array(SFP_config.dir_meas[:,ind_f]), \\\\\\n np.array(SFP_config.dir_meas_deg[:,1]))\\n high_ind = np.argwhere(p_SPL > 100)\\n low_ind = np.argwhere(p_SPL < 50)\\n for n in range(np.shape(high_ind)[0]):\\n p_SPL[high_ind[n,0], high_ind[n,1]] = 100\\n for n in range(np.shape(low_ind)[0]):\\n p_SPL[low_ind[n,0], low_ind[n,1]] = 50\\n mapper.low = np.amin(p_SPL)\\n mapper.high = np.amax(p_SPL) \\n return p_SPL\",\n \"def read_images_gen_cal(self, path: str) -> dict:\\n image_files = []\\n # read in all image paths (for png and jpgs)\\n image_files.extend(glob.glob(os.path.join(path, '*.png')))\\n image_files.extend(glob.glob(os.path.join(path, '*.jpg')))\\n\\n if len(image_files) <= 0:\\n raise FileNotFoundError('Could not find any image files for camera calibration (png, jppgs supported!')\\n\\n # preparation of the 'real world' points like in CarND-Camera-Calibration repository ipynb!\\n syn_objp = np.zeros((self._chessboard_shape[1] * self._chessboard_shape[0], 3), np.float32)\\n syn_objp[:, :2] = np.mgrid[0:self._chessboard_shape[0], 0:self._chessboard_shape[1]].T.reshape(-1, 2)\\n\\n # Arrays to store all points pairs from the images. They will be used for calibration computation.\\n objpoints = []\\n imgpoints = []\\n img_size = None\\n\\n for file_name in image_files:\\n img = cv2.imread(file_name)\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # remember shape of images\\n if img_size is None:\\n img_size = (gray.shape[1], gray.shape[0])\\n\\n # Chessboard detection\\n res, chess_pts = cv2.findChessboardCorners(gray, self._chessboard_shape, None)\\n # Debug\\n # painted = cv2.drawChessboardCorners(img, self._chessboard_shape, chess_pts, res)\\n if res:\\n objpoints.append(syn_objp)\\n imgpoints.append(chess_pts)\\n\\n if len(objpoints) <= 0:\\n raise ValueError('No Chessboard detected on images.')\\n\\n # Do camera calibration given object points and image points\\n ret, mtx, dist, _, _ = cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)\\n if not ret:\\n raise ValueError('cv2.calibrateCamera() failed.')\\n\\n # prepare return value dictionary\\n ret = {'mtx': mtx, 'dist': dist}\\n return ret\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def RBFLS(rbfParam, pd, x, y, f, X, Y \\\\\\n, xmc = [], ymc = [], ell = [], w = [], ELL = [], W = []) :\\n xmc, ymc, ell, w, ELL, W = assignDefaults(x, y, xmc, ymc, ell, w, ELL, W)\\n \\n if (len(xmc) < 2) and (len(ymc) < 2) :\\n \\n raise ValueError(\\\"Need at least 4 subregions (total) for RBF-LS.\\\")\\n \\n else :\\n \\n approx = np.zeros(len(X), float)\\n approx_sparse = np.zeros(len(x), float)\\n \\n for i in range(len(xmc)) :\\n IND = inSquare(x, y, xmc[i], ymc[i], ELL, W)\\n p = poly(x[IND], y[IND], pd)\\n ind = inSquare(x[IND], y[IND], xmc[i], ymc[i], ell, w)\\n xc = x[IND][ind]\\n yc = y[IND][ind]\\n A = rbf(x[IND], y[IND], xc, yc, rbfParam)\\n A = np.hstack((A, p))\\n lam = np.linalg.lstsq(A, f[IND], rcond=None)[0]\\n approx_sparse[IND] = A.dot(lam).flatten()\\n IND = inSquare(X, Y, xmc[i], ymc[i], ell, w)\\n A = rbf(X[IND], Y[IND], xc, yc, rbfParam)\\n B = poly(X[IND], Y[IND], pd)\\n B = np.hstack((A, B))\\n approx[IND] = B.dot(lam).flatten()\\n \\n return approx, approx_sparse, lam\",\n \"def fit(self, GRFData):\\n\\n self.__is_valid_dict(GRFData)\\n for component in self.comp_list:\\n self.scaler[component].fit(np.reshape(GRFData[component], (-1, 1)))\\n self.isFitted = True\",\n \"def get_scale(self, fe_params, cov_re):\\n\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n\\n qf = 0.\\n for k in range(self.n_groups):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n\\n # The residuals\\n expval = np.dot(exog, fe_params)\\n resid = self.endog_li[k] - expval\\n\\n mat = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n resid)\\n qf += np.dot(resid, mat)\\n\\n if self.reml:\\n qf /= (self.n_totobs - self.k_fe)\\n else:\\n qf /= self.n_totobs\\n\\n return qf\",\n \"def _run_rbf_interpolation(out_dir, layer, bounds, function, smooth):\\n # if running scipy methods prepend root dir to out path\\n out_dir = OPJ(path_root, out_dir)\\n if not os.path.isdir(out_dir):\\n print(\\n os.path.abspath(out_dir),\\n ' does not exist, creating directory.\\\\n'\\n )\\n Path(out_dir).mkdir(parents=True, exist_ok=True)\\n\\n out_file = OPJ(\\n out_dir, \\n '{time_agg}.tiff'.format(time_agg=layer)\\n )\\n print(\\n '\\\\nInterpolating {g} point bias ratios for: {t}\\\\n'.\\\\\\n format(g=grid_var, t=layer),\\n 'Using the \\\"{}\\\" method\\\\n'.format(function),\\n 'Resolution (pixel size) of output raster: {} degrees'.format(res)\\n )\\n print( \\n 'GeoTIFF raster will be saved to: \\\\n',\\n os.path.abspath(out_file)\\n )\\n\\n\\n # get grid extent based on station locations in CSV\\n if not bounds:\\n bounds = get_subgrid_bounds(in_path, buffer=buffer, grid_res=CS) \\n lon_min, lon_max, lat_min, lat_max = bounds\\n # fix any minor adjustments to make raster fit gridMET fishnet extent\\n # if scale_factor=1 make sure raster pixels align exactly w/gridcells\\n # raster extent may exceed fishnet grid to fill gaps for zonal stats\\n if scale_factor:\\n nxcells = abs(lon_min-lon_max) / (CS*scale_factor)\\n nycells = abs(lat_min-lat_max) / (CS*scale_factor)\\n remainder_x = int(nxcells) - nxcells\\n remainder_y = int(nycells) - nycells\\n if abs(remainder_x) > CS:\\n remainder_x -= CS * (remainder_x / CS) \\n if abs(remainder_y) > CS:\\n remainder_y -= CS * (remainder_y / CS)\\n lon_min -= remainder_x\\n lon_max += CS\\n lat_min -= remainder_y\\n lat_min -= CS\\n \\n # check if layer is in summary CSV \\n existing_layers = pd.read_csv(in_path).columns\\n if not layer in existing_layers:\\n print('Column {} does not exist in input CSV:\\\\n {}'.format(\\n layer, in_path),\\n '\\\\nSkipping interpolation.'\\n )\\n return\\n \\n # get point station data from summary CSV\\n in_df = pd.read_csv(in_path, na_values=[-999])\\n lon_pts, lat_pts = in_df.STATION_LON.values, in_df.STATION_LAT.values\\n values = in_df[layer].values\\n \\n # mask out stations with missing data\\n if in_df[layer].isnull().sum() > 0:\\n mask = in_df[layer].notnull()\\n n_missing = in_df[layer].isna().sum()\\n # if one point or less data points exists exit\\n if len(mask) == n_missing or len(values) - n_missing == 1:\\n print('Missing sufficient point data for variable: {} {}'.\\\\\\n format(grid_var, layer),\\n '\\\\nNeed at least two stations with data, skipping.')\\n return\\n print('Warning:\\\\n',\\n 'Data missing for {} of {} stations for variable: {} {}'.\\\\\\n format(n_missing, len(values), grid_var, layer),\\n '\\\\nproceeding with interpolation.')\\n # get locations where ratio is not nan\\n values = values[mask]\\n lon_pts = lon_pts[mask]\\n lat_pts = lat_pts[mask]\\n\\n nx_cells = int(np.round(np.abs((lon_min - lon_max) / CS)))\\n ny_cells = int(np.round(np.abs((lat_min - lat_max) / CS)))\\n # rbf requires uniform grid (n X n) so \\n # extend short dimension and clip later \\n nx_cells_out = copy.copy(nx_cells)\\n ny_cells_out = copy.copy(ny_cells)\\n # gdal requires \\\"upper left\\\" corner coordinates\\n lat_max_out = copy.copy(lat_max)\\n lon_max_out = copy.copy(lon_max)\\n # extend short dimension to make square grid\\n if not nx_cells == ny_cells:\\n diff = np.abs(nx_cells - ny_cells)\\n if nx_cells > ny_cells:\\n lat_max += diff * CS\\n ny_cells += diff\\n else:\\n lon_max += diff * CS\\n nx_cells += diff\\n\\n if scale_factor == 1:\\n # make finer/coarse grid by scale factor\\n lons = np.linspace(lon_min, lon_max, \\n int(np.round(nx_cells/scale_factor))-1)\\n lats = np.linspace(lat_min, lat_max, \\n int(np.round(ny_cells/scale_factor))-1)\\n # extent for original created by spatial.build_subgrid\\n # add one to make sure raster covers full extent\\n lons_out = np.linspace(lon_min, lon_max_out, \\n int(np.round(nx_cells_out/scale_factor))-1)\\n lats_out = np.linspace(lat_min, lat_max_out, \\n int(np.round(ny_cells_out/scale_factor))-1)\\n\\n else:\\n # add one extra cell to cover grid buffer extent for upscaling\\n # raster extent always >= grid buffer\\n lons = np.linspace(lon_min, lon_max, \\n int(np.round(nx_cells/scale_factor)))\\n lats = np.linspace(lat_min, lat_max, \\n int(np.round(ny_cells/scale_factor)))\\n lons_out = np.linspace(lon_min, lon_max_out, \\n int(np.round(nx_cells_out/scale_factor)))\\n lats_out = np.linspace(lat_min, lat_max_out, \\n int(np.round(ny_cells_out/scale_factor)))\\n\\n # if function was 'linear_rbf' \\n function = function.replace('_rbf', '')\\n # make sampling square grid\\n XI, YI = np.meshgrid(lons, lats)\\n # apply rbf interpolation\\n rbf = Rbf(lon_pts, lat_pts, values, function=function, smooth=smooth)\\n ZI = rbf(XI, YI)\\n # clip to original extent, rbf array flips axes, and row order... \\n ZI_out = ZI[0:len(lats_out),0:len(lons_out)]\\n ZI_out = np.flip(ZI_out,axis=0)\\n\\n #### save scipy interpolated data as raster \\n pixel_size = CS * scale_factor\\n # number of pixels in each direction\\n x_size = len(lons_out)\\n y_size = len(lats_out)\\n # set geotransform info\\n gt = [\\n lon_min,\\n pixel_size,\\n 0,\\n lat_max_out,\\n 0,\\n -pixel_size\\n ]\\n # make geotiff raster\\n driver = gdal.GetDriverByName('GTiff')\\n ds = driver.Create(\\n out_file,\\n x_size, \\n y_size, \\n 1, \\n gdal.GDT_Float32, \\n )\\n # set projection geographic lat/lon WGS 84\\n srs = osr.SpatialReference()\\n srs.ImportFromEPSG(4326)\\n ds.SetProjection(srs.ExportToWkt())\\n # assign spatial dimensions \\n ds.SetGeoTransform(gt)\\n outband = ds.GetRasterBand(1)\\n # save rbf interpolated array as geotiff raster close\\n outband.WriteArray(ZI_out)\\n ds = None\\n\\n # calc residuals add to shapefile and in_path CSV, move shape to out_dir\\n # only residuals for bias ratios, i.e. not for std dev, etc\\n if layer in InterpGdal.default_layers:\\n calc_pt_error(in_path, out_dir, layer, grid_var, \\n grid_id_name=grid_id_name\\n )\\n # calculate zonal statistics save means for each gridMET cell\\n if z_stats:\\n zonal_stats(in_path, out_file, grid_id_name=grid_id_name)\\n \\n # plot layer's interpolated residuals as bar plot witheach Wx station \\n # only produce residual plots for bias ratios, i.e. not for std dev, etc\\n if res_plot and layer in InterpGdal.default_layers:\\n layer = InterpGdal.var_residual_names.get(\\n layer, \\n layer.replace('mean','res')\\n )\\n y_label = 'residual (interpolated minus station value)'\\n title = 'layer: {} algorithm: {} (RBF) resolution: {} deg.'.format(\\n layer, function ,res)\\n res_plot_dir = Path(out_dir)/'residual_plots'\\n subtitle='parameters: smooth={}'.format(smooth)\\n source_file = Path(out_dir)/Path(in_path).name\\n\\n station_bar_plot(source_file, layer, out_dir=res_plot_dir, \\n y_label=y_label, title=title, subtitle=subtitle)\",\n \"def __call__(self,activation_mask):\\n assert self.grid.shape == activation_mask.shape\\n self.mask = cv2.dilate(activation_mask, self.dilation_kernel, iterations=1)\\n phosphenes = self.grid * self.mask\\n phosphenes = cv2.GaussianBlur(phosphenes,(self.k_size,self.k_size),self.sigma)\\n return phosphenes\",\n \"def preprocess_RSofia(img):\\n for i in range(480):\\n for j in range(200):\\n img[i,j]=0\\n for i in range(150):\\n for j in range(500):\\n img[i,j]=0 \\n for i in range(475):\\n for j in range(90):\\n img[i,img.shape[1]-1-j]=0\\n for i in range(90):\\n for j in range(465):\\n img[i,img.shape[1]-1-j]=0\\n return img\",\n \"def scale(self, X_train, X_test):\\n\\n #X_train, X_test, y_train, y_test = self.split_X_y_sets()\\n self.scaler.fit(X_train)\\n X_train_sc = self.scaler.transform(X_train)\\n X_test_sc = self.scaler.transform(X_test)\\n\\n return X_train_sc, X_test_sc #, y_train, y_test\",\n \"def fitfunc(self, x, p):\\n S = np.zeros(self.npt)\\n for i in range(0, len(p), self.maxparm):\\n ptyp = self.peakTyp[int(i/self.maxparm)]\\n xm = p[i]\\n amp = p[i+1]\\n w = p[i+2]\\n a = p[i+3]\\n m = p[i+4]\\n if ptyp == 'G':\\n # peak type = Gaussian\\n S = S + self.gauss(x, xm, amp, w)\\n elif ptyp == 'L':\\n # peak type = Lorentzian\\n S = S + self.lorentz(x, xm, amp, w)\\n elif ptyp == 'P':\\n # peak type = Pseudo-Voigt\\n S = S + self.psVoigt(x, xm, amp, w, m)\\n elif ptyp == 'AG':\\n # peak type = Asymmetric Gaussian\\n S = S + self.agauss(x, xm, amp, w, a)\\n elif ptyp == 'AL':\\n # peak type = Asymmetric Lorentzian\\n S = S + self.alorentz(x, xm, amp, w, a)\\n elif ptyp == 'AP':\\n # peak type = Asymmetric Pseudo-Voigt\\n S = S + self.aPsVoigt(x, xm, amp, w, a, m)\\n return S\",\n \"def test_roundtrip():\\n # Based heavily on test_sbinterpolatedimage() in test_SBProfile.py!\\n import time\\n t1 = time.time()\\n\\n # for each type, try to make an SBInterpolatedImage, and check that when we draw an image from\\n # that SBInterpolatedImage that it is the same as the original\\n ftypes = [np.float32, np.float64]\\n ref_array = np.array([\\n [0.01, 0.08, 0.07, 0.02],\\n [0.13, 0.38, 0.52, 0.06],\\n [0.09, 0.41, 0.44, 0.09],\\n [0.04, 0.11, 0.10, 0.01] ]) \\n\\n for array_type in ftypes:\\n image_in = galsim.ImageView[array_type](ref_array.astype(array_type))\\n np.testing.assert_array_equal(\\n ref_array.astype(array_type),image_in.array,\\n err_msg=\\\"Array from input Image differs from reference array for type %s\\\"%\\n array_type)\\n interp = galsim.InterpolatedImage(image_in, dx=test_dx)\\n test_array = np.zeros(ref_array.shape, dtype=array_type)\\n image_out = galsim.ImageView[array_type](test_array)\\n image_out.setScale(test_dx)\\n interp.draw(image_out)\\n np.testing.assert_array_equal(\\n ref_array.astype(array_type),image_out.array,\\n err_msg=\\\"Array from output Image differs from reference array for type %s\\\"%\\n array_type)\\n \\n # Lanczos doesn't quite get the flux right. Wrong at the 5th decimal place.\\n # Gary says that's expected -- Lanczos isn't technically flux conserving. \\n # He applied the 1st order correction to the flux, but expect to be wrong at around\\n # the 10^-5 level.\\n # Anyway, Quintic seems to be accurate enough.\\n quint = galsim.Quintic(1.e-4)\\n quint_2d = galsim.InterpolantXY(quint)\\n interp = galsim.InterpolatedImage(image_in, interpolant=quint_2d, dx=test_dx, flux=1.)\\n do_shoot(interp,image_out,\\\"InterpolatedImage\\\")\\n\\n t2 = time.time()\\n print 'time for %s = %.2f'%(funcname(),t2-t1)\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def preprocess(N, sigma2, R, f_def, params):\\n\\n #\\n if 'scale' in params:\\n if params['scale']:\\n\\n #\\n N0 = np.sum(R * f_def, axis=1)\\n\\n #\\n f_def *= np.average(N / N0)\\n\\n return N, sigma2, R, f_def, params\",\n \"def calcSFP(gamma_tilt_deg, created_pal, SFP_config, Tech_res):\\n # general\\n gamma_n = gamma_tilt_deg / 180 * np.pi\\n N = SFP_config.N\\n \\n ########################## SIMULATION SETUP ###############################\\n # reference pressure\\n p0 = 2 * 10**(-5)\\n # frequencies\\n f = get_freq_vec(N_freq=120, step_freq=1/12, freq_range=[20,20000])\\n f_xy = np.array([100, 200, 400, 800, 1000, 2000, 5000, 10000, 16000])\\n\\n # initialize variables\\n omega = 2 * np.pi * f\\n omega_xy = 2 * np.pi * f_xy\\n D_opt_LSA = np.ones([N, np.shape(f)[0]])\\n P_LSA = np.zeros([np.shape(created_pal.xline)[0],np.shape(f)[0]], dtype=complex)\\n\\n # air attenuation\\n alpha, c = AirAbsorptionCoefficient(f, T=293.15, p=101.325*10**(3), h=50)\\n\\n # directivity\\n # if PALC_config.directivity not in ['Measured Loudspeaker Data']:\\n # dire_meas_LSA = np.ones([np.shape(f)[0],np.shape(f)[0]])\\n # dire_meas_deg = np.ones([np.shape(f)[0],np.shape(f)[0]])\\n \\n ######################### SPL CALCULATION #################################\\n x_start, y_start, x_stop, y_stop, x_c_n, y_c_n, x_S, y_S = source_pos(gamma_n, SFP_config)\\n\\n for n in range(np.shape(f)[0]):\\n G_LSA_vert = CalcGreenFunctions(created_pal.xline, created_pal.yline, np.array([0]), \\\\\\n x_c_n, y_c_n, 0.82, SFP_config.directivity, \\\\\\n SFP_config.Lambda_y, gamma_n, c, omega[n], 1, \\\\\\n np.array(SFP_config.dir_meas[:,n]), \\\\\\n np.array(SFP_config.dir_meas_deg[:,1]), \\\\\\n alpha[n], f, n )\\n\\n P_LSA[:,n] = G_LSA_vert @ D_opt_LSA[:,n] # D_opt_LSA possibility to include driving functions\\n p_SPL = 20 * np.log10(np.abs(P_LSA) / p0)\\n Tech_res.update_tech_meas(p_SPL=p_SPL, f=f)\\n return x_S, y_S\",\n \"def scale(img, scales):\\n outputs = []\\n for sc in scales:\\n outputs.append(\\n cv2.resize(img, None, fx=sc, fy=sc, interpolation=cv2.INTER_CUBIC)\\n )\\n return outputs\",\n \"def fitfunc_2G1Y(a_x, a_p1, a_p2, a_p3, a_p4, a_p5, a_p6, a_p7):\\n \\n# if (a_x != 0.0):\\n if (True):\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)) +\\n a_p5 * (1.0 - exp(-a_p6 * a_x**2)) * exp(-a_p7 * a_x) / a_x)\\n else:\\n return (a_p1 * exp(-pow(a_x/a_p2, 2)) + a_p3 * exp(-pow(a_x/a_p4, 2)))\",\n \"def map_all_sig_p(limitregion=False, region=\\\"allsky\\\"):\\n \\n # Get ids of all pixels that contain RHT data\\n rht_cursor, tablename = get_rht_cursor(region = region)\\n all_ids = get_all_rht_ids(rht_cursor, tablename)\\n \\n planck_tqu_db = sqlite3.connect(\\\"planck_TQU_gal_2048_db.sqlite\\\")\\n planck_tqu_cursor = planck_tqu_db.cursor()\\n planck_cov_db = sqlite3.connect(\\\"planck_cov_gal_2048_db.sqlite\\\")\\n planck_cov_cursor = planck_cov_db.cursor()\\n \\n if limitregion is True:\\n print(\\\"Loading all allsky data points that are in the SC_241 region\\\")\\n # Get all ids that are in both allsky data and SC_241\\n all_ids_SC = pickle.load(open(\\\"SC_241_healpix_ids.p\\\", \\\"rb\\\"))\\n all_ids = list(set(all_ids).intersection(all_ids_SC))\\n \\n all_sigpGsq = np.zeros(len(all_ids))\\n\\n update_progress(0.0)\\n for i, hp_index in enumerate(all_ids):\\n #likelihood = Likelihood(_id[0], planck_tqu_cursor, planck_cov_cursor, p0_all, psi0_all, adaptivep0 = adaptivep0)\\n (hp_index, T, Q, U) = planck_tqu_cursor.execute(\\\"SELECT * FROM Planck_Nside_2048_TQU_Galactic WHERE id = ?\\\", hp_index).fetchone()\\n (hp_index, TT, TQ, TU, TQa, QQ, QU, TUa, QUa, UU) = planck_cov_cursor.execute(\\\"SELECT * FROM Planck_Nside_2048_cov_Galactic WHERE id = ?\\\", (hp_index,)).fetchone()\\n \\n # sigma_p as defined in arxiv:1407.0178v1 Eqn 3.\\n sigma_p = np.zeros((2, 2), np.float_) # [sig_Q^2, sig_QU // sig_QU, UU]\\n sigma_p[0, 0] = (1.0/T**2)*QQ #QQ\\n sigma_p[0, 1] = (1.0/T**2)*QU #QU\\n sigma_p[1, 0] = (1.0/T**2)*QU #QU\\n sigma_p[1, 1] = (1.0/T**2)*UU #UU\\n \\n # det(sigma_p) = sigma_p,G^4\\n det_sigma_p = np.linalg.det(sigma_p)\\n sigpGsq = np.sqrt(det_sigma_p)\\n \\n all_sigpGsq[i] = sigpGsq\\n \\n update_progress((i+1.0)/len(all_ids), message='Calculating: ', final_message='Finished Calculating: ')\\n \\n # Place into healpix map\\n hp_sigpGsq = make_hp_map(all_sigpGsq, all_ids, Nside = 2048, nest = True)\\n \\n out_root = \\\"/disks/jansky/a/users/goldston/susan/Wide_maps/\\\"\\n if limitregion:\\n hp.fitsfunc.write_map(out_root + \\\"planck_sigpGsq_SC_241.fits\\\", hp_sigpGsq, coord = \\\"G\\\", nest = True) \\n else:\\n hp.fitsfunc.write_map(out_root + \\\"planck_sigpGsq_DR2sky.fits\\\", hp_sigpGsq, coord = \\\"G\\\", nest = True)\",\n \"def residLike(self):\\n\\n # --------------------------------------------------------------------------------------------- #\\n # Compute the residuals\\n if self.csys == 'GAL':\\n # Redo some file computations with this coordinate system\\n self.outbinexp = os.path.join(self.workpath, 'BinExpMapGAL'+self.suffix+'.fits')\\n self.outbincub = os.path.join(self.workpath, 'BinCubeGAL'+self.suffix+'.fits')\\n self.outsrcmap = os.path.join(self.workpath, 'SrcMapsGAL'+self.suffix+'.fits')\\n self.outresid = os.path.join(self.workpath, 'ResidGAL'+self.suffix+'.fits')\\n self.outresig = os.path.join(self.workpath, 'ResSigmaGAL'+self.suffix+'.fits')\\n\\n self._gtExpmap()\\n self._gtBincube()\\n self._gtSrcmap()\\n else:\\n # Nothing to add\\n pass\\n \\n self._gtBinmap()\\n self._gtModel()\\n # Create the residual count map (count_map - model_map)\\n if not os.path.isfile(self.outresid):\\n os.popen(\\\"farith {} {} {} ops=SUB\\\".format(self.outbinmap, self.outgtmod,\\n self.outresid))\\n # Create the sigma-residual map (residual_map/sqrt(model_map))\\n if not os.path.isfile(self.outresig):\\n os.popen(\\\"ftpixcalc {} '(a-b)/sqrt(b)' a={} b={}\\\".format(self.outresig,\\n self.outbinmap, self.outgtmod))\\n\\n # --------------------------------------------------------------------------------------------- #\\n # Get the sources to overplot\\n srcs = self.getSrc()\\n srcs = srcs[(srcs['Separation'] <= 3.) & ([not i.endswith('c') for i in srcs['Name']])]\\n # Plot the residuals\\n resplt1 = FermiMap()\\n resplt1.savepath = self.workpath\\n resplt1.image = self.outresig\\n resplt1.figname = 'ResSigma.pdf'\\n dmin, dmax = np.abs(resplt1.datamin), resplt1.datamax\\n resplt1.datamin = - min(dmin, dmax)\\n resplt1.datamax = + min(dmin, dmax)\\n resplt1.cbarlabel = r'Residual $\\\\sigma$/pixel'\\n resplt1.mapSky()\\n resplt1.srcSky(srcs['RA'], srcs['DEC'], srcs['Name'])\\n resplt1.save()\\n print(\\\"\\\\t=== Figure '{}' created ===\\\".format( os.path.join(resplt1.savepath, resplt1.figname) ))\\n\\n resplt2 = FermiMap()\\n resplt2.savepath = self.workpath\\n resplt2.image = self.outresid\\n resplt2.figname = 'Residuals.pdf'\\n dmin, dmax = np.abs(resplt2.datamin), resplt2.datamax\\n resplt2.datamin = - min(dmin, dmax)\\n resplt2.datamax = + min(dmin, dmax)\\n resplt2.cbarlabel = r'Residual counts/pixel'\\n resplt2.mapSky()\\n resplt2.srcSky(srcs['RA'], srcs['DEC'], srcs['Name'])\\n resplt2.save()\\n print(\\\"\\\\t=== Figure '{}' created ===\\\".format( os.path.join(resplt2.savepath, resplt2.figname) ))\\n return\",\n \"def gaussExpand(img: np.ndarray, gs_k: np.ndarray) -> np.ndarray:\\r\\n gs_k = (gs_k / gs_k.sum()) * 4\\r\\n if img.ndim == 3:\\r\\n h, w, d = img.shape[:3]\\r\\n newImg = np.zeros((2 * h, 2 * w, d))\\r\\n else:\\r\\n h, w = img.shape[:2]\\r\\n newImg = np.zeros((2 * h, 2 * w))\\r\\n newImg[::2, ::2] = img\\r\\n image = cv2.filter2D(newImg, -1, gs_k, cv2.BORDER_REPLICATE)\\r\\n return image\",\n \"def scale(self, smin=0.6, smax=2.0, N=20):\\n scaled_geoms = []\\n for s in np.linspace(smin, smax, N):\\n scaled_atomlist = []\\n for (Zi,[xi,yi,zi]) in self.atomlist0:\\n scaled_atomlist.append( (Zi, (xi*s,yi*s,zi*s)) )\\n scaled_geoms.append(scaled_atomlist)\\n return scaled_geoms\",\n \"def calibration(self) -> int:\",\n \"def InterpolationFunctions(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):\\n ...\",\n \"def __call__(self, results):\\n if 'scale' not in results:\\n if 'scale_factor' in results:\\n img_shape = results['img'].shape[:2]\\n scale_factor = results['scale_factor']\\n assert isinstance(scale_factor, float)\\n results['scale'] = tuple([int(x * scale_factor) for x in img_shape][::-1])\\n else:\\n self._random_scale(results)\\n else:\\n if not self.override:\\n assert 'scale_factor' not in results, 'scale and scale_factor cannot be both set.'\\n else:\\n results.pop('scale')\\n if 'scale_factor' in results:\\n results.pop('scale_factor')\\n self._random_scale(results)\\n\\n self._resize_img(results)\\n self._resize_bboxes(results)\\n self._resize_cbboxes(results)\\n self._resize_masks(results)\\n self._resize_seg(results)\\n\\n return results\",\n \"def transform(self, GRFData):\\n \\n if not self.isFitted:\\n raise NotFittedError(\\\"The scaler has n ot been fitted to data. Call 'fit()' before calling 'transform()'.\\\")\\n\\n self.__is_valid_dict(GRFData)\\n transformed_GRFData = {}\\n for component in self.comp_list:\\n len_series = GRFData[component].shape[1]\\n transformed_data = self.scaler[component].transform(np.reshape(GRFData[component], (-1, 1)))\\n transformed_GRFData[component] = np.reshape(transformed_data, (-1, len_series))\\n\\n return transformed_GRFData\",\n \"def scaling(self):\\n return self.__scaling\",\n \"def standardization (x_train,x_test):\\n scaler = StandardScaler()\\n ## reshape training data to 2D, fit and transform scaler\\n scaler.fit(np.reshape(x_train, [x_train.shape[0], x_train.shape[1]*x_train.shape[2]*x_train.shape[3]]))\\n x_train = scaler.transform(np.reshape(x_train, [x_train.shape[0], x_train.shape[1]*x_train.shape[2]*x_train.shape[3]]))\\n ## reshape training data to 3D (n * frequencyrate * number of channels)\\n x_train = np.reshape(x_train, [x_train.shape[0],x_test.shape[1],x_test.shape[2],x_test.shape[3]])\\n x_test = scaler.transform(np.reshape(x_test, [x_test.shape[0], x_test.shape[1]*x_test.shape[2]*x_test.shape[3]]))\\n x_test = np.reshape(x_test,[x_test.shape[0], x_train.shape[1], x_train.shape[2], x_train.shape[3]])\\n return x_train, x_test, scaler\",\n \"def _scale_bkg(self, input_irf_file, config):\\n\\n # Reading the Background parameters.\\n self._bkg = dict()\\n self._bkg['dxlow'] = input_irf_file['BACKGROUND'].data['detx_lo'][0].copy()\\n self._bkg['dxhigh'] = input_irf_file['BACKGROUND'].data['detx_hi'][0].copy()\\n self._bkg['dylow'] = input_irf_file['BACKGROUND'].data['dety_lo'][0].copy()\\n self._bkg['dyhigh'] = input_irf_file['BACKGROUND'].data['dety_hi'][0].copy()\\n self._bkg['Elow'] = input_irf_file['BACKGROUND'].data['energ_lo'][0].copy()\\n self._bkg['Ehigh'] = input_irf_file['BACKGROUND'].data['energ_hi'][0].copy()\\n self._bkg['bckgnd'] = input_irf_file['BACKGROUND'].data['bgd'][0].transpose().copy()\\n \\n self._bkg['detx'] = (self._bkg['dxlow'] + self._bkg['dxhigh']) / 2.0\\n self._bkg['dety'] = (self._bkg['dylow'] + self._bkg['dyhigh']) / 2.0\\n self._bkg['enrg'] = scipy.sqrt(self._bkg['Elow'] * self._bkg['Ehigh'])\\n\\n # Creating the [detx - dety - energy] mesh grid.\\n detx, dety, energy = scipy.meshgrid(self._bkg['detx'], self._bkg['dety'], self._bkg['enrg'], indexing='ij')\\n \\n # ----------------------------------\\n # Scaling the Background Energy dependence.\\n\\n # Constant error function\\n if config['energy_scaling']['err_func_type'] == \\\"constant\\\":\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * config['energy_scaling']['constant']['scale']\\n\\n # Gradients error function\\n elif config['energy_scaling']['err_func_type'] == \\\"gradient\\\":\\n scaling_params = config['energy_scaling']['gradient']\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * (\\n 1 + scaling_params['scale'] * gradient(scipy.log10(energy),\\n scipy.log10(scaling_params['range_min']),\\n scipy.log10(scaling_params['range_max']))\\n )\\n \\n # Step error function\\n elif config['energy_scaling']['err_func_type'] == \\\"step\\\":\\n scaling_params = config['energy_scaling']['step']\\n break_points = list(zip(scipy.log10(scaling_params['transition_pos']),\\n scaling_params['transition_widths']))\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd'] * (\\n 1 + scaling_params['scale'] * step(scipy.log10(energy), break_points)\\n )\\n else:\\n raise ValueError(\\\"Background energy scaling: unknown scaling function type '{:s}'\\\"\\n .format(config['energy_scaling']['err_func_type']))\\n\\n # -------------------------------------------\\n # Scaling the Background Angular dependence\\n\\n # Angular (FOV coordinate X-axis binning)\\n # Constant error function\\n if config['angular_scaling']['err_func_type'] == \\\"constant\\\":\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * config['angular_scaling']['constant']['scale']\\n\\n # Gradients error function\\n elif config['angular_scaling']['err_func_type'] == \\\"gradient\\\":\\n scaling_params = config['angular_scaling']['gradient']\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\\n 1. + scaling_params['scale'] * gradient(detx,\\n scaling_params['range_min'],\\n scaling_params['range_max']) \\n )\\n # Step error function\\n elif config['angular_scaling']['err_func_type'] == \\\"step\\\":\\n scaling_params = config['angular_scaling']['step']\\n break_points = list(zip(scaling_params['transition_pos'],\\n scaling_params['transition_widths']))\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\\n 1 + scaling_params['scale'] * step(detx, break_points)\\n )\\n else:\\n raise ValueError(\\\"Background angular scaling: unknown scaling function type '{:s}'\\\"\\n .format(config['angular_scaling']['err_func_type'])\\n )\\n\\n # Angular (FOV coordinate Y-axis binning)\\n # Constant error function\\n if config['angular_scaling']['err_func_type'] == \\\"constant\\\":\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * config['angular_scaling']['constant']['scale']\\n\\n # Gradients error function\\n elif config['angular_scaling']['err_func_type'] == \\\"gradient\\\":\\n scaling_params = config['angular_scaling']['gradient']\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\\n 1. + scaling_params['scale'] * gradient(dety,\\n scaling_params['range_min'],\\n scaling_params['range_max']) \\n )\\n # Step error function\\n elif config['angular_scaling']['err_func_type'] == \\\"step\\\":\\n scaling_params = config['angular_scaling']['step']\\n break_points = list(zip(scaling_params['transition_pos'],\\n scaling_params['transition_widths']))\\n self._bkg['bckgnd_new'] = self._bkg['bckgnd_new'] * (\\n 1 + scaling_params['scale'] * step(dety, break_points)\\n )\\n else:\\n raise ValueError(\\\"Background angular scaling: unknown scaling function type '{:s}'\\\"\\n .format(config['angular_scaling']['err_func_type'])\\n )\\n\\n # ----------------------------------\\n # Recording the scaled Background\\n input_irf_file['BACKGROUND'].data['bgd'][0] = self._bkg['bckgnd_new'].transpose()\",\n \"def get_scale_parameter(self):\\n\\n shape_in_gamma_func = float(1 + (1 / self._shape_parameter))\\n gamma_func = special.gamma(shape_in_gamma_func)\\n self._scale_parameter = self._mean_fire_recurrence / gamma_func\",\n \"def test_fluxnorm():\\n import time\\n t1 = time.time()\\n\\n # define values\\n im_lin_scale = 5 # make an image with this linear scale\\n im_fill_value = 3. # fill it with this number\\n im_scale = 1.3\\n\\n # First, make some Image with some total flux value (sum of pixel values) and scale\\n im = galsim.ImageF(im_lin_scale, im_lin_scale)\\n im.fill(im_fill_value)\\n im.setScale(im_scale)\\n total_flux = im_fill_value*(im_lin_scale**2)\\n np.testing.assert_equal(total_flux, im.array.sum(),\\n err_msg='Created array with wrong total flux')\\n\\n # Check that if we make an InterpolatedImage with flux normalization, it keeps that flux\\n interp = galsim.InterpolatedImage(im) # note, flux normalization is the default\\n np.testing.assert_equal(total_flux, interp.getFlux(),\\n err_msg='Did not keep flux normalization')\\n # Check that this is preserved when drawing\\n im2 = interp.draw(dx = im_scale)\\n np.testing.assert_equal(total_flux, im2.array.sum(),\\n err_msg='Drawn image does not have expected flux normalization')\\n\\n # Now make an InterpolatedImage but tell it sb normalization\\n interp_sb = galsim.InterpolatedImage(im, normalization = 'sb')\\n # Check that when drawing, the sum is equal to what we expect if the original image had been\\n # surface brightness\\n im3 = interp_sb.draw(dx = im_scale)\\n np.testing.assert_almost_equal(total_flux*(im_scale**2)/im3.array.sum(), 1.0, decimal=6,\\n err_msg='Did not use surface brightness normalization')\\n # Check that when drawing with sb normalization, the sum is the same as the original\\n im4 = interp_sb.draw(dx = im_scale, normalization = 'sb')\\n np.testing.assert_almost_equal(total_flux/im4.array.sum(), 1.0, decimal=6,\\n err_msg='Failed roundtrip for sb normalization')\\n\\n # Finally make an InterpolatedImage but give it some other flux value\\n interp_flux = galsim.InterpolatedImage(im, flux=test_flux)\\n # Check that it has that flux\\n np.testing.assert_equal(test_flux, interp_flux.getFlux(),\\n err_msg = 'InterpolatedImage did not use flux keyword')\\n # Check that this is preserved when drawing\\n im5 = interp_flux.draw(dx = im_scale)\\n np.testing.assert_almost_equal(test_flux/im5.array.sum(), 1.0, decimal=6,\\n err_msg = 'Drawn image does not reflect flux keyword')\\n\\n t2 = time.time()\\n print 'time for %s = %.2f'%(funcname(),t2-t1)\",\n \"def calibration(self) -> tuple[int, int, int, int, int]:\",\n \"def get_image(self, psf, atms, rmax, nx, pixelshift=[0,0,0], scalefactor=1.0):\\n\\n try:\\n rank = MPI.COMM_WORLD.Get_rank()\\n except:\\n rank = 0\\n\\n psf2d = numpy.fft.fft2(psf)\\n\\n pot = self.stempot(rmax,rmax,len(psf),len(psf[0]),atms,pixelshift,scalefactor)\\n\\n potft = numpy.fft.fft2(pot)\\n\\n potm = potft*psf2d\\n\\n zcon_im = numpy.fft.ifft2(potm,axes=(0,1)).real\\n\\n return zcon_im\",\n \"def get_scaling(self):\\n if self.constrain_navigation:\\n self.activate_navigation_constrain()\\n return self.sx, self.sy\",\n \"def guider_fit(fibres, observatory='APO'):\\n\\n dRA = fibres.dRA\\n dDec = fibres.dDec\\n raCenter = fibres.xFocal\\n decCenter = fibres.yFocal\\n\\n arcsec_mm = 3600 / PLUGPLATESCALE[observatory]\\n guideRMS = np.sqrt((fibres.dx**2 + fibres.dy**2).sum() / len(fibres)) * arcsec_mm\\n\\n bb = np.zeros(3, dtype=np.float64)\\n AA = np.zeros((3, 3), dtype=np.float64)\\n\\n bb[0] = dRA.sum()\\n bb[1] = dDec.sum()\\n bb[2] = (raCenter * dDec - decCenter * dRA).sum()\\n\\n AA[0, 0] = len(fibres)\\n AA[0, 1] = 0\\n AA[0, 2] = -decCenter.sum()\\n\\n AA[1, 0] = 0\\n AA[1, 1] = len(fibres)\\n AA[1, 2] = raCenter.sum()\\n\\n AA[2, 2] = (raCenter * raCenter + decCenter * decCenter).sum()\\n\\n AA[2, 0] = AA[0, 2]\\n AA[2, 1] = AA[1, 2]\\n\\n b3 = (raCenter * dRA + decCenter * dDec).sum()\\n\\n xx = np.linalg.solve(AA, bb)\\n\\n mRA = xx[0] / PLUGPLATESCALE[observatory]\\n mDec = xx[1] / PLUGPLATESCALE[observatory]\\n mRot = -np.rad2deg(xx[2])\\n\\n mScale = b3 / AA[2, 2] + 1.\\n\\n p0 = fibres[['xCenter', 'yCenter']].as_matrix()\\n p1 = p0 - fibres[['dRA', 'dDec']].as_matrix()\\n\\n pos_error = get_position_error(p0, p1, [xx[0], xx[1]], -mRot, mScale)\\n pos_error /= PLUGPLATESCALE[observatory]\\n\\n n_points = len(fibres)\\n\\n return pd.Series({'mRA': mRA, 'mDec': mDec, 'mRot': mRot,\\n 'mScale': mScale, 'guideRMS': guideRMS,\\n 'pos_error': pos_error, 'n_points': n_points})\",\n \"def fit_gauss(x, y):\\n nx = numpy.array(x)\\n ny = numpy.array(y)\\n ne = numpy.ones(len(ny))\\n#\\n#--- we need to give an initial guess\\n#\\n ymax = numpy.max(ny)\\n med = find_med(y)\\n p0 = [ymax, med, 10, 0]\\n\\n fitobj = kmpfit.Fitter(residuals=residualsG, data=(nx,ny,ne))\\n fitobj.fit(params0=p0)\\n [amp, cent, width, floor] = fitobj.params\\n\\n return [amp, cent, width]\",\n \"def test_scaling(self):\\n def runs_successfully(use_scal, coeffs):\\n prob = om.Problem()\\n prob.model.add_subsystem('row1', ScalingTestComp(row=1, coeffs=coeffs,\\n use_scal=use_scal))\\n prob.model.add_subsystem('row2', ScalingTestComp(row=2, coeffs=coeffs,\\n use_scal=use_scal))\\n prob.model.connect('row1.y', 'row2.x')\\n prob.model.connect('row2.y', 'row1.x')\\n prob.model.nonlinear_solver = om.NewtonSolver(solve_subsystems=False, maxiter=2, atol=1e-5, rtol=0)\\n prob.model.nonlinear_solver.linear_solver = om.ScipyKrylov(maxiter=1)\\n\\n prob.set_solver_print(level=0)\\n\\n prob.setup()\\n prob.run_model()\\n\\n return np.linalg.norm(prob.model._residuals.asarray()) < 1e-5\\n\\n # ---------------------------\\n # coeffs: r1, r2, c1, c2\\n coeffs = [1.e0, 1.e0, 1.e0, 1.e0]\\n\\n # Don't use scaling - but there's no need\\n use_scal = False\\n self.assertTrue(runs_successfully(use_scal, coeffs))\\n # Use scaling - but there's no need\\n use_scal = True\\n self.assertTrue(runs_successfully(use_scal, coeffs))\\n\\n # ---------------------------\\n # coeffs: r1, r2, c1, c2 - test output scaling:\\n coeffs = [1.e0, 1.e0, 1.e10, 1.e0]\\n\\n # Don't use scaling - but output scaling needed\\n use_scal = False\\n self.assertTrue(not runs_successfully(use_scal, coeffs))\\n # Use scaling - output scaling works successfully\\n use_scal = True\\n self.assertTrue(runs_successfully(use_scal, coeffs))\\n\\n # ---------------------------\\n # coeffs: r1, r2, c1, c2 - test residual scaling:\\n coeffs = [1.e10, 1.e0, 1.e10, 1.e0]\\n\\n # Don't use scaling - but residual scaling needed\\n use_scal = False\\n self.assertTrue(not runs_successfully(use_scal, coeffs))\\n # Use scaling - residual scaling works successfully\\n use_scal = True\\n self.assertTrue(runs_successfully(use_scal, coeffs))\",\n \"def _ssim_for_multiscale(img1, img2, max_val=255, filter_size=11,\\n filter_sigma=1.5, k1=0.01, k2=0.03):\\n\\n _, height, width, _ = img1.shape\\n\\n # Filter size can't be larger than height or width of images.\\n #size = tf.min(filter_size, height, width)\\n size = filter_size\\n\\n # Scale down sigma if a smaller filter size is used.\\n sigma = size * filter_sigma / filter_size if filter_size else 0\\n\\n if filter_size:\\n window = broadcast_to(tf.reshape(_f_special_gauss(size, sigma),\\n (size, size, 1, 1)), (size, size, 3,1))\\n mu1 = conv(img1, window)\\n mu2 = conv(img2, window)\\n sigma11 = conv(img1 * img1, window)\\n sigma22 = conv(img2 * img2, window)\\n sigma12 = conv(img1 * img2, window)\\n else:\\n # Empty blur kernel so no need to convolve.\\n mu1, mu2 = img1, img2\\n sigma11 = img1 * img1\\n sigma22 = img2 * img2\\n sigma12 = img1 * img2\\n\\n mu11 = mu1 * mu1\\n mu22 = mu2 * mu2\\n mu12 = mu1 * mu2\\n sigma11 -= mu11\\n sigma22 -= mu22\\n sigma12 -= mu12\\n\\n # Calculate intermediate values used by both ssim and cs_map.\\n c1 = (k1 * max_val) ** 2\\n c2 = (k2 * max_val) ** 2\\n v1 = 2.0 * sigma12 + c2\\n v2 = sigma11 + sigma22 + c2\\n ssim = tf.reduce_mean((((2.0 * mu12 + c1) * v1) / ((mu11 + mu22 + c1) * v2)))\\n cs = tf.reduce_mean(v1 / v2)\\n return ssim, cs\",\n \"def smooth_scipy(self, mri_data):\\n\\n # image dimension\\n if hasattr(mri_data.img_header, 'info'):\\n dx, dy, dz = np.abs(mri_data.img_header.info['DELTA'])\\n elif hasattr(mri_data.img_header, 'get_zooms'):\\n dx, dy, dz = mri_data.img_header.get_zooms()[:3]\\n else:\\n self.errmsg(\\\"No voxel size information in mri_data header\\\")\\n\\n # Set gaussian sigma in image dimension\\n sigma = (self.blur_fwhm / np.array((dx, dy, dz))) / 2.354820\\n imgdata = mri_data.img_data.astype(np.float64)\\n\\n # Apply mask\\n if hasattr(self, 'maskV'):\\n imgdata[~self.maskV] = 0\\n\\n # Apply Gaussian filter\\n filt_img = gaussian_filter(imgdata, sigma, mode='constant')\\n\\n if hasattr(self, 'maskV'):\\n # Adjust voxels with out of the mask (0) convolution\\n aux_img = np.ones_like(imgdata)\\n aux_img[~self.maskV] = 0\\n filt_aux_img = gaussian_filter(aux_img, sigma, mode='constant')\\n filt_img[self.maskV] /= filt_aux_img[self.maskV]\\n\\n return filt_img.astype(mri_data.img_data.dtype)\",\n \"def scaling(self):\\n return self._scaling\",\n \"def scaling(self):\\n return self._scaling\",\n \"def fit_psf_to_gaussian(self, xx, yy, psf_data, x0, y0, sigmax0, sigmay0):\\n peak0, offset0 = 1.0, 0.0 # Guesses\\n # # We guess that the FWHM will be around 2 detector pixels [30 microns]\\n # # Using the formula for a Gaussian FWHM = 2 sqrt(2 ln(2)) Sigma\\n # sigma_fwhm = 100e-3 / 2 * np.sqrt(2 * np.log(2))\\n # sigmax0, sigmay0 = sigma_fwhm, sigma_fwhm\\n\\n guess_param = [x0, y0, sigmax0, sigmay0, peak0, offset0]\\n bounds = ([-np.inf, -np.inf, 0.0, 0.0, 0, -np.inf],\\n [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf])\\n\\n while True:\\n # The Gaussian fit can sometimes fail if our guess for the size of the PSF is very wrong\\n try:\\n pars, cov = curve_fit(self.gaussian2d, (xx.ravel(), yy.ravel()), psf_data.ravel(),\\n p0=guess_param, bounds=bounds)\\n # Results of the fit for the sigmaX, sigmaY\\n sigmaX, sigmaY = pars[2], pars[3]\\n # print(\\\"Successful Guassian Fit\\\")\\n break\\n\\n except RuntimeError: # If it fails to converge, repeat with a randomly perturbed guess\\n # sigmaX, sigmaY = np.nan, np.nan\\n print(\\\"\\\\n[WARNING] Gaussian Fit of the PSF failed!\\\")\\n\\n # try with other guesses\\n deltax = np.random.uniform(low=-1.0, high=1.0)\\n deltay = np.random.uniform(low=-1.0, high=1.0)\\n new_sigmax0 = (1 + deltax) * sigmax0\\n new_sigmay0 = (1 + deltay) * sigmay0\\n print(\\\"Trying with new Sigmas: X %.3f & Y %.3f microns\\\" % (1e3 * new_sigmax0, 1e3 * new_sigmay0))\\n guess_param = [x0, y0, new_sigmax0, new_sigmay0, peak0, offset0]\\n\\n # Use the formula for the Gaussian FWHM to transform the sigmas into FWHM values\\n fwhm_x = 2 * np.sqrt(2 * np.log(2)) * sigmaX * 1000\\n fwhm_y = 2 * np.sqrt(2 * np.log(2)) * sigmaY * 1000\\n\\n return fwhm_x, fwhm_y\",\n \"def peak_PSF(self):\\n im, strehl = self.compute_PSF(np.zeros(self.N_act))\\n return strehl\",\n \"def scale(self):\\n return self._gev_bijector.scale\",\n \"def __call__(self, results):\\n\\n if 'scale' not in results:\\n if 'scale_factor' in results:\\n img_shape = results['img'].shape[:2]\\n scale_factor = results['scale_factor']\\n assert isinstance(scale_factor, float)\\n results['scale'] = tuple(\\n [int(x * scale_factor) for x in img_shape][::-1])\\n else:\\n self._random_scale(results)\\n else:\\n if not self.override:\\n assert 'scale_factor' not in results, (\\n 'scale and scale_factor cannot be both set.')\\n else:\\n results.pop('scale')\\n if 'scale_factor' in results:\\n results.pop('scale_factor')\\n self._random_scale(results)\\n\\n self._resize_img(results)\\n self._resize_bboxes(results)\\n self._resize_masks(results)\\n self._resize_seg(results)\\n return results\",\n \"def __call__(self, results):\\n\\n if 'scale' not in results:\\n if 'scale_factor' in results:\\n img_shape = results['img'].shape[:2]\\n scale_factor = results['scale_factor']\\n assert isinstance(scale_factor, float)\\n results['scale'] = tuple(\\n [int(x * scale_factor) for x in img_shape][::-1])\\n else:\\n self._random_scale(results)\\n else:\\n if not self.override:\\n assert 'scale_factor' not in results, (\\n 'scale and scale_factor cannot be both set.')\\n else:\\n results.pop('scale')\\n if 'scale_factor' in results:\\n results.pop('scale_factor')\\n self._random_scale(results)\\n\\n self._resize_img(results)\\n self._resize_bboxes(results)\\n self._resize_masks(results)\\n self._resize_seg(results)\\n return results\",\n \"def coral_image_resize(im, scaling_method, scaling_factor, height_cm):\\n\\n if scaling_method == 'scale':\\n scale = float(scaling_factor) # here scaling_factor is the desired image scaling.\\n elif scaling_method == 'ratio':\\n scale = float(scaling_factor) * height_cm / im.shape[0] # here scaling_factor is the desited px_cm_ratio.\\n im = scipy.misc.imresize(im, scale)\\n return (im, scale)\",\n \"def initialise_calibration(self):\\n for i in range(0, self.NUM_SENSORS):\\n self.calibratedMax[i] = 0\\n self.calibratedMin[i] = self.READING_TIMEOUT\",\n \"def scale4x(self) -> 'BaseImage':\\n return self.scale2x().scale2x()\",\n \"def GetParameters(ParamsFile, QualityFile, Bands, NumberOfParameters, RelativeUncert, ScaleFactor, ProcessSnow = 0):\\n\\n FillValue = 32767\\n NumberOfBands = Bands.shape[0]\\n\\n # Get dimensions\\n rows, cols = GetDimSubDataset( ParamsFile )\\n\\n Parameters = np.zeros((rows, cols, NumberOfBands, NumberOfParameters), np.float32)\\n Uncertainties = np.zeros((rows, cols, NumberOfBands), np.float32)\\n\\n # Get Snow\\n # 1 Snow albedo retrieved\\n # 0 Snow-free albedo retrieved\\n # 255 Fill Value\\n print \\\"Reading Snow QA:\\\", QualityFile\\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\\\"' + QualityFile + '\\\":MOD_Grid_BRDF:Snow_BRDF_Albedo'\\n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\\n SnowQA = SubDataset.GetRasterBand(1).ReadAsArray()\\n if ProcessSnow == 0:\\n SnowQA = np.where( SnowQA == 0, 1, 0)\\n else:\\n SnowQA = np.where( SnowQA == 1, 1, 0)\\n\\n # Load BRDF parameters\\n print \\\"Reading BRDF parameters...\\\"\\n for Band in range( Bands.shape[0] ):\\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\\\"' + ParamsFile + '\\\":MOD_Grid_BRDF:BRDF_Albedo_Parameters_Band' + str( Bands[Band] )\\n print SubDatasetName \\n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\\n\\n for Parameter in range(NumberOfParameters):\\n print \\\"Getting BRDF parameter\\\", Parameter\\n Parameters[:,:,Band,Parameter] = SubDataset.GetRasterBand( Parameter + 1 ).ReadAsArray()\\n\\n # Snow mask\\n Parameters[:,:,Band,Parameter] = Parameters[:,:,Band,Parameter] * SnowQA\\n\\n # Filter out fill values\\n Parameters[:,:,Band,Parameter] = np.where(Parameters[:,:,Band,Parameter] == FillValue, 0.,\\n Parameters[:,:,Band,Parameter] * ScaleFactor )\\n\\n # Get QA\\n print \\\"Reading QA:\\\", QualityFile\\n for Band in range( Bands.shape[0] ):\\n SubDatasetName = 'HDF4_EOS:EOS_GRID:\\\"' + QualityFile + '\\\":MOD_Grid_BRDF:BRDF_Albedo_Band_Quality_Band' + str( Bands[Band] )\\n SubDataset = gdal.Open(SubDatasetName, GA_ReadOnly)\\n QA = SubDataset.GetRasterBand(1).ReadAsArray()\\n\\n # https://ladsweb.nascom.nasa.gov/api/v1/filespec/collection=6&product=MCD43A2\\n # BRDF_Albedo_Band_Quality_BandN ( N is 1 to 7 )> \\n # 0 = best quality, full inversion (WoDs, RMSE majority good)\\n # 1 = good quality, full inversion (also including the cases that no clear sky\\n # observations over the day of interest or the Solar Zenith Angle is too \\n # large even WoDs, RMSE majority good)\\n # 2 = Magnitude inversion (numobs >=7)\\n # 3 = Magnitude inversion (numobs >=2&<7)\\n # 4 = Fill value\\n\\n QA_flags = np.array( [ 0,1,2,3 ] )\\n\\n for i, QA_flag in enumerate( QA_flags ) :\\n indices = np.where( QA == QA_flag )\\n Uncertainties[ indices[0], indices[1], Band ] = RelativeUncert[ i ]\\n\\n Uncertainties[:,:,Band] = Uncertainties[:,:,Band] * SnowQA \\n\\n SubDataset = None\\n return Parameters, Uncertainties\",\n \"def _get_params(self, input):\\n transforms = []\\n \\n if self.brightness is not None:\\n brightness = random.uniform(self.brightness[0], self.brightness[1])\\n f = lambda img: F.adjust_brightness(img, brightness)\\n transforms.append(f)\\n\\n if self.contrast is not None:\\n contrast = random.uniform(self.contrast[0], self.contrast[1])\\n f = lambda img: F.adjust_contrast(img, contrast)\\n transforms.append(f)\\n\\n if self.saturation is not None:\\n saturation = random.uniform(self.saturation[0], self.saturation[1])\\n f = lambda img: F.adjust_saturation(img, saturation)\\n transforms.append(f)\\n\\n if self.hue is not None:\\n hue = random.uniform(self.hue[0], self.hue[1])\\n f = lambda img: F.adjust_hue(img, hue)\\n transforms.append(f)\\n\\n random.shuffle(transforms)\\n return transforms\",\n \"def __scale(data, max_value_list, min_value_list, scale_value_list, process_cols_list):\\n features = np.array(data.features, dtype=float)\\n for i in process_cols_list:\\n value = features[i]\\n if value > max_value_list[i]:\\n value = max_value_list[i]\\n elif value < min_value_list[i]:\\n value = min_value_list[i]\\n\\n features[i] = (value - min_value_list[i]) / scale_value_list[i]\\n _data = copy.deepcopy(data)\\n _data.features = features\\n return _data\",\n \"def _gf_gray(I, p, r, eps, s=None):\\n if s is not None:\\n Isub = sp.ndimage.zoom(I, 1/s, order=1)\\n Psub = sp.ndimage.zoom(p, 1/s, order=1)\\n r = round(r / s)\\n else:\\n Isub = I\\n Psub = p\\n\\n\\n (rows, cols) = Isub.shape\\n\\n N = box(np.ones([rows, cols]), r)\\n\\n meanI = box(Isub, r) / N\\n meanP = box(Psub, r) / N\\n corrI = box(Isub * Isub, r) / N\\n corrIp = box(Isub * Psub, r) / N\\n varI = corrI - meanI * meanI\\n covIp = corrIp - meanI * meanP\\n\\n\\n a = covIp / (varI + eps)\\n b = meanP - a * meanI\\n\\n meanA = box(a, r) / N\\n meanB = box(b, r) / N\\n\\n if s is not None:\\n meanA = sp.ndimage.zoom(meanA, s, order=1)\\n meanB = sp.ndimage.zoom(meanB, s, order=1)\\n\\n q = meanA * I + meanB\\n return q\",\n \"def fit_gaussian_rl(img_dataset,image_data_variable_to_fit='PSF',beam_set_name='RESTORE_PARMS',fit_method='rm_fit',npix_window=[21,21],sampling=[401,401],cutoff=0.5,cutoff_sensitivity=0.003):\\n import xarray as xr\\n import matplotlib.pyplot as plt\\n import dask.array as da\\n from scipy.interpolate import interpn\\n \\n sampling = np.array(sampling)\\n npix_window = np.array(npix_window)\\n delta = np.array(img_dataset.incr[0:2])*3600*180/np.pi\\n chunks = img_dataset[image_data_variable_to_fit].data.chunks[2:] + (3,)\\n ellipse_parms = da.map_blocks(rm_fit,img_dataset[image_data_variable_to_fit].data,npix_window,sampling,cutoff,cutoff_sensitivity,delta,dtype=np.double,drop_axis=[0,1],new_axis=[2],chunks=chunks)\\n\\n img_dataset[beam_set_name] = xr.DataArray(ellipse_parms,dims=['chan','pol','elps_index'])\\n return img_dataset\",\n \"def calibrate(cap, location):\\n\\n #Poisition and size of sensor\\n [x, y, h, w] = location\\n\\n #show square to user and wait for key\\n print(\\\"please, step away to clear the blue square displayed on screen and press q to continue\\\")\\n while True:\\n ret, frame = cap.read()\\n cv2.namedWindow('Calibrate',cv2.WINDOW_NORMAL)\\n show = cv2.rectangle(frame, (x,y), (x+w,y+h), (255, 0, 0) , 5)\\n cv2.imshow('Calibrate', show)\\n key = cv2.waitKey(1)\\n if key == ord('q'):\\n break\\n\\n #get first image, process and define window previous for iteration\\n ret, frame = cap.read()\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n frame = cv2.GaussianBlur(frame, (7,7), 0)\\n previous = frame[y:y+w,x:x+h]\\n\\n #set parameters for mean value of sensor, kernel of erode function,\\n sampleNbMean = 50\\n xi = np.empty((0, sampleNbMean))\\n kernel = np.ones((5,5), np.uint8)\\n\\n #iterate over each frame until sample number\\n for iteration in range(sampleNbMean):\\n\\n # Capture frame, draw the window and display to the user\\n ret, frame = cap.read()\\n # Image operation\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n frame = cv2.GaussianBlur(frame, (7,7), 0)\\n\\n #get present window\\n present = frame[y:y+w,x:x+h]\\n\\n #add sample for mean, add diference of window with prieviuos\\n xi = np.append(xi,\\n np.sum(\\n cv2.erode(\\n cv2.bitwise_xor(present,previous), kernel, iterations=1)))\\n\\n #present image becomes previous before steping into next image\\n previous = present\\n\\n #mean\\n mean = np.sum(xi)/len(xi)\\n\\n #sigma\\n sum = 0\\n for sample in xi:\\n sum += np.power(sample - mean, 2)\\n sigma = np.sqrt(sum/len(xi))\\n\\n #close window\\n cv2.destroyWindow('Calibrate')\\n\\n return mean, sigma\",\n \"def extractScale(self,groups):\\n self.scaleX = float(groups[0])\\n self.scaleY = float(groups[0])\\n if len(groups) == 2 and groups[1]:\\n self.scaleY = float(groups[1])\\n self.matrix = [[self.scaleX, 0.0, 0.0], \\\\\\n [0.0, self.scaleY, 0.0]]\",\n \"def fit_gp(self):\\n self.gpf_core.fit_gp_for_gp_bandit(num_samples=self.options.hp_samples)\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def _resize_masks(self, results):\\n for key in results.get('mask_fields', []):\\n if results[key] is None:\\n continue\\n if self.keep_ratio:\\n results[key] = results[key].rescale(results['scale'])\\n else:\\n results[key] = results[key].resize(results['img_shape'][:2])\",\n \"def fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w):\\n h, w, c = im.shape\\n scale = float(target_h) / h\\n im = cv2.resize(im, (target_w, target_h))\\n mask = cv2.resize(mask, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\\n if inst_masks.size > 0:\\n inst_masks = np.transpose(inst_masks, (1, 2, 0)) # to (h, w, n)\\n inst_masks = cv2.resize(inst_masks, (target_w, target_h), interpolation=cv2.INTER_NEAREST)\\n try:\\n if inst_masks.ndim > 2:\\n inst_masks = np.transpose(inst_masks, (2, 0, 1)) # to (n, h, w)\\n else:\\n inst_masks = inst_masks.reshape((1, target_h, target_w))\\n except ValueError:\\n print (inst_masks.ndim, inst_masks.shape)\\n raise\\n else:\\n inst_masks = np.zeros((0, h, w), inst_masks.dtype)\\n boxes[:, 0:4:2] = boxes[:, 0:4:2] * float(target_w) / w\\n boxes[:, 1:4:2] = boxes[:, 1:4:2] * float(target_h) / h\\n\\n return im, inst_masks, mask, boxes, classes\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5934714","0.59323114","0.56692666","0.56136227","0.5515017","0.55022854","0.5450474","0.5448875","0.541764","0.53971016","0.53850543","0.5371395","0.5353867","0.53373635","0.53324974","0.5330355","0.52796024","0.5279098","0.52602744","0.52514803","0.524723","0.5215939","0.5215275","0.52105486","0.52103037","0.52041334","0.5202234","0.5194438","0.5178743","0.5178114","0.5168644","0.51678807","0.51606154","0.5159314","0.5155946","0.5147318","0.5139398","0.51391065","0.5138566","0.5129324","0.5124209","0.5112529","0.5109672","0.5095311","0.50892454","0.5072178","0.5059162","0.50527817","0.5045904","0.503804","0.5037009","0.5031131","0.5030306","0.5029408","0.5028522","0.5024545","0.5020488","0.50074613","0.5006702","0.50048584","0.50045156","0.5002919","0.500132","0.49994665","0.49967295","0.49947366","0.4992077","0.49898055","0.49895692","0.49894327","0.4988497","0.49877942","0.49857074","0.49811536","0.497725","0.4977068","0.49743673","0.49659133","0.49606994","0.49597073","0.49572402","0.49572402","0.4953181","0.49521458","0.4946872","0.49401018","0.49401018","0.49318305","0.4931262","0.49310976","0.49263462","0.4923697","0.49188203","0.49139023","0.49119627","0.49085957","0.49068415","0.49065325","0.49021873","0.49021873","0.49009228"],"string":"[\n \"0.5934714\",\n \"0.59323114\",\n \"0.56692666\",\n \"0.56136227\",\n \"0.5515017\",\n \"0.55022854\",\n \"0.5450474\",\n \"0.5448875\",\n \"0.541764\",\n \"0.53971016\",\n \"0.53850543\",\n \"0.5371395\",\n \"0.5353867\",\n \"0.53373635\",\n \"0.53324974\",\n \"0.5330355\",\n \"0.52796024\",\n \"0.5279098\",\n \"0.52602744\",\n \"0.52514803\",\n \"0.524723\",\n \"0.5215939\",\n \"0.5215275\",\n \"0.52105486\",\n \"0.52103037\",\n \"0.52041334\",\n \"0.5202234\",\n \"0.5194438\",\n \"0.5178743\",\n \"0.5178114\",\n \"0.5168644\",\n \"0.51678807\",\n \"0.51606154\",\n \"0.5159314\",\n \"0.5155946\",\n \"0.5147318\",\n \"0.5139398\",\n \"0.51391065\",\n \"0.5138566\",\n \"0.5129324\",\n \"0.5124209\",\n \"0.5112529\",\n \"0.5109672\",\n \"0.5095311\",\n \"0.50892454\",\n \"0.5072178\",\n \"0.5059162\",\n \"0.50527817\",\n \"0.5045904\",\n \"0.503804\",\n \"0.5037009\",\n \"0.5031131\",\n \"0.5030306\",\n \"0.5029408\",\n \"0.5028522\",\n \"0.5024545\",\n \"0.5020488\",\n \"0.50074613\",\n \"0.5006702\",\n \"0.50048584\",\n \"0.50045156\",\n \"0.5002919\",\n \"0.500132\",\n \"0.49994665\",\n \"0.49967295\",\n \"0.49947366\",\n \"0.4992077\",\n \"0.49898055\",\n \"0.49895692\",\n \"0.49894327\",\n \"0.4988497\",\n \"0.49877942\",\n \"0.49857074\",\n \"0.49811536\",\n \"0.497725\",\n \"0.4977068\",\n \"0.49743673\",\n \"0.49659133\",\n \"0.49606994\",\n \"0.49597073\",\n \"0.49572402\",\n \"0.49572402\",\n \"0.4953181\",\n \"0.49521458\",\n \"0.4946872\",\n \"0.49401018\",\n \"0.49401018\",\n \"0.49318305\",\n \"0.4931262\",\n \"0.49310976\",\n \"0.49263462\",\n \"0.4923697\",\n \"0.49188203\",\n \"0.49139023\",\n \"0.49119627\",\n \"0.49085957\",\n \"0.49068415\",\n \"0.49065325\",\n \"0.49021873\",\n \"0.49021873\",\n \"0.49009228\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84660,"cells":{"query":{"kind":"string","value":"Compute temporal offset between the PACS counter and the spacecraft clock."},"document":{"kind":"string","value":"def pacs_compute_delay(obs, tod, model, invntt=None, tol_delay=1.e-3,\n tol_mapper=1.e-3, hyper=1., brack=(-60.,-30.,0.),\n full_output=False):\n global map_rls\n\n def func_model(obs, tod, model):\n\n def substitute_projection(model):\n for i, c in enumerate(model.operands):\n if isinstance(c, ProjectionBaseOperator):\n model.operands[i] = obs.get_projection_operator(\n method=c.method, header=c.header,\n npixels_per_sample=c.npixels_per_sample,\n storage='in memory' if isinstance(c, ProjectionInMemoryOperator) else 'on fly')\n return True\n elif hasattr(c, 'operands'):\n if substitute_projection(c):\n return True\n return False\n\n if isinstance(model, ProjectionBaseOperator):\n return ProjectionOperator(obs, method=model.method, header= \\\n model.header, npixels_per_sample=model.npixels_per_sample)\n if hasattr(model, 'operands'):\n if substitute_projection(model):\n return model\n\n raise TypeError('There is no projection in this acquisition model.')\n \n delays = []\n criteria = []\n\n def criteria_delay(params, obs, tod, model, invntt, tol, hyper):\n global map_rls\n delay = params if np.rank(params) == 0 else params[0]\n obs.slice[0].delay = delay\n model = func_model(obs, tod, model)\n print('\\nDelay: ' + str(delay) + 'ms...')\n map_rls = mapper_rls(tod, model, invntt=invntt, tol=tol, hyper=hyper)\n criterion = map_rls.header['criter']\n delays.append(delay)\n criteria.append(criterion)\n gc.collect()\n return criterion\n\n if obs.slice.size > 1:\n raise ValueError('Temporal delay is determined within a single obsid.')\n\n if weight is None:\n weight = IdentityOperator()\n\n method = scipy.optimize.brent\n result = method(criteria_delay, (obs, tod, model, weight, tol_mapper,\n hyper), brack=brack, tol=tol_delay)\n\n map_rls.header.update('delay', result)\n\n if full_output:\n return result, map_rls.header['criter'], delays, criteria, map_rls\n\n return result"},"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 _clock_time(self):\n return self._shifted_time % (24*3600)","def _prev_shifted_time(self):\n return self._prev_sim_time + self.options.time.start_clocktime","def _shifted_time(self):\n return self.sim_time + self.options.time.start_clocktime","def GetDeviceHostClockOffset(self):\n if self._device_host_clock_offset is None:\n device_time, _ = self.RunCmdOnDevice(['date', '+%s'])\n host_time = time.time()\n self._device_host_clock_offset = int(int(device_time.strip()) - host_time)\n return self._device_host_clock_offset","def GetDeviceHostClockOffset(self):\n if self._device_host_clock_offset is None:\n device_time, _ = self.RunCmdOnDevice(['date', '+%s'])\n host_time = time.time()\n self._device_host_clock_offset = int(int(device_time.strip()) - host_time)\n return self._device_host_clock_offset","def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\n return float(pcr_t2-pcr_t1)/90000.0 + offset","def _local_time_offset():\n if time.localtime().tm_isdst and time.daylight:\n return -time.altzone\n else:\n return -time.timezone","def get_time_shift_pad_offset(time_shift_amount):\n if time_shift_amount > 0:\n time_shift_padding = [[time_shift_amount, 0], [0, 0]]\n time_shift_offset = [0, 0]\n else:\n time_shift_padding = [[0, -time_shift_amount], [0, 0]]\n time_shift_offset = [-time_shift_amount, 0]\n return time_shift_padding, time_shift_offset","def _calc_cycle_delta_pos(self):\n first_frame = self._frames[0]\n last_frame = self._frames[-1]\n\n pos_start = self.get_frame_root_pos(first_frame)\n pos_end = self.get_frame_root_pos(last_frame)\n cycle_delta_pos = pos_end - pos_start\n cycle_delta_pos[2] = 0 # only translate along horizontal plane\n\n return cycle_delta_pos","def get_tz_offset(self) -> float:\n return self.AD.tz.utcoffset(self.datetime()).total_seconds() / 60","def _clock_day(self):\n return int(self._shifted_time / 86400)","def ctime():\n acstime_ACE_BEGIN = 122192928000000000L\n return int(acstime_ACE_BEGIN + time.time() * 10000000L)","def pc_work_time_total(self):\n return _spacegrant_swig.invert_bit_sptr_pc_work_time_total(self)","def get_tz_offset_s(time_dt):\n return s_from_dt(time_dt.replace(tzinfo=pytz.UTC)) - s_from_dt(time_dt)","def part2(input):\n ps = PlanetSystem(input)\n c = ps.total_cycle_time()\n return c","def __get_timezone_offset(self, timestamp):\n try:\n ts = int(timestamp)\n except ValueError:\n LOG.error(\"__get_timezone_offset() given non-numeric input {}\".format(timestamp))\n if self.__tzname is None:\n r = self.ctx.p4.run('counter', '-u', p4gf_const.P4GF_COUNTER_TIME_ZONE_NAME)\n value = p4gf_util.first_value_for_key(r, 'value')\n if value == '0' or value is None:\n # Upgrade from an EA system, perhaps, in which the upgrade counters\n # have been set but the later changes where not applied during init.\n msg = _(\"Counter '{}' not set, using UTC as default.\"\n \" Change this to your Perforce server's time zone.\") \\\n .format(p4gf_const.P4GF_COUNTER_TIME_ZONE_NAME)\n LOG.warn(msg)\n value = NTR('UTC')\n self.__tzname = value\n try:\n mytz = pytz.timezone(self.__tzname)\n except pytz.exceptions.UnknownTimeZoneError:\n LOG.warn(\"Time zone name '{}' unrecognized, using UTC as default\".format(self.__tzname))\n mytz = pytz.utc\n LOG.debug(\"__get_timezone_offset({}) with {}\".format(ts, mytz))\n dt = datetime.datetime.fromtimestamp(ts, tz=pytz.utc)\n ct = dt.astimezone(mytz)\n return ct.strftime('%z')","def pc_work_time(self):\n return _spacegrant_swig.invert_bit_sptr_pc_work_time(self)","def get_timzone_offset(self, timezone):\n raise NotImplementedError","def pc_work_time_total(self):\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time_total(self)","def _calc_cycle_offset_pos(self, num_cycles):\n\n if not self._enable_cycle_offset_pos:\n cycle_offset_pos = np.zeros(3)\n else:\n if not self._enable_cycle_offset_rot:\n cycle_offset_pos = num_cycles * self._cycle_delta_pos\n\n else:\n cycle_offset_pos = np.zeros(3)\n for i in range(num_cycles):\n curr_heading = i * self._cycle_delta_heading\n rot = transformations.quaternion_about_axis(curr_heading, [0, 0, 1])\n curr_offset = pose3d.QuaternionRotatePoint(self._cycle_delta_pos, rot)\n cycle_offset_pos += curr_offset\n\n return cycle_offset_pos","def pc_work_time_total(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)","def get_utc_offset():\n timedelta = datetime.datetime.now() - datetime.datetime.utcnow()\n # XXX: `return -time.timezone`?\n return timedelta.total_seconds()","def pc_work_time(self):\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time(self)","def get_tz_offset_seconds() -> float:\n import time\n import datetime\n tval = time.time()\n utc_offset = (datetime.datetime.fromtimestamp(tval) -\n datetime.datetime.utcfromtimestamp(tval)).total_seconds()\n return utc_offset","def pc_work_time_total(self):\n return _spacegrant_swig.DeNRZI_sptr_pc_work_time_total(self)","def pc_work_time_total(self):\n return _spacegrant_swig.udp_debug_sptr_pc_work_time_total(self)","def pc_work_time(self):\n return _spacegrant_swig.udp_debug_sptr_pc_work_time(self)","def pc_work_time(self):\n return _TestA_swig.cleanslate_sptr_pc_work_time(self)","def pc_work_time_total(self):\n return _spacegrant_swig.ax25_pdu_packer_sptr_pc_work_time_total(self)","def pc_work_time_total(self):\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_pc_work_time_total(self)","def getLastSolRepOffset(self):\n self.lastSolRepOffset = self.firstRepOffset + \\\n (self.numberOfSamples * self.numberOfTechReps) + \\\n self.numberOfQCReps + self.numberOfSolventReps\n return self.lastSolRepOffset","def pc_work_time_total(self):\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_total(self)","def pc_work_time(self):\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_pc_work_time(self)","def pc_work_time_total(self):\n return _spacegrant_swig.G3RUH_descramble_sptr_pc_work_time_total(self)","def pc_work_time_total(self):\n return _spacegrant_swig.NRZI_sptr_pc_work_time_total(self)","def pc_work_time(self):\n return _spacegrant_swig.ax25_pdu_packer_sptr_pc_work_time(self)","def pc_work_time(self):\n return _spacegrant_swig.DeNRZI_sptr_pc_work_time(self)","def pc_work_time_total(self):\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_pc_work_time_total(self)","def __calculateOffset(self):\n #if len(self.__XValue) > 0:\n # print(\"GPSBearing: \"+str(round(self.__GPSBearing[-1]))+\", heading: \"+str(round(self.value))+\n # \", x: \"+str(round(self.__XValue[-1]))+\", stdev: \"+str(round(np.std(self.__GPSBearing),5))+\n # \", offset: \"+str(self.__offset))\n if len(self.__GPSBearing) == self.__GPSBearing.maxlen and np.std(self.__GPSBearing) < 0.2 and self.speed > 7:\n self.__offset = (np.mean(self.__GPSBearing) + 360 - np.mean(self.__XValue)) % 360\n #print(\"new offset: \"+str(self.__offset)) ","def offset(self):\n\n offsetList = ['12 am', '1 am', '2 am', '3 am', '4 am', '5 am', '6 am', '7 am', '8 am', '9 am',\n '10 am', '11 am', '12 pm', '1 pm', '2 pm', '3 pm', '4 pm', '5 pm', '6 pm', '7 pm',\n '8 pm', '9 pm', '10 pm', '11 pm', '12 pm']\n\n firstTimeHour = self.firstTime.time().hour\n print ('First Time Hour:', firstTimeHour)\n\n m2 = str(self.firstTime.time())\n m2 = datetime.datetime.strptime(m2, '%I:%M %p')\n print(m2)","def pc_work_time_total(self):\n return _spacegrant_swig.binary_sink_sptr_pc_work_time_total(self)","def cadenceEventTime(self):\n return (self.raw[2] << 8) | self.raw[1]","def pc_work_time(self):\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_pc_work_time(self)","def n_vert_clock_amps(self):\n n = ct.c_int()\n self.lib.GetNumberVSAmplitudes(ct.pointer(n))\n return n.value","def _format_timezone_offset(converted_time):\n\n # Windows treats %z in the format string as %Z, so we compute the hour/minute offset\n # manually.\n if converted_time.tm_isdst == 1 and time.daylight:\n utc_offset_secs = time.altzone\n else:\n utc_offset_secs = time.timezone\n\n # The offset is positive if the local timezone is behind (east of) UTC, and negative if it\n # is ahead (west) of UTC.\n utc_offset_prefix = \"-\" if utc_offset_secs > 0 else \"+\"\n utc_offset_secs = abs(utc_offset_secs)\n\n utc_offset_mins = (utc_offset_secs / 60) % 60\n utc_offset_hours = utc_offset_secs / 3600\n return \"%s%02d%02d\" % (utc_offset_prefix, utc_offset_hours, utc_offset_mins)","def set_offset_for_processes(self):\n processes = self.get_processes()\n if (len(processes) == 0):\n print \"Not enough servers up yet. Cannot synchronize clocks.\"\n return \"Cannot synchronize clocks yet.\"\n servers = list(processes.itervalues())\n\n local_time = time.time()\n times = [server.get_time_in_seconds() for server in servers]\n avg_time = (sum(times) + local_time)/(len(times) + 1.0)\n\n self.offset = avg_time - local_time\n for s, t in zip(servers, times):\n s.set_offset(avg_time - t)\n\n t = Timer(5, self.set_offset_for_processes)\n t.daemon = True\n t.start()\n return \"Clocks synchronized.\"","def pc_work_time(self) -> \"float\":\n return _beamforming_swig.doaesprit_sptr_pc_work_time(self)","def pc_work_time(self):\n return _spacegrant_swig.binary_sink_sptr_pc_work_time(self)","def _get_offset(self, seconds):\n now_nanosec = time.time_ns()\n target_nanosec = now_nanosec - utils.seconds_in_nano(seconds)\n target_search = counter.Search(None, None, target_nanosec)\n\n offset = bisect.bisect_left(self._search_history, target_search)\n\n return offset","def pc_work_time_total(self) -> \"float\":\n return _beamforming_swig.doaesprit_sptr_pc_work_time_total(self)","def pos(self, time):\n if (time < self.ti):\n t = 0\n elif (time > self.tf):\n t = self.tf - self.ti\n else:\n t = time - self.ti\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)","def offset_capture():\n Clock()","def get_pos_dt(self) -> WAVector:\n pass","def pc_work_time_total(self):\n return _spacegrant_swig.general_burster_2_sptr_pc_work_time_total(self)","def pc_work_time(self):\n return _spacegrant_swig.G3RUH_descramble_sptr_pc_work_time(self)","def pc_work_time(self):\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time(self)","def get_dc_offset(self):\n self.dev.write(1, 'A1')\n digit1, digit2 = self.dev.read(0x81, 64)[:2]\n # Save the data as voltage between 0.0 and 5.0\n self.data1.append((digit1 + 256*digit2)*5.0/1024)","def pc_work_time(self):\n return _spacegrant_swig.NRZI_sptr_pc_work_time(self)","def getCoordinate(self, value, cardinal_point):\n d, m, s = value\n\n if cardinal_point in ['S', 'W']:\n d = -d\n m = -m\n s = -s\n\n return d + m / 60.0 + s / 3600.0","def __calculate_time_cs(self, jiffies):\n\n return int((jiffies * 100.0) / self._jiffies_per_sec)","def calOffsets(self, Xi_arr, Vi_arr, hz):\n\n Wi_arr = [round(vi / hz, 6) for vi in Vi_arr] # tcptimestamps in seconds with microsecond precision\n Yi_arr = [(wi - xi) * 1000 for wi, xi in zip(Wi_arr, Xi_arr)] # offset in miliseconds\n offset_arr = [(round(x, 6), round(y, 6)) for x, y in zip(Xi_arr, Yi_arr)]\n return offset_arr","def alignTime(self):\n agility = self.agility\n mass = self.mass\n\n alignTime = -math.log(0.25) * agility * mass / 1000000\n return alignTime","def calculate_module_offsets(self):\n \n # These aren't for instantiating, but we use them to get the dimensions\n self.poly_contact_offset = vector(0.5*contact.poly.width,0.5*contact.poly.height)\n\n # M1/M2 routing pitch is based on contacted pitch\n self.m1_pitch = max(contact.m1m2.width,contact.m1m2.height) + max(self.m1_space,self.m2_space)\n self.m2_pitch = max(contact.m2m3.width,contact.m2m3.height) + max(self.m2_space,self.m3_space)\n \n # This corrects the offset pitch difference between M2 and M1\n self.offset_fix = vector(0.5*(self.m2_width-self.m1_width),0)\n\n # delay chain will be rotated 90, so move it over a width\n # we move it up a inv height just for some routing room\n self.rbl_inv_offset = vector(self.delay_chain.height, self.inv.width)\n # access TX goes right on top of inverter, leave space for an inverter which is\n # about the same as a TX. We'll need to add rails though.\n self.access_tx_offset = vector(1.25*self.inv.height,self.rbl_inv_offset.y) + vector(0,2.5*self.inv.width)\n self.delay_chain_offset = self.rbl_inv_offset + vector(0,4*self.inv.width)\n\n # Replica bitline and such are not rotated, but they must be placed far enough\n # away from the delay chain/inverter with space for three M2 tracks\n self.bitcell_offset = self.rbl_inv_offset + vector(2*self.m2_pitch, 0) + vector(0, self.bitcell.height + self.inv.width)\n\n self.rbl_offset = self.bitcell_offset\n\n \n self.height = self.rbl_offset.y + self.rbl.height + self.m2_pitch\n self.width = self.rbl_offset.x + self.bitcell.width","def pc_work_time(self) -> \"float\":\n return _beamforming_swig.phasedarray_sptr_pc_work_time(self)","def compute_offsets(task, nc_per_task, is_cifar):\n if is_cifar:\n offset1 = task * nc_per_task\n offset2 = (task + 1) * nc_per_task\n else:\n offset1 = 0\n offset2 = nc_per_task\n return offset1, offset2","def compute_offsets(task, nc_per_task, is_cifar):\n if is_cifar:\n offset1 = task * nc_per_task\n offset2 = (task + 1) * nc_per_task\n else:\n offset1 = 0\n offset2 = nc_per_task\n return offset1, offset2","def GetCurrentOffset():\r\n return GetData().offsetCurrent","def pc_work_time_total(self):\n return _spacegrant_swig.hdlc_framer_sptr_pc_work_time_total(self)","def localTimeOffset(t=None):\n\tif t is None:\n\t\tt = time.time()\n\t\n\tif time.localtime(t).tm_isdst and time.daylight:\n\t\treturn -time.altzone\n\telse:\n\t\treturn -time.timezone","def dc_offset(self):\n return self._read(0x0E, 0, 0xFF), self._read(0x0F, 0, 0xFF)","def pc_work_time_total(self) -> \"float\":\n return _beamforming_swig.phasedarray_sptr_pc_work_time_total(self)","def lap(self):\n oldtime = self._clock() - self._starttime\n self._starttime = self._clock()\n return oldtime","def tzoffset(self):\n return _tzoffset(self._tz, self._t)","def phase_shift(annuli,annulus):\n delta_t = viscous_timescale(annuli[annulus+1]) - viscous_timescale(annuli[annulus])\n return int(delta_t)","def arcsec_per_kpc_from(self, redshift: float) -> float:\r\n return self.arcsec_per_kpc_proper(z=redshift).value","def _adjusted_time(self, otime: float = 0):\n if 'xtime_adjustment' in self.__timing_parameters:\n return time.time() - self.__timing_parameters['xtime_adjustment'] - otime\n else:\n return time.time() - otime","def pc_work_time_total(self):\n return _spacegrant_swig.message_debug_sptr_pc_work_time_total(self)","def get_time(self):\n clock = self.pipeline.get_clock()\n tm = clock.get_internal_time()\n return tm / 1.e9","def pc_work_time(self):\n return _spacegrant_swig.general_burster_2_sptr_pc_work_time(self)","def pc_work_time_total(self):\n return _uhd_swig.usrp_sink_sptr_pc_work_time_total(self)","def utc_to_tt_offset(time: dt.datetime) -> float:\n if time.year < 1972:\n raise ValueError(\"dates prior to 1972 are not currently supported\")\n # this includes the horrible fractional leap seconds prior to 1972\n # and the base 32.184 s offset between TAI and TT\n offset = 42.184\n for threshold in LEAP_SECOND_THRESHOLDS:\n if time > threshold:\n offset += 1\n return offset","def get_unixtime(self):\n if not self.Complete():\n raise DateTimeError(\"get_unixtime requires complete timepoint\")\n zoffset = self.time.GetZoneOffset()\n if zoffset is None:\n raise DateTimeError(\"get_unixtime requires timezone\")\n elif zoffset == 0:\n zt = self\n else:\n zt = self.ShiftZone(zDirection=0)\n days = zt.date.GetAbsoluteDay() - EPOCH.date.GetAbsoluteDay()\n seconds = zt.time.GetTotalSeconds() - EPOCH.time.GetTotalSeconds()\n return 86400 * days + seconds","def orig_time(self) -> float:\n return ntp_to_system_time(self.orig_timestamp)","def calc_frame_time(instrument, aperture, xdim, ydim, amps):\n instrument = instrument.lower()\n if instrument == \"nircam\":\n xs = xdim\n ys = ydim\n colpad = 12\n\n # Fullframe\n if amps == 4:\n rowpad = 1\n fullpad = 1\n else:\n # All subarrays\n rowpad = 2\n fullpad = 0\n if ((xdim <= 8) & (ydim <= 8)):\n # The smallest subarray\n rowpad = 3\n\n elif instrument == \"niriss\":\n xs = ydim\n ys = xdim\n colpad = 12\n\n # Fullframe\n if amps == 4:\n rowpad = 1\n fullpad = 1\n else:\n rowpad = 2\n fullpad = 0\n\n elif instrument == 'fgs':\n xs = ydim\n ys = xdim\n colpad = 6\n if 'acq1' in aperture.lower():\n colpad = 12\n rowpad = 1\n if amps == 4:\n fullpad = 1\n else:\n fullpad = 0\n\n return ((1.0 * xs / amps + colpad) * (ys + rowpad) + fullpad) * 1.e-5","def pc_work_time(self):\n return _uhd_swig.usrp_sink_sptr_pc_work_time(self)","def get_log_pos(timer, lane_speed):\n log_pos = timer * lane_speed\n if log_pos < 0:\n log_pos = 64 - (abs(log_pos) % 64)\n return log_pos","def smpte_offset(self) -> int:\n return self.__smpte_offset","def pc_work_time_avg(self):\n return _spacegrant_swig.invert_bit_sptr_pc_work_time_avg(self)","def pc_work_time(self):\n return _add_vector_swig.add_vector_2_cpp_sptr_pc_work_time(self)","def get_eclampsia_time(self):\n return self._stateMonitor.get_eclampsia_time()","def get_panels_pcb_offset():\n mount_hole_offset = arena_assembly['panels_to_hallway_gap']\n mount_hole_offset -= arena_assembly['panels_assembly_offset']\n mount_hole_offset += 0.5*hallway_bottom_plate['width']\n mount_hole_offset += 0.5*panels_pcb['width']\n return mount_hole_offset","def get_clock(self):\n return self.clock","def pc_work_time_avg(self):\n return _spacegrant_swig.udp_debug_sptr_pc_work_time_avg(self)","def pc_work_time(self):\n return _spacegrant_swig.message_debug_sptr_pc_work_time(self)","def localtime(stamp):\n return stamp - utc_offset","def adjust_pc(pc):\n # FIXME\n pc[0, :] = pc[-1, :]\n\n return crop(np.fft.fftshift(pc), width=100).real","def get_wcs_integer_pixel_offset(self):\n # Grab the WCS of the first image\n refWCS = self.image1.wcs\n\n # Estimate the central location for this image\n refX, refY = self.image1.shape[1]//2, self.image1.shape[0]//2\n\n # Convert pixels to sky coordinates\n refRA, refDec = refWCS.all_pix2world(refX, refY, 0, ra_dec_order=True)\n\n # Compute the pixel location of the reference RA and Dec\n dx, dy = self.image2.wcs.all_world2pix(refRA, refDec, 0)\n\n # Convert these relativeoffsets into integer values\n dx, dy = int(dx - refX), int(dy - refY)\n\n # Return the image offsets\n return (dx, dy)","def pc_work_time_total(self):\n return _uhd_swig.usrp_source_sptr_pc_work_time_total(self)","def calcOffset(self, x, y):\r\n # Datalayout\r\n # X = longitude\r\n # Y = latitude\r\n # Sample for size 1201x1201\r\n # ( 0/1200) ( 1/1200) ... (1199/1200) (1200/1200)\r\n # ( 0/1199) ( 1/1199) ... (1199/1199) (1200/1199)\r\n # ... ... ... ...\r\n # ( 0/ 1) ( 1/ 1) ... (1199/ 1) (1200/ 1)\r\n # ( 0/ 0) ( 1/ 0) ... (1199/ 0) (1200/ 0)\r\n # Some offsets:\r\n # (0/1200) 0\r\n # (1200/1200) 1200\r\n # (0/1199) 1201\r\n # (1200/1199) 2401\r\n # (0/0) 1201*1200\r\n # (1200/0) 1201*1201-1\r\n return x + self.size * (self.size - y - 1)","def pc_work_time_avg(self):\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time_avg(self)","def get_offset():\n offset = datetime.date.today() - start_day\n return int(offset.days) - 4"],"string":"[\n \"def _clock_time(self):\\n return self._shifted_time % (24*3600)\",\n \"def _prev_shifted_time(self):\\n return self._prev_sim_time + self.options.time.start_clocktime\",\n \"def _shifted_time(self):\\n return self.sim_time + self.options.time.start_clocktime\",\n \"def GetDeviceHostClockOffset(self):\\n if self._device_host_clock_offset is None:\\n device_time, _ = self.RunCmdOnDevice(['date', '+%s'])\\n host_time = time.time()\\n self._device_host_clock_offset = int(int(device_time.strip()) - host_time)\\n return self._device_host_clock_offset\",\n \"def GetDeviceHostClockOffset(self):\\n if self._device_host_clock_offset is None:\\n device_time, _ = self.RunCmdOnDevice(['date', '+%s'])\\n host_time = time.time()\\n self._device_host_clock_offset = int(int(device_time.strip()) - host_time)\\n return self._device_host_clock_offset\",\n \"def pcr_delta_time_ms(pcr_t1, pcr_t2, offset = 0):\\n return float(pcr_t2-pcr_t1)/90000.0 + offset\",\n \"def _local_time_offset():\\n if time.localtime().tm_isdst and time.daylight:\\n return -time.altzone\\n else:\\n return -time.timezone\",\n \"def get_time_shift_pad_offset(time_shift_amount):\\n if time_shift_amount > 0:\\n time_shift_padding = [[time_shift_amount, 0], [0, 0]]\\n time_shift_offset = [0, 0]\\n else:\\n time_shift_padding = [[0, -time_shift_amount], [0, 0]]\\n time_shift_offset = [-time_shift_amount, 0]\\n return time_shift_padding, time_shift_offset\",\n \"def _calc_cycle_delta_pos(self):\\n first_frame = self._frames[0]\\n last_frame = self._frames[-1]\\n\\n pos_start = self.get_frame_root_pos(first_frame)\\n pos_end = self.get_frame_root_pos(last_frame)\\n cycle_delta_pos = pos_end - pos_start\\n cycle_delta_pos[2] = 0 # only translate along horizontal plane\\n\\n return cycle_delta_pos\",\n \"def get_tz_offset(self) -> float:\\n return self.AD.tz.utcoffset(self.datetime()).total_seconds() / 60\",\n \"def _clock_day(self):\\n return int(self._shifted_time / 86400)\",\n \"def ctime():\\n acstime_ACE_BEGIN = 122192928000000000L\\n return int(acstime_ACE_BEGIN + time.time() * 10000000L)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.invert_bit_sptr_pc_work_time_total(self)\",\n \"def get_tz_offset_s(time_dt):\\n return s_from_dt(time_dt.replace(tzinfo=pytz.UTC)) - s_from_dt(time_dt)\",\n \"def part2(input):\\n ps = PlanetSystem(input)\\n c = ps.total_cycle_time()\\n return c\",\n \"def __get_timezone_offset(self, timestamp):\\n try:\\n ts = int(timestamp)\\n except ValueError:\\n LOG.error(\\\"__get_timezone_offset() given non-numeric input {}\\\".format(timestamp))\\n if self.__tzname is None:\\n r = self.ctx.p4.run('counter', '-u', p4gf_const.P4GF_COUNTER_TIME_ZONE_NAME)\\n value = p4gf_util.first_value_for_key(r, 'value')\\n if value == '0' or value is None:\\n # Upgrade from an EA system, perhaps, in which the upgrade counters\\n # have been set but the later changes where not applied during init.\\n msg = _(\\\"Counter '{}' not set, using UTC as default.\\\"\\n \\\" Change this to your Perforce server's time zone.\\\") \\\\\\n .format(p4gf_const.P4GF_COUNTER_TIME_ZONE_NAME)\\n LOG.warn(msg)\\n value = NTR('UTC')\\n self.__tzname = value\\n try:\\n mytz = pytz.timezone(self.__tzname)\\n except pytz.exceptions.UnknownTimeZoneError:\\n LOG.warn(\\\"Time zone name '{}' unrecognized, using UTC as default\\\".format(self.__tzname))\\n mytz = pytz.utc\\n LOG.debug(\\\"__get_timezone_offset({}) with {}\\\".format(ts, mytz))\\n dt = datetime.datetime.fromtimestamp(ts, tz=pytz.utc)\\n ct = dt.astimezone(mytz)\\n return ct.strftime('%z')\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.invert_bit_sptr_pc_work_time(self)\",\n \"def get_timzone_offset(self, timezone):\\n raise NotImplementedError\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time_total(self)\",\n \"def _calc_cycle_offset_pos(self, num_cycles):\\n\\n if not self._enable_cycle_offset_pos:\\n cycle_offset_pos = np.zeros(3)\\n else:\\n if not self._enable_cycle_offset_rot:\\n cycle_offset_pos = num_cycles * self._cycle_delta_pos\\n\\n else:\\n cycle_offset_pos = np.zeros(3)\\n for i in range(num_cycles):\\n curr_heading = i * self._cycle_delta_heading\\n rot = transformations.quaternion_about_axis(curr_heading, [0, 0, 1])\\n curr_offset = pose3d.QuaternionRotatePoint(self._cycle_delta_pos, rot)\\n cycle_offset_pos += curr_offset\\n\\n return cycle_offset_pos\",\n \"def pc_work_time_total(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time_total(self)\",\n \"def get_utc_offset():\\n timedelta = datetime.datetime.now() - datetime.datetime.utcnow()\\n # XXX: `return -time.timezone`?\\n return timedelta.total_seconds()\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time(self)\",\n \"def get_tz_offset_seconds() -> float:\\n import time\\n import datetime\\n tval = time.time()\\n utc_offset = (datetime.datetime.fromtimestamp(tval) -\\n datetime.datetime.utcfromtimestamp(tval)).total_seconds()\\n return utc_offset\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.DeNRZI_sptr_pc_work_time_total(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.udp_debug_sptr_pc_work_time_total(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.udp_debug_sptr_pc_work_time(self)\",\n \"def pc_work_time(self):\\n return _TestA_swig.cleanslate_sptr_pc_work_time(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.ax25_pdu_packer_sptr_pc_work_time_total(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_pc_work_time_total(self)\",\n \"def getLastSolRepOffset(self):\\n self.lastSolRepOffset = self.firstRepOffset + \\\\\\n (self.numberOfSamples * self.numberOfTechReps) + \\\\\\n self.numberOfQCReps + self.numberOfSolventReps\\n return self.lastSolRepOffset\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time_total(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_pc_work_time(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.G3RUH_descramble_sptr_pc_work_time_total(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.NRZI_sptr_pc_work_time_total(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.ax25_pdu_packer_sptr_pc_work_time(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.DeNRZI_sptr_pc_work_time(self)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.ax25_udp_pdu_receiver_sptr_pc_work_time_total(self)\",\n \"def __calculateOffset(self):\\n #if len(self.__XValue) > 0:\\n # print(\\\"GPSBearing: \\\"+str(round(self.__GPSBearing[-1]))+\\\", heading: \\\"+str(round(self.value))+\\n # \\\", x: \\\"+str(round(self.__XValue[-1]))+\\\", stdev: \\\"+str(round(np.std(self.__GPSBearing),5))+\\n # \\\", offset: \\\"+str(self.__offset))\\n if len(self.__GPSBearing) == self.__GPSBearing.maxlen and np.std(self.__GPSBearing) < 0.2 and self.speed > 7:\\n self.__offset = (np.mean(self.__GPSBearing) + 360 - np.mean(self.__XValue)) % 360\\n #print(\\\"new offset: \\\"+str(self.__offset)) \",\n \"def offset(self):\\n\\n offsetList = ['12 am', '1 am', '2 am', '3 am', '4 am', '5 am', '6 am', '7 am', '8 am', '9 am',\\n '10 am', '11 am', '12 pm', '1 pm', '2 pm', '3 pm', '4 pm', '5 pm', '6 pm', '7 pm',\\n '8 pm', '9 pm', '10 pm', '11 pm', '12 pm']\\n\\n firstTimeHour = self.firstTime.time().hour\\n print ('First Time Hour:', firstTimeHour)\\n\\n m2 = str(self.firstTime.time())\\n m2 = datetime.datetime.strptime(m2, '%I:%M %p')\\n print(m2)\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.binary_sink_sptr_pc_work_time_total(self)\",\n \"def cadenceEventTime(self):\\n return (self.raw[2] << 8) | self.raw[1]\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.ax25_pdu_unpacker_sptr_pc_work_time(self)\",\n \"def n_vert_clock_amps(self):\\n n = ct.c_int()\\n self.lib.GetNumberVSAmplitudes(ct.pointer(n))\\n return n.value\",\n \"def _format_timezone_offset(converted_time):\\n\\n # Windows treats %z in the format string as %Z, so we compute the hour/minute offset\\n # manually.\\n if converted_time.tm_isdst == 1 and time.daylight:\\n utc_offset_secs = time.altzone\\n else:\\n utc_offset_secs = time.timezone\\n\\n # The offset is positive if the local timezone is behind (east of) UTC, and negative if it\\n # is ahead (west) of UTC.\\n utc_offset_prefix = \\\"-\\\" if utc_offset_secs > 0 else \\\"+\\\"\\n utc_offset_secs = abs(utc_offset_secs)\\n\\n utc_offset_mins = (utc_offset_secs / 60) % 60\\n utc_offset_hours = utc_offset_secs / 3600\\n return \\\"%s%02d%02d\\\" % (utc_offset_prefix, utc_offset_hours, utc_offset_mins)\",\n \"def set_offset_for_processes(self):\\n processes = self.get_processes()\\n if (len(processes) == 0):\\n print \\\"Not enough servers up yet. Cannot synchronize clocks.\\\"\\n return \\\"Cannot synchronize clocks yet.\\\"\\n servers = list(processes.itervalues())\\n\\n local_time = time.time()\\n times = [server.get_time_in_seconds() for server in servers]\\n avg_time = (sum(times) + local_time)/(len(times) + 1.0)\\n\\n self.offset = avg_time - local_time\\n for s, t in zip(servers, times):\\n s.set_offset(avg_time - t)\\n\\n t = Timer(5, self.set_offset_for_processes)\\n t.daemon = True\\n t.start()\\n return \\\"Clocks synchronized.\\\"\",\n \"def pc_work_time(self) -> \\\"float\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_work_time(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.binary_sink_sptr_pc_work_time(self)\",\n \"def _get_offset(self, seconds):\\n now_nanosec = time.time_ns()\\n target_nanosec = now_nanosec - utils.seconds_in_nano(seconds)\\n target_search = counter.Search(None, None, target_nanosec)\\n\\n offset = bisect.bisect_left(self._search_history, target_search)\\n\\n return offset\",\n \"def pc_work_time_total(self) -> \\\"float\\\":\\n return _beamforming_swig.doaesprit_sptr_pc_work_time_total(self)\",\n \"def pos(self, time):\\n if (time < self.ti):\\n t = 0\\n elif (time > self.tf):\\n t = self.tf - self.ti\\n else:\\n t = time - self.ti\\n return self.a0 + self.a1 * t + self.a2 * pow(t, 2) + self.a3 * pow(t, 3) + self.a4 * pow(t, 4) + self.a5 * pow(t, 5)\",\n \"def offset_capture():\\n Clock()\",\n \"def get_pos_dt(self) -> WAVector:\\n pass\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.general_burster_2_sptr_pc_work_time_total(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.G3RUH_descramble_sptr_pc_work_time(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.hdlc_deframer_sptr_pc_work_time(self)\",\n \"def get_dc_offset(self):\\n self.dev.write(1, 'A1')\\n digit1, digit2 = self.dev.read(0x81, 64)[:2]\\n # Save the data as voltage between 0.0 and 5.0\\n self.data1.append((digit1 + 256*digit2)*5.0/1024)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.NRZI_sptr_pc_work_time(self)\",\n \"def getCoordinate(self, value, cardinal_point):\\n d, m, s = value\\n\\n if cardinal_point in ['S', 'W']:\\n d = -d\\n m = -m\\n s = -s\\n\\n return d + m / 60.0 + s / 3600.0\",\n \"def __calculate_time_cs(self, jiffies):\\n\\n return int((jiffies * 100.0) / self._jiffies_per_sec)\",\n \"def calOffsets(self, Xi_arr, Vi_arr, hz):\\n\\n Wi_arr = [round(vi / hz, 6) for vi in Vi_arr] # tcptimestamps in seconds with microsecond precision\\n Yi_arr = [(wi - xi) * 1000 for wi, xi in zip(Wi_arr, Xi_arr)] # offset in miliseconds\\n offset_arr = [(round(x, 6), round(y, 6)) for x, y in zip(Xi_arr, Yi_arr)]\\n return offset_arr\",\n \"def alignTime(self):\\n agility = self.agility\\n mass = self.mass\\n\\n alignTime = -math.log(0.25) * agility * mass / 1000000\\n return alignTime\",\n \"def calculate_module_offsets(self):\\n \\n # These aren't for instantiating, but we use them to get the dimensions\\n self.poly_contact_offset = vector(0.5*contact.poly.width,0.5*contact.poly.height)\\n\\n # M1/M2 routing pitch is based on contacted pitch\\n self.m1_pitch = max(contact.m1m2.width,contact.m1m2.height) + max(self.m1_space,self.m2_space)\\n self.m2_pitch = max(contact.m2m3.width,contact.m2m3.height) + max(self.m2_space,self.m3_space)\\n \\n # This corrects the offset pitch difference between M2 and M1\\n self.offset_fix = vector(0.5*(self.m2_width-self.m1_width),0)\\n\\n # delay chain will be rotated 90, so move it over a width\\n # we move it up a inv height just for some routing room\\n self.rbl_inv_offset = vector(self.delay_chain.height, self.inv.width)\\n # access TX goes right on top of inverter, leave space for an inverter which is\\n # about the same as a TX. We'll need to add rails though.\\n self.access_tx_offset = vector(1.25*self.inv.height,self.rbl_inv_offset.y) + vector(0,2.5*self.inv.width)\\n self.delay_chain_offset = self.rbl_inv_offset + vector(0,4*self.inv.width)\\n\\n # Replica bitline and such are not rotated, but they must be placed far enough\\n # away from the delay chain/inverter with space for three M2 tracks\\n self.bitcell_offset = self.rbl_inv_offset + vector(2*self.m2_pitch, 0) + vector(0, self.bitcell.height + self.inv.width)\\n\\n self.rbl_offset = self.bitcell_offset\\n\\n \\n self.height = self.rbl_offset.y + self.rbl.height + self.m2_pitch\\n self.width = self.rbl_offset.x + self.bitcell.width\",\n \"def pc_work_time(self) -> \\\"float\\\":\\n return _beamforming_swig.phasedarray_sptr_pc_work_time(self)\",\n \"def compute_offsets(task, nc_per_task, is_cifar):\\n if is_cifar:\\n offset1 = task * nc_per_task\\n offset2 = (task + 1) * nc_per_task\\n else:\\n offset1 = 0\\n offset2 = nc_per_task\\n return offset1, offset2\",\n \"def compute_offsets(task, nc_per_task, is_cifar):\\n if is_cifar:\\n offset1 = task * nc_per_task\\n offset2 = (task + 1) * nc_per_task\\n else:\\n offset1 = 0\\n offset2 = nc_per_task\\n return offset1, offset2\",\n \"def GetCurrentOffset():\\r\\n return GetData().offsetCurrent\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.hdlc_framer_sptr_pc_work_time_total(self)\",\n \"def localTimeOffset(t=None):\\n\\tif t is None:\\n\\t\\tt = time.time()\\n\\t\\n\\tif time.localtime(t).tm_isdst and time.daylight:\\n\\t\\treturn -time.altzone\\n\\telse:\\n\\t\\treturn -time.timezone\",\n \"def dc_offset(self):\\n return self._read(0x0E, 0, 0xFF), self._read(0x0F, 0, 0xFF)\",\n \"def pc_work_time_total(self) -> \\\"float\\\":\\n return _beamforming_swig.phasedarray_sptr_pc_work_time_total(self)\",\n \"def lap(self):\\n oldtime = self._clock() - self._starttime\\n self._starttime = self._clock()\\n return oldtime\",\n \"def tzoffset(self):\\n return _tzoffset(self._tz, self._t)\",\n \"def phase_shift(annuli,annulus):\\n delta_t = viscous_timescale(annuli[annulus+1]) - viscous_timescale(annuli[annulus])\\n return int(delta_t)\",\n \"def arcsec_per_kpc_from(self, redshift: float) -> float:\\r\\n return self.arcsec_per_kpc_proper(z=redshift).value\",\n \"def _adjusted_time(self, otime: float = 0):\\n if 'xtime_adjustment' in self.__timing_parameters:\\n return time.time() - self.__timing_parameters['xtime_adjustment'] - otime\\n else:\\n return time.time() - otime\",\n \"def pc_work_time_total(self):\\n return _spacegrant_swig.message_debug_sptr_pc_work_time_total(self)\",\n \"def get_time(self):\\n clock = self.pipeline.get_clock()\\n tm = clock.get_internal_time()\\n return tm / 1.e9\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.general_burster_2_sptr_pc_work_time(self)\",\n \"def pc_work_time_total(self):\\n return _uhd_swig.usrp_sink_sptr_pc_work_time_total(self)\",\n \"def utc_to_tt_offset(time: dt.datetime) -> float:\\n if time.year < 1972:\\n raise ValueError(\\\"dates prior to 1972 are not currently supported\\\")\\n # this includes the horrible fractional leap seconds prior to 1972\\n # and the base 32.184 s offset between TAI and TT\\n offset = 42.184\\n for threshold in LEAP_SECOND_THRESHOLDS:\\n if time > threshold:\\n offset += 1\\n return offset\",\n \"def get_unixtime(self):\\n if not self.Complete():\\n raise DateTimeError(\\\"get_unixtime requires complete timepoint\\\")\\n zoffset = self.time.GetZoneOffset()\\n if zoffset is None:\\n raise DateTimeError(\\\"get_unixtime requires timezone\\\")\\n elif zoffset == 0:\\n zt = self\\n else:\\n zt = self.ShiftZone(zDirection=0)\\n days = zt.date.GetAbsoluteDay() - EPOCH.date.GetAbsoluteDay()\\n seconds = zt.time.GetTotalSeconds() - EPOCH.time.GetTotalSeconds()\\n return 86400 * days + seconds\",\n \"def orig_time(self) -> float:\\n return ntp_to_system_time(self.orig_timestamp)\",\n \"def calc_frame_time(instrument, aperture, xdim, ydim, amps):\\n instrument = instrument.lower()\\n if instrument == \\\"nircam\\\":\\n xs = xdim\\n ys = ydim\\n colpad = 12\\n\\n # Fullframe\\n if amps == 4:\\n rowpad = 1\\n fullpad = 1\\n else:\\n # All subarrays\\n rowpad = 2\\n fullpad = 0\\n if ((xdim <= 8) & (ydim <= 8)):\\n # The smallest subarray\\n rowpad = 3\\n\\n elif instrument == \\\"niriss\\\":\\n xs = ydim\\n ys = xdim\\n colpad = 12\\n\\n # Fullframe\\n if amps == 4:\\n rowpad = 1\\n fullpad = 1\\n else:\\n rowpad = 2\\n fullpad = 0\\n\\n elif instrument == 'fgs':\\n xs = ydim\\n ys = xdim\\n colpad = 6\\n if 'acq1' in aperture.lower():\\n colpad = 12\\n rowpad = 1\\n if amps == 4:\\n fullpad = 1\\n else:\\n fullpad = 0\\n\\n return ((1.0 * xs / amps + colpad) * (ys + rowpad) + fullpad) * 1.e-5\",\n \"def pc_work_time(self):\\n return _uhd_swig.usrp_sink_sptr_pc_work_time(self)\",\n \"def get_log_pos(timer, lane_speed):\\n log_pos = timer * lane_speed\\n if log_pos < 0:\\n log_pos = 64 - (abs(log_pos) % 64)\\n return log_pos\",\n \"def smpte_offset(self) -> int:\\n return self.__smpte_offset\",\n \"def pc_work_time_avg(self):\\n return _spacegrant_swig.invert_bit_sptr_pc_work_time_avg(self)\",\n \"def pc_work_time(self):\\n return _add_vector_swig.add_vector_2_cpp_sptr_pc_work_time(self)\",\n \"def get_eclampsia_time(self):\\n return self._stateMonitor.get_eclampsia_time()\",\n \"def get_panels_pcb_offset():\\n mount_hole_offset = arena_assembly['panels_to_hallway_gap']\\n mount_hole_offset -= arena_assembly['panels_assembly_offset']\\n mount_hole_offset += 0.5*hallway_bottom_plate['width']\\n mount_hole_offset += 0.5*panels_pcb['width']\\n return mount_hole_offset\",\n \"def get_clock(self):\\n return self.clock\",\n \"def pc_work_time_avg(self):\\n return _spacegrant_swig.udp_debug_sptr_pc_work_time_avg(self)\",\n \"def pc_work_time(self):\\n return _spacegrant_swig.message_debug_sptr_pc_work_time(self)\",\n \"def localtime(stamp):\\n return stamp - utc_offset\",\n \"def adjust_pc(pc):\\n # FIXME\\n pc[0, :] = pc[-1, :]\\n\\n return crop(np.fft.fftshift(pc), width=100).real\",\n \"def get_wcs_integer_pixel_offset(self):\\n # Grab the WCS of the first image\\n refWCS = self.image1.wcs\\n\\n # Estimate the central location for this image\\n refX, refY = self.image1.shape[1]//2, self.image1.shape[0]//2\\n\\n # Convert pixels to sky coordinates\\n refRA, refDec = refWCS.all_pix2world(refX, refY, 0, ra_dec_order=True)\\n\\n # Compute the pixel location of the reference RA and Dec\\n dx, dy = self.image2.wcs.all_world2pix(refRA, refDec, 0)\\n\\n # Convert these relativeoffsets into integer values\\n dx, dy = int(dx - refX), int(dy - refY)\\n\\n # Return the image offsets\\n return (dx, dy)\",\n \"def pc_work_time_total(self):\\n return _uhd_swig.usrp_source_sptr_pc_work_time_total(self)\",\n \"def calcOffset(self, x, y):\\r\\n # Datalayout\\r\\n # X = longitude\\r\\n # Y = latitude\\r\\n # Sample for size 1201x1201\\r\\n # ( 0/1200) ( 1/1200) ... (1199/1200) (1200/1200)\\r\\n # ( 0/1199) ( 1/1199) ... (1199/1199) (1200/1199)\\r\\n # ... ... ... ...\\r\\n # ( 0/ 1) ( 1/ 1) ... (1199/ 1) (1200/ 1)\\r\\n # ( 0/ 0) ( 1/ 0) ... (1199/ 0) (1200/ 0)\\r\\n # Some offsets:\\r\\n # (0/1200) 0\\r\\n # (1200/1200) 1200\\r\\n # (0/1199) 1201\\r\\n # (1200/1199) 2401\\r\\n # (0/0) 1201*1200\\r\\n # (1200/0) 1201*1201-1\\r\\n return x + self.size * (self.size - y - 1)\",\n \"def pc_work_time_avg(self):\\n return _spacegrant_swig.ax25_udp_pdu_gen_sptr_pc_work_time_avg(self)\",\n \"def get_offset():\\n offset = datetime.date.today() - start_day\\n return int(offset.days) - 4\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62899196","0.60005045","0.59686583","0.5939301","0.5939301","0.58321625","0.5753285","0.574835","0.5717388","0.5690558","0.5614201","0.5609203","0.56034964","0.5539353","0.55265343","0.5476326","0.54753363","0.5435063","0.54001856","0.5394224","0.53915477","0.5379569","0.537324","0.53611475","0.53468376","0.5333281","0.53170574","0.5315438","0.5311826","0.5309783","0.5286227","0.5283138","0.5280934","0.52653605","0.5265237","0.5263932","0.52629995","0.5256782","0.5255543","0.525436","0.5250584","0.5244999","0.52416986","0.52309597","0.52278566","0.5216739","0.52107435","0.5210025","0.52094364","0.5184079","0.517391","0.5166035","0.51625526","0.51613575","0.51582575","0.51562595","0.5149433","0.51439923","0.5126642","0.5125509","0.5119771","0.51146364","0.5114444","0.5113234","0.51081735","0.51081735","0.51025784","0.5097987","0.5093185","0.5091739","0.5087254","0.50867736","0.5074724","0.5066015","0.5053498","0.50466365","0.50406283","0.5039063","0.5035459","0.5028628","0.5017114","0.5007595","0.49919572","0.49916157","0.49892473","0.4988347","0.49877712","0.49829936","0.49774852","0.49772555","0.49745262","0.4972733","0.49700907","0.49624422","0.49573904","0.49497405","0.49496987","0.49487835","0.49389336","0.49338242","0.49328429"],"string":"[\n \"0.62899196\",\n \"0.60005045\",\n \"0.59686583\",\n \"0.5939301\",\n \"0.5939301\",\n \"0.58321625\",\n \"0.5753285\",\n \"0.574835\",\n \"0.5717388\",\n \"0.5690558\",\n \"0.5614201\",\n \"0.5609203\",\n \"0.56034964\",\n \"0.5539353\",\n \"0.55265343\",\n \"0.5476326\",\n \"0.54753363\",\n \"0.5435063\",\n \"0.54001856\",\n \"0.5394224\",\n \"0.53915477\",\n \"0.5379569\",\n \"0.537324\",\n \"0.53611475\",\n \"0.53468376\",\n \"0.5333281\",\n \"0.53170574\",\n \"0.5315438\",\n \"0.5311826\",\n \"0.5309783\",\n \"0.5286227\",\n \"0.5283138\",\n \"0.5280934\",\n \"0.52653605\",\n \"0.5265237\",\n \"0.5263932\",\n \"0.52629995\",\n \"0.5256782\",\n \"0.5255543\",\n \"0.525436\",\n \"0.5250584\",\n \"0.5244999\",\n \"0.52416986\",\n \"0.52309597\",\n \"0.52278566\",\n \"0.5216739\",\n \"0.52107435\",\n \"0.5210025\",\n \"0.52094364\",\n \"0.5184079\",\n \"0.517391\",\n \"0.5166035\",\n \"0.51625526\",\n \"0.51613575\",\n \"0.51582575\",\n \"0.51562595\",\n \"0.5149433\",\n \"0.51439923\",\n \"0.5126642\",\n \"0.5125509\",\n \"0.5119771\",\n \"0.51146364\",\n \"0.5114444\",\n \"0.5113234\",\n \"0.51081735\",\n \"0.51081735\",\n \"0.51025784\",\n \"0.5097987\",\n \"0.5093185\",\n \"0.5091739\",\n \"0.5087254\",\n \"0.50867736\",\n \"0.5074724\",\n \"0.5066015\",\n \"0.5053498\",\n \"0.50466365\",\n \"0.50406283\",\n \"0.5039063\",\n \"0.5035459\",\n \"0.5028628\",\n \"0.5017114\",\n \"0.5007595\",\n \"0.49919572\",\n \"0.49916157\",\n \"0.49892473\",\n \"0.4988347\",\n \"0.49877712\",\n \"0.49829936\",\n \"0.49774852\",\n \"0.49772555\",\n \"0.49745262\",\n \"0.4972733\",\n \"0.49700907\",\n \"0.49624422\",\n \"0.49573904\",\n \"0.49497405\",\n \"0.49496987\",\n \"0.49487835\",\n \"0.49389336\",\n \"0.49338242\",\n \"0.49328429\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84661,"cells":{"query":{"kind":"string","value":"Return FITS keyword, according to HCSS handling."},"document":{"kind":"string","value":"def _hcss_fits_keyword(header, keyword, *args):\n if len(args) > 1:\n raise ValueError('Invalid number of arguments.')\n for k in header.keys():\n if not k.startswith('key.'):\n continue\n if header[k] == keyword:\n return header[k[4:]]\n if len(args) == 1:\n return args[0]\n raise KeyError(\"Keyword '{0}' not found.\".format(keyword))"},"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 cached_dm_find_fits_keyword(key):\n return MODEL.find_fits_keyword(key.upper(), return_result=True)","def getKeyword(self, key):\n try:\n return self.raw[0].header[key]\n except:\n return self.raw[0].header['HIERARCH ESO '+key]","def translate_keyword(keyword):\n define = {\n '运动类型': 'Sport Type',\n '性别': 'Sex',\n '颜色': 'Color',\n '鞋透气指数': 'Shoes breathability index',\n '鞋软硬指数': 'Shoe soft and hard index',\n }\n if keyword in define:\n return define[keyword]\n else:\n return keyword","def getformalname(self, tag: str) -> Union[str, None]:\n for key in self.formal_names:\n if key in tag.lower():\n if key == \"pca\":\n if \"pca-intrin\" in tag.lower():\n return self.formal_names[\"pca-intrin\"]\n\n elif \"pca-full\" in tag.lower():\n return self.formal_names[\"pca-full\"]\n\n else:\n return self.formal_names[\"pca\"]\n \n else:\n return self.formal_names[key]\n\n # Exit case if key -> value not in mapping\n return None","def _keyfunct(cls, f):\n return re.search(r'SPT-CLJ\\d+[+-]?\\d+[-\\d+]?', f).group(0)","def key_f(f):\n regex_res = re.search(r'(?<=Magnetization\\-)[0-9]+(?=\\-)', f).group(0)\n return regex_res","def freq(self):\n a = re.search('(?<=_)[K,C,L,P]{1}(?<!_)', self.fname)\n if a is None:\n raise Exception(\"Can't determine frequency freq from CFX file\")\n else:\n return a.group()","def fkg(word, sent, syll):\n flesch_kincaid_grade = (0.39* (word / sent)) + (11.8 * (syll / word)) - 15.59\n return flesch_kincaid_grade","def cget(self, key):\n if key in (text_s, text_as):\n return self.text\n if key in ttfont_dict_keys:\n return self.font_d.get(key)\n if key in (case_s, case_as) or key in case_dict_keys:\n return self.case\n return super().cget(key)","def fits_idx(idx):\n fits_list = dict(zip(list(map((lambda x: 2**x),range(6))),\n ['HIRES','ESI','UVES','XX','MIKEb','MIKEr']))\n try:\n return fits_list[idx]\n except:\n return 'Unknown'","def fitsFormatLookup(x):\n \n # This is a python dictionary to lookup mappings.\n return {\n 'L' : 'bool_',\n 'X' : 'bool_',\n 'B' : 'ubyte',\n 'I' : 'int16',\n 'J' : 'int32',\n 'K' : 'int64',\n 'A' : 'str_',\n 'E' : 'float32',\n 'D' : 'float64',\n 'C' : 'complex64',\n 'M' : 'complex128',\n 'P' : 'float32'\n }.get(x, 'float32')","def frequency(word, freq):\n if word in freq:\n if freq[word] > 2:\n return 'high'\n else:\n return 'low'\n else:\n return 'none'","def calico_kitty():\n return __cat_whisperer(colors=True, coat='calico_colorz', logo_colorz='logo_colorz')[Cat.ASS]","def keyword_from_meaning(name):\n # Try to adhere to keyword scheme in DICOM (CP850)\n\n # singular/plural alternative forms are made plural\n # e.g., “Physician(s) of Record” becomes “PhysiciansOfRecord”\n name = name.replace(\"(s)\", \"s\")\n\n # “Patient’s Name” -> “PatientName”\n # “Operators’ Name” -> “OperatorsName”\n name = name.replace(\"’s \", \" \")\n name = name.replace(\"'s \", \" \")\n name = name.replace(\"s’ \", \"s \")\n name = name.replace(\"s' \", \"s \")\n\n # Mathematical symbols\n name = name.replace(\"%\", \" Percent \")\n name = name.replace(\">\", \" Greater Than \")\n name = name.replace(\"=\", \" Equals \")\n name = name.replace(\"<\", \" Lesser Than \")\n\n name = re.sub(r\"([0-9]+)\\.([0-9]+)\", \"\\\\1 Point \\\\2\", name)\n name = re.sub(r\"\\s([0-9.]+)-([0-9.]+)\\s\", \" \\\\1 To \\\\2 \", name)\n\n name = re.sub(r\"([0-9]+)day\", \"\\\\1 Day\", name)\n name = re.sub(r\"([0-9]+)y\", \"\\\\1 Years\", name)\n\n # Remove category modifiers, such as \"(specimen)\", \"(procedure)\",\n # \"(body structure)\", etc.\n name = re.sub(r\"^(.+) \\([a-z ]+\\)$\", \"\\\\1\", name)\n\n name = camel_case(name.strip())\n\n # Python variables must not begin with a number.\n if re.match(r\"[0-9]\", name):\n name = \"_\" + name\n\n return name","def get_hst_filter(header):\n if 'FILTER' in header:\n return header['FILTER'].upper()\n \n if header['INSTRUME'].strip() == 'ACS':\n for i in [1,2]:\n filter_i = header['FILTER{0:d}'.format(i)]\n if 'CLEAR' in filter_i:\n continue\n else:\n filter = filter_i\n \n elif header['INSTRUME'] == 'WFPC2':\n filter = header['FILTNAM1']\n else:\n raise KeyError ('Filter keyword not found for instrument {0}'.format(header['INSTRUME']))\n \n return filter.upper()","def gf_header_key(header, key='2_XC'):\n return float(header[key].split()[0].strip('[]').strip('*').strip('{').strip('}'))","def get_key_from_var(var):\n var_rgx = r'_?(cos(alpha|th)|phi)_[A-Z]{2}'\n var_match = re.search(var_rgx, var)\n if var_match:\n hist_var = var_match.group(1)\n return hist_var\n return ''","def map_what(self, what):\n res = None\n import zikeshop\n if what == \"category\":\n res = zikeshop.Category\n elif what==\"product\":\n res = zikeshop.Product\n elif what==\"sale\":\n res = zikeshop.Sale\n elif what==\"style\":\n res = zikeshop.Style\n return res","def get_keyword(package):\n\ttry:\n\t\tsubstr = re.search(r'(\\S+)_(\\S+)', package)\n\t\tif substr:\n\t\t\treturn substr.groups()\n\texcept Exception,e:\n\t\tlog.error(str(e))\n\t\treturn None","def cisfun(text):\n text = text.replace(\"_\", \" \")\n return \"C {}\".format(text)","def hilfe(self):\n sKreis_hilfe(3)","def quality(value: str) -> str:\n if \"HDTV\" in value:\n return \"HDTV\"\n else:\n return \"SD\"","def get_kurucz_phys(sed_name):\n if sed_name[1] == 'p':\n metallicity_sgn = 1.0\n elif sed_name[1] == 'm':\n metallicity_sgn = -1.0\n else:\n raise RuntimeError('Cannot parse metallicity sign of %s' % sed_name)\n\n new_name = sed_name.replace('.','_').split('_')\n\n metallicity = 0.1*metallicity_sgn*float(new_name[0][2:])\n\n teff = float(new_name[-2])\n\n logg = 0.1*np.float(new_name[3][1:])\n\n return teff, metallicity, logg","def return_category_from_value_HML(val):\n val = int(val.values[0])\n if val == 5:\n return 'H'\n elif val == 4:\n return 'M'\n else:\n return 'L'","def hax(string):\r\n hax_dict = { }\r\n return hax_dict.get(string, string)","def _getFrequency(s, line, text):\n if len(s) > 0 and s[0].isalpha(): \n if s.lower() in _frequency:\n return _frequency[s.lower()]\n else:\n raise ValueError(\"invalid note name/frequency '%s' on line %d: %s\" % (s, line, text))\n else:\n return int(float(s))","def resolution(self):\n\t\tif self.name.endswith( '_LOW' ):\n\t\t\treturn 'LOW'\n\t\telif self.name.endswith( '_MID' ):\n\t\t\treturn 'MID'\n\t\telse:\n\t\t\treturn 'HIGH'","def hdfkey(self):\n\t\tpass","def get_instrument(self, header):\n for key in [self.instrument_key.upper(), self.instrument_key.lower()] + INSTRUMENT_KEYWORDS:\n try: # This hack makes FITS headers work prior to back-mapping to data model names.\n instr = header[key]\n except KeyError:\n continue\n else:\n if instr.upper() != \"UNDEFINED\":\n break\n else:\n raise crexc.CrdsError(\"Missing '%s' keyword in header for determining instrument.\" % self.instrument_key)\n return instr.upper()","def readable_keyword(s):\n if s and not s.startswith(\"*\") and not s.startswith(\"[\"):\n if s.count(\".\"):\n library, name = s.rsplit(\".\", 1)\n return library + \".\" + name[0:].title()\n else:\n return s\n else:\n return s","def frequencyLetterDic(s):\n pass","def get_sumkw(self):\n sumkw_l = self.read_register(4107, 0, 3) \n sumkw_h = self.read_register(4108, 0, 3) \n return (sumkw_h * 255) + sumkw_l","def define(word):\n\treturn lexicon.get(word.upper(), \"I couldn't find the definition of {}\\n\".format(word))","def get_wd_phys(sed_name):\n new_name = sed_name.replace('.','_').split('_')\n teff = float(new_name[-2])\n if new_name[1]!='He':\n logg = 0.1*float(new_name[2])\n else:\n logg = 0.1*float(new_name[3])\n\n return teff, -999.0, logg","def html_of_unit(quant):\n return quant.dimensionality.html","def fluid_properties(fluid_str):\n fluid_lib = {'water':(1000., 1.0e-6), \n 'glycol':(965.3,6.216e-4),\n 'glycerin':(1260,1.18e-3)}\n if fluid_str in fluid_lib.keys():\n return fluid_lib[fluid_str]\n else:\n print 'valid fluids are:'\n for keys in fluid_lib:\n print \" '%s' \" % keys\n raise KeyError('invalid fluid specified')","def fluid_properties(fluid_str):\n fluid_lib = {'water':(1000., 1.0e-6), \n 'glycol':(965.3,6.216e-4),\n 'glycerin':(1260,1.18e-3)}\n if fluid_str in fluid_lib.keys():\n return fluid_lib[fluid_str]\n else:\n print 'valid fluids are:'\n for keys in fluid_lib:\n print \" '%s' \" % keys\n raise KeyError('invalid fluid specified')","def label(self):\n G = self.__f.group()\n if is_Gamma0(G):\n group = ''\n elif is_Gamma1(G):\n group = 'G1'\n elif is_GammaH(G):\n group = 'GH[' + ','.join([str(z) for z in G._generators_for_H()]) + ']'\n return '%s%s%s'%(self.level(), cremona_letter_code(self.factor_number()), group)","def FSMLetterSymbol(letter):\n return FSMEmptyWordSymbol if letter is None else repr(letter)","def ky(self, k: int) -> float:\n result = self._read_inline(f\"ky({k})\")\n return result","def info_content(self,lookup_word):\n\t if self.N == 0:\n\t # poor man's lazy evaluation\n\t for sent in brown.sents():\n\t for word in sent:\n\t word = word.lower()\n\t if not word in self.brown_freqs.keys():\n\t self.brown_freqs[word] = 0\n\t self.brown_freqs[word] = self.brown_freqs[word] + 1\n\t self.N = self.N + 1\n\t lookup_word = lookup_word.lower()\n\t n = 0 if not lookup_word in self.brown_freqs.keys() else self.brown_freqs[lookup_word]\n\t return 1.0 - (math.log(n + 1) / math.log(self.N + 1))","def used_tex_func(val):\n return None","def series_type(series, type_defs):\n for key, search_strings in type_defs.items():\n # print('################')\n # print(key)\n for search_str in search_strings:\n # print(search_str)\n if series.name.lower().find(search_str.lower()) == -1:\n continue\n else:\n return key\n return ''","def return_category_from_value_HL(val):\n val = int(val.values[0])\n if val >= 4:\n return 'H'\n else:\n return 'L'","def bpix_kw(bpixtab):\n print('Verifying the header keywords of UVIS bad pixel table {}...'.format(bpixtab))\n print('USEAFTER:')\n print(fits.getheader(bpixtab)['USEAFTER'])\n print(' ')\n print('PEDIGREE:')\n print(fits.getheader(bpixtab)['PEDIGREE'])\n print(' ')\n print('DESCRIP:')\n print(fits.getheader(bpixtab)['DESCRIP'])\n print(' ')\n print('COMMENT:')\n print(fits.getheader(bpixtab)['COMMENT'])\n print(' ')\n print('HISTORY:')\n print(fits.getheader(bpixtab)['HISTORY'])","def spidex_human(variant_obj):\n if variant_obj.get('spidex') is None:\n return 'not_reported'\n elif abs(variant_obj['spidex']) < SPIDEX_HUMAN['low']['pos'][1]:\n return 'low'\n elif abs(variant_obj['spidex']) < SPIDEX_HUMAN['medium']['pos'][1]:\n return 'medium'\n else:\n return 'high'","def get_freq(self,term):\n\n try:\n return self.freq_dict[term]\n except:\n return None","def get_fid_from_fiducial_hypo_key(self, fhkey):\n return fhkey.split('_')[-2]","def get_keyword(arg: str, keyword_set: set) -> Keyword or None:\n arg = arg.lower().lstrip('-')\n for keyword in keyword_set:\n if arg == keyword.keyword or arg in keyword.aliases:\n return keyword\n\n return None","def as_human(self, prec: Optional[int] = None) -> str:\n return fn_human_count(FEATURES.feature_space, FEATURES.feature_1024,\n FEATURES.feature_iec)(self._value, self._unit, prec)","def get_scientific_name( species ):\n\n species = species.strip( ).lower( )\n result = species # fail-safe if there is no match in the loop\n for species_key in Species_Dict:\n if species in Species_Dict[ species_key ]:\n result = Species_Dict[ species_key ][ 3 ] # change assignment if you want to return another list element\n break\n return result","def get_british_term_definition(word: str) -> str:\n word = process_word(word)\n return BRITISH_ENGLISH_ONLY_TERMS[word]","def getSpecific(self, keyword, key):","def itransform_name_define(transform):\n if transform == 'tanh':\n return 'arctanh'\n elif transform == 'exp':\n return 'log'\n elif transform == 'logit':\n return 'ilogit'\n elif transform is None:\n return ''\n else:\n return None","def _get_faction(text):\n for faction in _FACTIONS:\n if faction in text:\n return faction\n return None","def fitshead(imgname):\n try:\n img_header = pyfits.getheader(imgname, ignore_missing_end = True)\n return img_header\n except IOError:\n print \"FITSHEAD: Unable to open FITS image %s. Stopping.\" %imgname\n \n return","def getDetector(self):\n\t\t#if self.offset5() == -18.5:\n\t\tif self.offset5() == -17.5:\n\t\t\tself.countername='Vortex'\n\t\tif self.offset5() == -2.5:\n\t\t\tself.countername='apd'\n\t\telse:\n\t\t\treturn \"No valid detector selected\"\n\t\treturn self.countername","def face_short(self):\n if self.value == Face.ace or \\\n self.value == Face.jack or \\\n self.value == Face.queen or \\\n self.value == Face.king:\n return self.value.name[0]\n else:\n return self.value.value","def getFit(self):\n if self.fits.has_key('default'):\n return self.fits['default']\n else:\n return None","def getMeasure(unique_name):","def getMeasure(unique_name):","def __call__(self, cname: str)->str:\n return self.like(cname, mx=1)[0]['FIPS']","def idf(word):\n return math.log10(len(news_content) / document_frequency(word) + 1)# 分母加1，可防止分母为0的情况","def _get_snow_rain_value(self, _dict):\n if _dict.get(\"1h\"):\n return _dict.get(\"1h\")\n if _dict.get(\"3h\"):\n return _dict.get(\"3h\")\n if _dict.get(\"all\"):\n return _dict.get(\"all\")\n return None","def py_to_fits(val):\n\n vtype=type(val[0])\n \n if(vtype is int):\n return 'J'\n elif(vtype is float):\n return 'D'\n elif(vtype is str):\n size=len(max(val,key=len))\n return 'A'+str(size)\n else:\n print \"ERROR: No known FITS type for python type\",vtype\n sys.exit(1)","def get_flashcard(self):\n return f'{self.word}; \"{self.definition}\"'","def get_flashcard(self):\n return f'{self.word}; \"{self.definition}\"'","def get_fc(self, layer):\n return getattr(self, 'attention_{}'.format(layer))","def med_in_hindi(word):\r\n\treturn int(med(correction(word),word))","def get_width(par_dict):\n wd_attrs = [\"width\", \"range_samples\", \"CHP_num_samp\", \"map_width\",\n \"interferogram_width\", \"range_samp_1\"]\n try:\n wd = par_dict.get_first_match(wd_attrs)\n # wd = [getattr(par_dict, attr) for attr in par_dict.keys() if attr in wd_attrs]\n # #Return first match\n return wd\n except AttributeError:\n par_dict = par_to_dict(par_dict)\n wd = par_dict.get_first_match(wd_attrs)\n return wd\n else:\n raise KeyError('Did not find any keyword describing width of dataset')\n return wd","def _features_of(entry: _LexiconEntry) -> str:\n return entry[\"features\"]","def hfg():\r\n fruit = random.choice(pycorpora.foods.fruits[\"fruits\"])\r\n bread = random.choice(pycorpora.foods.breads_and_pastries[\"breads\"])\r\n animal = random.choice(pycorpora.animals.common[\"animals\"])\r\n beer = random.choice(pycorpora.foods.beer_styles[\"beer_styles\"])\r\n sausage = random.choice(pycorpora.foods.sausages[\"sausages\"])\r\n \r\n return(\"A %s %s, with a %s chutney upon %s.\" % (animal, sausage, fruit, bread))","def _get_string_cfdi(text, size=100):\n if not text:\n return None\n text = text.replace('|', ' ').replace('/', '').replace('-', '').replace('_', '')\n return text.strip()[:size]","def imgwhat(fn, fast=None):\n\n if fast == 1:\n (base, ext) = splitext(fn)\n if ext[1:].lower() in fast_imgexts:\n return ext.lower()\n else:\n return None\n else:\n # slow method, requires opening the file\n try:\n return imghdr.what(fn)\n except IOError:\n return None","def filename_format(keyword):\r\n tmp = re.sub('[^0-9a-zA-Z]', '_', keyword).strip('_')\r\n return re.sub('_+', '_', tmp).lower()","def get_american_term_definition(word: str) -> str:\n word = process_word(word)\n return AMERICAN_ENGLISH_ONLY_TERMS[word]","def _latex_(self):\n return \"\\\\Gamma_0(%s)\"%self.level()","def get_screen_type(self, temperature):\n if self.is_permissive_temperature(temperature):\n return 'ENH'\n elif self.is_restrictive_temperature(temperature):\n return 'SUP'\n else:\n return None","def getdef(self, handle):\n \n return self.fhdict.get(handle.lower(), (None, None))","def get_hypo_from_fiducial_hypo_key(self, fhkey):\n return fhkey.split('_')[0]","def _get_valid_foma_regex_name(self, candidate):\n if candidate == self.unknown_category:\n return 'unknownCat'\n name = self.delete_foma_reserved_symbols(candidate)\n if not name:\n return None\n return u'%sCat' % name","def cor_keyword(fn):\n ra, dec = func.get_ra_dec(fn)\n func.set_ra_dec(fn, ra, dec) # set ra dec\n iraf.hedit(images=fn, fields='EPOCH', value='2000.000', add='Yes',\n addonly='No', delete='No', verify='No', show='Yes',\n update='Yes') # set epoch\n dateobs = pyfits.getval(fn, 'DATE-OBS')\n sidtime = get_sidereal_time2(dateobs)\n iraf.hedit(images=fn, fields='LST', value=sidtime, add='Yes', addonly='No',\n delete='No', verify='No', show='Yes', update='Yes')\n func.set_airmass(fn)","def filter_headers(self, header):\n if header == \"Ticker symbol\":\n return \"symbol\"\n elif header == \"GICS Sector\":\n return \"sector\"\n elif header == \"Security\":\n return \"name\"\n elif header == \"GICS Sub Industry\":\n return \"industry\"\n else:\n return header","def category(self):\n if self.is_terminal():\n return \"Word\"\n return self.label[feature_type]","def hgvs_three(self):\n try:\n return 'p.' + str(self.hp.parse(self.term).posedit)\n except hgvs.exceptions.HGVSParseError:\n # Log me\n # print(self.term)\n return None","def feature_dist_func_dict():\n return {\"tanimoto_dissimilarity\": tanimoto_dissimilarity}","def get_frequency(self):\r\n x = self.query('SOUR:FREQ:CW?')\r\n if x == None: return None\r\n return float(x)","def get_frequency(self):\r\n x = self.query('SOUR:FREQ:CW?')\r\n if x == None: return None\r\n return float(x)","def GetKeyword(self,prompt=''):\n\t\treturn self.acad.ActiveDocument.Utility.GetKeyword(prompt)","def chooseStyle(c):\n if c == None: return None\n c = c[:3]\n styledict = {}\n styledict['alt'] = \"alpha\"\n if c in styledict:\n return styledict[c]\n else:\n return None","def printHWHeader(keyword, count):\n\n print (\n \"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n\\n\" +\n \"Social Computing HW1\\n\" +\n \"Donghun Lee, 2012-23867\\n\" +\n \"This is twitter result for\\n\" +\n \"Keyword :\" + keyword + \" Query amount :\" + str(count))","def get_mlt_phys(sed_name):\n\n new_name = sed_name.replace('+','-').replace('a','-').split('-')\n\n logg_sgn_dex = len(new_name[0])\n\n if sed_name[logg_sgn_dex] == '-':\n logg_sgn = 1.0\n elif sed_name[logg_sgn_dex] == '+':\n logg_sgn = -1.0\n else:\n raise RuntimeError('Cannot get logg_sgn for %s' % sed_name)\n\n metallicity_sgn_dex = len(new_name[0]) + len(new_name[1]) + 1\n\n if sed_name[metallicity_sgn_dex] == '-':\n metallicity_sgn = -1.0\n elif sed_name[metallicity_sgn_dex] == '+':\n metallicity_sgn = 1.0\n else:\n raise RuntimeError('Cannot get metallicity_sgn for %s' % sed_name)\n\n teff = 100.0*float(new_name[0][3:])\n metallicity = metallicity_sgn*float(new_name[2])\n logg = logg_sgn*float(new_name[1])\n\n return teff, metallicity, logg","def _get_category(identifier: str) -> str:\n for category, keywords in categories.items():\n # Check for each keyword\n for k in keywords:\n # Check if lower-case keyword is substring of lower-case identifier\n if identifier.lower().find(k.lower()) != -1:\n return category\n # Default value if no category was found\n return 'other'","def crawler_format(keyword):\r\n tmp = re.sub('[^0-9a-zA-Z]', '_', keyword).strip('_')\r\n return re.sub('_+', ' ', tmp).lower()","def outfigname(num, ext, char=\"\"):\n return \"f{}{}{}\".format(num, char, ext)","def getFrequency(s,d):\n #if the character is in the dictionary \n if s in d:\n #the value is returned \n return d[s]\n #if not returns 0 (since its not in the dictionary)\n \n else:\n return 0","def surf_text(mukey):\n #read appropriate soils.in content to a python list\n mukey = str(mukey)\n soil_path = \"/data/paustian/ernie/SSURGO_master_script/soil_test2/\"\n soil_fpath = soil_path+mukey[:-3]+\"/\"+mukey+\".in\"\n data_input = open(soil_fpath, 'r')\n top = next(data_input).split()\n sand = float(top[7])\n clay = float(top[8])\n silt = round(1-sand-clay, 2)\n\n return sand, silt, clay","def get_shear_style(data):\n if 'dsensum' in data.dtype.names:\n shear_style='lensfit'\n else:\n shear_style='reduced'\n return shear_style","def sanitize(header, keyword, type=float, default=0.0):\n try:\n value = header[keyword]\n except KeyError:\n return type(default)\n #\n # try converting the keyword\n try:\n converted_value = type(value)\n except ValueError:\n return type(default)\n return converted_value","def to_symbol(text):\n text = text.upper()\n if text in (\"BGM\", \"BANGUMI\"):\n return \"bgm\"\n elif text in (\"MAL\", \"MYANIMELIST\"):\n return \"mal\"\n else:\n return None"],"string":"[\n \"def cached_dm_find_fits_keyword(key):\\n return MODEL.find_fits_keyword(key.upper(), return_result=True)\",\n \"def getKeyword(self, key):\\n try:\\n return self.raw[0].header[key]\\n except:\\n return self.raw[0].header['HIERARCH ESO '+key]\",\n \"def translate_keyword(keyword):\\n define = {\\n '运动类型': 'Sport Type',\\n '性别': 'Sex',\\n '颜色': 'Color',\\n '鞋透气指数': 'Shoes breathability index',\\n '鞋软硬指数': 'Shoe soft and hard index',\\n }\\n if keyword in define:\\n return define[keyword]\\n else:\\n return keyword\",\n \"def getformalname(self, tag: str) -> Union[str, None]:\\n for key in self.formal_names:\\n if key in tag.lower():\\n if key == \\\"pca\\\":\\n if \\\"pca-intrin\\\" in tag.lower():\\n return self.formal_names[\\\"pca-intrin\\\"]\\n\\n elif \\\"pca-full\\\" in tag.lower():\\n return self.formal_names[\\\"pca-full\\\"]\\n\\n else:\\n return self.formal_names[\\\"pca\\\"]\\n \\n else:\\n return self.formal_names[key]\\n\\n # Exit case if key -> value not in mapping\\n return None\",\n \"def _keyfunct(cls, f):\\n return re.search(r'SPT-CLJ\\\\d+[+-]?\\\\d+[-\\\\d+]?', f).group(0)\",\n \"def key_f(f):\\n regex_res = re.search(r'(?<=Magnetization\\\\-)[0-9]+(?=\\\\-)', f).group(0)\\n return regex_res\",\n \"def freq(self):\\n a = re.search('(?<=_)[K,C,L,P]{1}(?<!_)', self.fname)\\n if a is None:\\n raise Exception(\\\"Can't determine frequency freq from CFX file\\\")\\n else:\\n return a.group()\",\n \"def fkg(word, sent, syll):\\n flesch_kincaid_grade = (0.39* (word / sent)) + (11.8 * (syll / word)) - 15.59\\n return flesch_kincaid_grade\",\n \"def cget(self, key):\\n if key in (text_s, text_as):\\n return self.text\\n if key in ttfont_dict_keys:\\n return self.font_d.get(key)\\n if key in (case_s, case_as) or key in case_dict_keys:\\n return self.case\\n return super().cget(key)\",\n \"def fits_idx(idx):\\n fits_list = dict(zip(list(map((lambda x: 2**x),range(6))),\\n ['HIRES','ESI','UVES','XX','MIKEb','MIKEr']))\\n try:\\n return fits_list[idx]\\n except:\\n return 'Unknown'\",\n \"def fitsFormatLookup(x):\\n \\n # This is a python dictionary to lookup mappings.\\n return {\\n 'L' : 'bool_',\\n 'X' : 'bool_',\\n 'B' : 'ubyte',\\n 'I' : 'int16',\\n 'J' : 'int32',\\n 'K' : 'int64',\\n 'A' : 'str_',\\n 'E' : 'float32',\\n 'D' : 'float64',\\n 'C' : 'complex64',\\n 'M' : 'complex128',\\n 'P' : 'float32'\\n }.get(x, 'float32')\",\n \"def frequency(word, freq):\\n if word in freq:\\n if freq[word] > 2:\\n return 'high'\\n else:\\n return 'low'\\n else:\\n return 'none'\",\n \"def calico_kitty():\\n return __cat_whisperer(colors=True, coat='calico_colorz', logo_colorz='logo_colorz')[Cat.ASS]\",\n \"def keyword_from_meaning(name):\\n # Try to adhere to keyword scheme in DICOM (CP850)\\n\\n # singular/plural alternative forms are made plural\\n # e.g., “Physician(s) of Record” becomes “PhysiciansOfRecord”\\n name = name.replace(\\\"(s)\\\", \\\"s\\\")\\n\\n # “Patient’s Name” -> “PatientName”\\n # “Operators’ Name” -> “OperatorsName”\\n name = name.replace(\\\"’s \\\", \\\" \\\")\\n name = name.replace(\\\"'s \\\", \\\" \\\")\\n name = name.replace(\\\"s’ \\\", \\\"s \\\")\\n name = name.replace(\\\"s' \\\", \\\"s \\\")\\n\\n # Mathematical symbols\\n name = name.replace(\\\"%\\\", \\\" Percent \\\")\\n name = name.replace(\\\">\\\", \\\" Greater Than \\\")\\n name = name.replace(\\\"=\\\", \\\" Equals \\\")\\n name = name.replace(\\\"<\\\", \\\" Lesser Than \\\")\\n\\n name = re.sub(r\\\"([0-9]+)\\\\.([0-9]+)\\\", \\\"\\\\\\\\1 Point \\\\\\\\2\\\", name)\\n name = re.sub(r\\\"\\\\s([0-9.]+)-([0-9.]+)\\\\s\\\", \\\" \\\\\\\\1 To \\\\\\\\2 \\\", name)\\n\\n name = re.sub(r\\\"([0-9]+)day\\\", \\\"\\\\\\\\1 Day\\\", name)\\n name = re.sub(r\\\"([0-9]+)y\\\", \\\"\\\\\\\\1 Years\\\", name)\\n\\n # Remove category modifiers, such as \\\"(specimen)\\\", \\\"(procedure)\\\",\\n # \\\"(body structure)\\\", etc.\\n name = re.sub(r\\\"^(.+) \\\\([a-z ]+\\\\)$\\\", \\\"\\\\\\\\1\\\", name)\\n\\n name = camel_case(name.strip())\\n\\n # Python variables must not begin with a number.\\n if re.match(r\\\"[0-9]\\\", name):\\n name = \\\"_\\\" + name\\n\\n return name\",\n \"def get_hst_filter(header):\\n if 'FILTER' in header:\\n return header['FILTER'].upper()\\n \\n if header['INSTRUME'].strip() == 'ACS':\\n for i in [1,2]:\\n filter_i = header['FILTER{0:d}'.format(i)]\\n if 'CLEAR' in filter_i:\\n continue\\n else:\\n filter = filter_i\\n \\n elif header['INSTRUME'] == 'WFPC2':\\n filter = header['FILTNAM1']\\n else:\\n raise KeyError ('Filter keyword not found for instrument {0}'.format(header['INSTRUME']))\\n \\n return filter.upper()\",\n \"def gf_header_key(header, key='2_XC'):\\n return float(header[key].split()[0].strip('[]').strip('*').strip('{').strip('}'))\",\n \"def get_key_from_var(var):\\n var_rgx = r'_?(cos(alpha|th)|phi)_[A-Z]{2}'\\n var_match = re.search(var_rgx, var)\\n if var_match:\\n hist_var = var_match.group(1)\\n return hist_var\\n return ''\",\n \"def map_what(self, what):\\n res = None\\n import zikeshop\\n if what == \\\"category\\\":\\n res = zikeshop.Category\\n elif what==\\\"product\\\":\\n res = zikeshop.Product\\n elif what==\\\"sale\\\":\\n res = zikeshop.Sale\\n elif what==\\\"style\\\":\\n res = zikeshop.Style\\n return res\",\n \"def get_keyword(package):\\n\\ttry:\\n\\t\\tsubstr = re.search(r'(\\\\S+)_(\\\\S+)', package)\\n\\t\\tif substr:\\n\\t\\t\\treturn substr.groups()\\n\\texcept Exception,e:\\n\\t\\tlog.error(str(e))\\n\\t\\treturn None\",\n \"def cisfun(text):\\n text = text.replace(\\\"_\\\", \\\" \\\")\\n return \\\"C {}\\\".format(text)\",\n \"def hilfe(self):\\n sKreis_hilfe(3)\",\n \"def quality(value: str) -> str:\\n if \\\"HDTV\\\" in value:\\n return \\\"HDTV\\\"\\n else:\\n return \\\"SD\\\"\",\n \"def get_kurucz_phys(sed_name):\\n if sed_name[1] == 'p':\\n metallicity_sgn = 1.0\\n elif sed_name[1] == 'm':\\n metallicity_sgn = -1.0\\n else:\\n raise RuntimeError('Cannot parse metallicity sign of %s' % sed_name)\\n\\n new_name = sed_name.replace('.','_').split('_')\\n\\n metallicity = 0.1*metallicity_sgn*float(new_name[0][2:])\\n\\n teff = float(new_name[-2])\\n\\n logg = 0.1*np.float(new_name[3][1:])\\n\\n return teff, metallicity, logg\",\n \"def return_category_from_value_HML(val):\\n val = int(val.values[0])\\n if val == 5:\\n return 'H'\\n elif val == 4:\\n return 'M'\\n else:\\n return 'L'\",\n \"def hax(string):\\r\\n hax_dict = { }\\r\\n return hax_dict.get(string, string)\",\n \"def _getFrequency(s, line, text):\\n if len(s) > 0 and s[0].isalpha(): \\n if s.lower() in _frequency:\\n return _frequency[s.lower()]\\n else:\\n raise ValueError(\\\"invalid note name/frequency '%s' on line %d: %s\\\" % (s, line, text))\\n else:\\n return int(float(s))\",\n \"def resolution(self):\\n\\t\\tif self.name.endswith( '_LOW' ):\\n\\t\\t\\treturn 'LOW'\\n\\t\\telif self.name.endswith( '_MID' ):\\n\\t\\t\\treturn 'MID'\\n\\t\\telse:\\n\\t\\t\\treturn 'HIGH'\",\n \"def hdfkey(self):\\n\\t\\tpass\",\n \"def get_instrument(self, header):\\n for key in [self.instrument_key.upper(), self.instrument_key.lower()] + INSTRUMENT_KEYWORDS:\\n try: # This hack makes FITS headers work prior to back-mapping to data model names.\\n instr = header[key]\\n except KeyError:\\n continue\\n else:\\n if instr.upper() != \\\"UNDEFINED\\\":\\n break\\n else:\\n raise crexc.CrdsError(\\\"Missing '%s' keyword in header for determining instrument.\\\" % self.instrument_key)\\n return instr.upper()\",\n \"def readable_keyword(s):\\n if s and not s.startswith(\\\"*\\\") and not s.startswith(\\\"[\\\"):\\n if s.count(\\\".\\\"):\\n library, name = s.rsplit(\\\".\\\", 1)\\n return library + \\\".\\\" + name[0:].title()\\n else:\\n return s\\n else:\\n return s\",\n \"def frequencyLetterDic(s):\\n pass\",\n \"def get_sumkw(self):\\n sumkw_l = self.read_register(4107, 0, 3) \\n sumkw_h = self.read_register(4108, 0, 3) \\n return (sumkw_h * 255) + sumkw_l\",\n \"def define(word):\\n\\treturn lexicon.get(word.upper(), \\\"I couldn't find the definition of {}\\\\n\\\".format(word))\",\n \"def get_wd_phys(sed_name):\\n new_name = sed_name.replace('.','_').split('_')\\n teff = float(new_name[-2])\\n if new_name[1]!='He':\\n logg = 0.1*float(new_name[2])\\n else:\\n logg = 0.1*float(new_name[3])\\n\\n return teff, -999.0, logg\",\n \"def html_of_unit(quant):\\n return quant.dimensionality.html\",\n \"def fluid_properties(fluid_str):\\n fluid_lib = {'water':(1000., 1.0e-6), \\n 'glycol':(965.3,6.216e-4),\\n 'glycerin':(1260,1.18e-3)}\\n if fluid_str in fluid_lib.keys():\\n return fluid_lib[fluid_str]\\n else:\\n print 'valid fluids are:'\\n for keys in fluid_lib:\\n print \\\" '%s' \\\" % keys\\n raise KeyError('invalid fluid specified')\",\n \"def fluid_properties(fluid_str):\\n fluid_lib = {'water':(1000., 1.0e-6), \\n 'glycol':(965.3,6.216e-4),\\n 'glycerin':(1260,1.18e-3)}\\n if fluid_str in fluid_lib.keys():\\n return fluid_lib[fluid_str]\\n else:\\n print 'valid fluids are:'\\n for keys in fluid_lib:\\n print \\\" '%s' \\\" % keys\\n raise KeyError('invalid fluid specified')\",\n \"def label(self):\\n G = self.__f.group()\\n if is_Gamma0(G):\\n group = ''\\n elif is_Gamma1(G):\\n group = 'G1'\\n elif is_GammaH(G):\\n group = 'GH[' + ','.join([str(z) for z in G._generators_for_H()]) + ']'\\n return '%s%s%s'%(self.level(), cremona_letter_code(self.factor_number()), group)\",\n \"def FSMLetterSymbol(letter):\\n return FSMEmptyWordSymbol if letter is None else repr(letter)\",\n \"def ky(self, k: int) -> float:\\n result = self._read_inline(f\\\"ky({k})\\\")\\n return result\",\n \"def info_content(self,lookup_word):\\n\\t if self.N == 0:\\n\\t # poor man's lazy evaluation\\n\\t for sent in brown.sents():\\n\\t for word in sent:\\n\\t word = word.lower()\\n\\t if not word in self.brown_freqs.keys():\\n\\t self.brown_freqs[word] = 0\\n\\t self.brown_freqs[word] = self.brown_freqs[word] + 1\\n\\t self.N = self.N + 1\\n\\t lookup_word = lookup_word.lower()\\n\\t n = 0 if not lookup_word in self.brown_freqs.keys() else self.brown_freqs[lookup_word]\\n\\t return 1.0 - (math.log(n + 1) / math.log(self.N + 1))\",\n \"def used_tex_func(val):\\n return None\",\n \"def series_type(series, type_defs):\\n for key, search_strings in type_defs.items():\\n # print('################')\\n # print(key)\\n for search_str in search_strings:\\n # print(search_str)\\n if series.name.lower().find(search_str.lower()) == -1:\\n continue\\n else:\\n return key\\n return ''\",\n \"def return_category_from_value_HL(val):\\n val = int(val.values[0])\\n if val >= 4:\\n return 'H'\\n else:\\n return 'L'\",\n \"def bpix_kw(bpixtab):\\n print('Verifying the header keywords of UVIS bad pixel table {}...'.format(bpixtab))\\n print('USEAFTER:')\\n print(fits.getheader(bpixtab)['USEAFTER'])\\n print(' ')\\n print('PEDIGREE:')\\n print(fits.getheader(bpixtab)['PEDIGREE'])\\n print(' ')\\n print('DESCRIP:')\\n print(fits.getheader(bpixtab)['DESCRIP'])\\n print(' ')\\n print('COMMENT:')\\n print(fits.getheader(bpixtab)['COMMENT'])\\n print(' ')\\n print('HISTORY:')\\n print(fits.getheader(bpixtab)['HISTORY'])\",\n \"def spidex_human(variant_obj):\\n if variant_obj.get('spidex') is None:\\n return 'not_reported'\\n elif abs(variant_obj['spidex']) < SPIDEX_HUMAN['low']['pos'][1]:\\n return 'low'\\n elif abs(variant_obj['spidex']) < SPIDEX_HUMAN['medium']['pos'][1]:\\n return 'medium'\\n else:\\n return 'high'\",\n \"def get_freq(self,term):\\n\\n try:\\n return self.freq_dict[term]\\n except:\\n return None\",\n \"def get_fid_from_fiducial_hypo_key(self, fhkey):\\n return fhkey.split('_')[-2]\",\n \"def get_keyword(arg: str, keyword_set: set) -> Keyword or None:\\n arg = arg.lower().lstrip('-')\\n for keyword in keyword_set:\\n if arg == keyword.keyword or arg in keyword.aliases:\\n return keyword\\n\\n return None\",\n \"def as_human(self, prec: Optional[int] = None) -> str:\\n return fn_human_count(FEATURES.feature_space, FEATURES.feature_1024,\\n FEATURES.feature_iec)(self._value, self._unit, prec)\",\n \"def get_scientific_name( species ):\\n\\n species = species.strip( ).lower( )\\n result = species # fail-safe if there is no match in the loop\\n for species_key in Species_Dict:\\n if species in Species_Dict[ species_key ]:\\n result = Species_Dict[ species_key ][ 3 ] # change assignment if you want to return another list element\\n break\\n return result\",\n \"def get_british_term_definition(word: str) -> str:\\n word = process_word(word)\\n return BRITISH_ENGLISH_ONLY_TERMS[word]\",\n \"def getSpecific(self, keyword, key):\",\n \"def itransform_name_define(transform):\\n if transform == 'tanh':\\n return 'arctanh'\\n elif transform == 'exp':\\n return 'log'\\n elif transform == 'logit':\\n return 'ilogit'\\n elif transform is None:\\n return ''\\n else:\\n return None\",\n \"def _get_faction(text):\\n for faction in _FACTIONS:\\n if faction in text:\\n return faction\\n return None\",\n \"def fitshead(imgname):\\n try:\\n img_header = pyfits.getheader(imgname, ignore_missing_end = True)\\n return img_header\\n except IOError:\\n print \\\"FITSHEAD: Unable to open FITS image %s. Stopping.\\\" %imgname\\n \\n return\",\n \"def getDetector(self):\\n\\t\\t#if self.offset5() == -18.5:\\n\\t\\tif self.offset5() == -17.5:\\n\\t\\t\\tself.countername='Vortex'\\n\\t\\tif self.offset5() == -2.5:\\n\\t\\t\\tself.countername='apd'\\n\\t\\telse:\\n\\t\\t\\treturn \\\"No valid detector selected\\\"\\n\\t\\treturn self.countername\",\n \"def face_short(self):\\n if self.value == Face.ace or \\\\\\n self.value == Face.jack or \\\\\\n self.value == Face.queen or \\\\\\n self.value == Face.king:\\n return self.value.name[0]\\n else:\\n return self.value.value\",\n \"def getFit(self):\\n if self.fits.has_key('default'):\\n return self.fits['default']\\n else:\\n return None\",\n \"def getMeasure(unique_name):\",\n \"def getMeasure(unique_name):\",\n \"def __call__(self, cname: str)->str:\\n return self.like(cname, mx=1)[0]['FIPS']\",\n \"def idf(word):\\n return math.log10(len(news_content) / document_frequency(word) + 1)# 分母加1，可防止分母为0的情况\",\n \"def _get_snow_rain_value(self, _dict):\\n if _dict.get(\\\"1h\\\"):\\n return _dict.get(\\\"1h\\\")\\n if _dict.get(\\\"3h\\\"):\\n return _dict.get(\\\"3h\\\")\\n if _dict.get(\\\"all\\\"):\\n return _dict.get(\\\"all\\\")\\n return None\",\n \"def py_to_fits(val):\\n\\n vtype=type(val[0])\\n \\n if(vtype is int):\\n return 'J'\\n elif(vtype is float):\\n return 'D'\\n elif(vtype is str):\\n size=len(max(val,key=len))\\n return 'A'+str(size)\\n else:\\n print \\\"ERROR: No known FITS type for python type\\\",vtype\\n sys.exit(1)\",\n \"def get_flashcard(self):\\n return f'{self.word}; \\\"{self.definition}\\\"'\",\n \"def get_flashcard(self):\\n return f'{self.word}; \\\"{self.definition}\\\"'\",\n \"def get_fc(self, layer):\\n return getattr(self, 'attention_{}'.format(layer))\",\n \"def med_in_hindi(word):\\r\\n\\treturn int(med(correction(word),word))\",\n \"def get_width(par_dict):\\n wd_attrs = [\\\"width\\\", \\\"range_samples\\\", \\\"CHP_num_samp\\\", \\\"map_width\\\",\\n \\\"interferogram_width\\\", \\\"range_samp_1\\\"]\\n try:\\n wd = par_dict.get_first_match(wd_attrs)\\n # wd = [getattr(par_dict, attr) for attr in par_dict.keys() if attr in wd_attrs]\\n # #Return first match\\n return wd\\n except AttributeError:\\n par_dict = par_to_dict(par_dict)\\n wd = par_dict.get_first_match(wd_attrs)\\n return wd\\n else:\\n raise KeyError('Did not find any keyword describing width of dataset')\\n return wd\",\n \"def _features_of(entry: _LexiconEntry) -> str:\\n return entry[\\\"features\\\"]\",\n \"def hfg():\\r\\n fruit = random.choice(pycorpora.foods.fruits[\\\"fruits\\\"])\\r\\n bread = random.choice(pycorpora.foods.breads_and_pastries[\\\"breads\\\"])\\r\\n animal = random.choice(pycorpora.animals.common[\\\"animals\\\"])\\r\\n beer = random.choice(pycorpora.foods.beer_styles[\\\"beer_styles\\\"])\\r\\n sausage = random.choice(pycorpora.foods.sausages[\\\"sausages\\\"])\\r\\n \\r\\n return(\\\"A %s %s, with a %s chutney upon %s.\\\" % (animal, sausage, fruit, bread))\",\n \"def _get_string_cfdi(text, size=100):\\n if not text:\\n return None\\n text = text.replace('|', ' ').replace('/', '').replace('-', '').replace('_', '')\\n return text.strip()[:size]\",\n \"def imgwhat(fn, fast=None):\\n\\n if fast == 1:\\n (base, ext) = splitext(fn)\\n if ext[1:].lower() in fast_imgexts:\\n return ext.lower()\\n else:\\n return None\\n else:\\n # slow method, requires opening the file\\n try:\\n return imghdr.what(fn)\\n except IOError:\\n return None\",\n \"def filename_format(keyword):\\r\\n tmp = re.sub('[^0-9a-zA-Z]', '_', keyword).strip('_')\\r\\n return re.sub('_+', '_', tmp).lower()\",\n \"def get_american_term_definition(word: str) -> str:\\n word = process_word(word)\\n return AMERICAN_ENGLISH_ONLY_TERMS[word]\",\n \"def _latex_(self):\\n return \\\"\\\\\\\\Gamma_0(%s)\\\"%self.level()\",\n \"def get_screen_type(self, temperature):\\n if self.is_permissive_temperature(temperature):\\n return 'ENH'\\n elif self.is_restrictive_temperature(temperature):\\n return 'SUP'\\n else:\\n return None\",\n \"def getdef(self, handle):\\n \\n return self.fhdict.get(handle.lower(), (None, None))\",\n \"def get_hypo_from_fiducial_hypo_key(self, fhkey):\\n return fhkey.split('_')[0]\",\n \"def _get_valid_foma_regex_name(self, candidate):\\n if candidate == self.unknown_category:\\n return 'unknownCat'\\n name = self.delete_foma_reserved_symbols(candidate)\\n if not name:\\n return None\\n return u'%sCat' % name\",\n \"def cor_keyword(fn):\\n ra, dec = func.get_ra_dec(fn)\\n func.set_ra_dec(fn, ra, dec) # set ra dec\\n iraf.hedit(images=fn, fields='EPOCH', value='2000.000', add='Yes',\\n addonly='No', delete='No', verify='No', show='Yes',\\n update='Yes') # set epoch\\n dateobs = pyfits.getval(fn, 'DATE-OBS')\\n sidtime = get_sidereal_time2(dateobs)\\n iraf.hedit(images=fn, fields='LST', value=sidtime, add='Yes', addonly='No',\\n delete='No', verify='No', show='Yes', update='Yes')\\n func.set_airmass(fn)\",\n \"def filter_headers(self, header):\\n if header == \\\"Ticker symbol\\\":\\n return \\\"symbol\\\"\\n elif header == \\\"GICS Sector\\\":\\n return \\\"sector\\\"\\n elif header == \\\"Security\\\":\\n return \\\"name\\\"\\n elif header == \\\"GICS Sub Industry\\\":\\n return \\\"industry\\\"\\n else:\\n return header\",\n \"def category(self):\\n if self.is_terminal():\\n return \\\"Word\\\"\\n return self.label[feature_type]\",\n \"def hgvs_three(self):\\n try:\\n return 'p.' + str(self.hp.parse(self.term).posedit)\\n except hgvs.exceptions.HGVSParseError:\\n # Log me\\n # print(self.term)\\n return None\",\n \"def feature_dist_func_dict():\\n return {\\\"tanimoto_dissimilarity\\\": tanimoto_dissimilarity}\",\n \"def get_frequency(self):\\r\\n x = self.query('SOUR:FREQ:CW?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def get_frequency(self):\\r\\n x = self.query('SOUR:FREQ:CW?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def GetKeyword(self,prompt=''):\\n\\t\\treturn self.acad.ActiveDocument.Utility.GetKeyword(prompt)\",\n \"def chooseStyle(c):\\n if c == None: return None\\n c = c[:3]\\n styledict = {}\\n styledict['alt'] = \\\"alpha\\\"\\n if c in styledict:\\n return styledict[c]\\n else:\\n return None\",\n \"def printHWHeader(keyword, count):\\n\\n print (\\n \\\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\\\n\\\\n\\\" +\\n \\\"Social Computing HW1\\\\n\\\" +\\n \\\"Donghun Lee, 2012-23867\\\\n\\\" +\\n \\\"This is twitter result for\\\\n\\\" +\\n \\\"Keyword :\\\" + keyword + \\\" Query amount :\\\" + str(count))\",\n \"def get_mlt_phys(sed_name):\\n\\n new_name = sed_name.replace('+','-').replace('a','-').split('-')\\n\\n logg_sgn_dex = len(new_name[0])\\n\\n if sed_name[logg_sgn_dex] == '-':\\n logg_sgn = 1.0\\n elif sed_name[logg_sgn_dex] == '+':\\n logg_sgn = -1.0\\n else:\\n raise RuntimeError('Cannot get logg_sgn for %s' % sed_name)\\n\\n metallicity_sgn_dex = len(new_name[0]) + len(new_name[1]) + 1\\n\\n if sed_name[metallicity_sgn_dex] == '-':\\n metallicity_sgn = -1.0\\n elif sed_name[metallicity_sgn_dex] == '+':\\n metallicity_sgn = 1.0\\n else:\\n raise RuntimeError('Cannot get metallicity_sgn for %s' % sed_name)\\n\\n teff = 100.0*float(new_name[0][3:])\\n metallicity = metallicity_sgn*float(new_name[2])\\n logg = logg_sgn*float(new_name[1])\\n\\n return teff, metallicity, logg\",\n \"def _get_category(identifier: str) -> str:\\n for category, keywords in categories.items():\\n # Check for each keyword\\n for k in keywords:\\n # Check if lower-case keyword is substring of lower-case identifier\\n if identifier.lower().find(k.lower()) != -1:\\n return category\\n # Default value if no category was found\\n return 'other'\",\n \"def crawler_format(keyword):\\r\\n tmp = re.sub('[^0-9a-zA-Z]', '_', keyword).strip('_')\\r\\n return re.sub('_+', ' ', tmp).lower()\",\n \"def outfigname(num, ext, char=\\\"\\\"):\\n return \\\"f{}{}{}\\\".format(num, char, ext)\",\n \"def getFrequency(s,d):\\n #if the character is in the dictionary \\n if s in d:\\n #the value is returned \\n return d[s]\\n #if not returns 0 (since its not in the dictionary)\\n \\n else:\\n return 0\",\n \"def surf_text(mukey):\\n #read appropriate soils.in content to a python list\\n mukey = str(mukey)\\n soil_path = \\\"/data/paustian/ernie/SSURGO_master_script/soil_test2/\\\"\\n soil_fpath = soil_path+mukey[:-3]+\\\"/\\\"+mukey+\\\".in\\\"\\n data_input = open(soil_fpath, 'r')\\n top = next(data_input).split()\\n sand = float(top[7])\\n clay = float(top[8])\\n silt = round(1-sand-clay, 2)\\n\\n return sand, silt, clay\",\n \"def get_shear_style(data):\\n if 'dsensum' in data.dtype.names:\\n shear_style='lensfit'\\n else:\\n shear_style='reduced'\\n return shear_style\",\n \"def sanitize(header, keyword, type=float, default=0.0):\\n try:\\n value = header[keyword]\\n except KeyError:\\n return type(default)\\n #\\n # try converting the keyword\\n try:\\n converted_value = type(value)\\n except ValueError:\\n return type(default)\\n return converted_value\",\n \"def to_symbol(text):\\n text = text.upper()\\n if text in (\\\"BGM\\\", \\\"BANGUMI\\\"):\\n return \\\"bgm\\\"\\n elif text in (\\\"MAL\\\", \\\"MYANIMELIST\\\"):\\n return \\\"mal\\\"\\n else:\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61742735","0.5731916","0.5624878","0.5479709","0.5469909","0.536184","0.5338029","0.53282803","0.53036934","0.52704316","0.52200615","0.51690644","0.51421887","0.51387876","0.5137836","0.51041573","0.5076539","0.50673413","0.5035812","0.50308436","0.50272006","0.50262487","0.50196743","0.50173753","0.500825","0.49975553","0.49934474","0.49907222","0.49872246","0.49386328","0.49037862","0.48966122","0.48905268","0.48823112","0.48738497","0.48626825","0.48626825","0.4858303","0.48532042","0.48522928","0.48467785","0.48441964","0.4841772","0.48312643","0.4826281","0.4825617","0.4804036","0.48017725","0.479152","0.47914115","0.47900197","0.47887787","0.47874033","0.47833297","0.47712794","0.47702995","0.47699434","0.47696918","0.47692567","0.47671145","0.47671145","0.47666252","0.4760194","0.47576863","0.47506124","0.47275782","0.47275782","0.472612","0.47218496","0.471954","0.47113478","0.4706816","0.4702629","0.4701189","0.46970272","0.46968034","0.46862486","0.46852416","0.4683609","0.46781927","0.46733356","0.46665892","0.46616155","0.46608523","0.4650697","0.46500838","0.46486163","0.46486163","0.4648399","0.46395594","0.4638845","0.46360627","0.46278203","0.46265042","0.46176174","0.46160293","0.4615276","0.4614845","0.46069705","0.45988095"],"string":"[\n \"0.61742735\",\n \"0.5731916\",\n \"0.5624878\",\n \"0.5479709\",\n \"0.5469909\",\n \"0.536184\",\n \"0.5338029\",\n \"0.53282803\",\n \"0.53036934\",\n \"0.52704316\",\n \"0.52200615\",\n \"0.51690644\",\n \"0.51421887\",\n \"0.51387876\",\n \"0.5137836\",\n \"0.51041573\",\n \"0.5076539\",\n \"0.50673413\",\n \"0.5035812\",\n \"0.50308436\",\n \"0.50272006\",\n \"0.50262487\",\n \"0.50196743\",\n \"0.50173753\",\n \"0.500825\",\n \"0.49975553\",\n \"0.49934474\",\n \"0.49907222\",\n \"0.49872246\",\n \"0.49386328\",\n \"0.49037862\",\n \"0.48966122\",\n \"0.48905268\",\n \"0.48823112\",\n \"0.48738497\",\n \"0.48626825\",\n \"0.48626825\",\n \"0.4858303\",\n \"0.48532042\",\n \"0.48522928\",\n \"0.48467785\",\n \"0.48441964\",\n \"0.4841772\",\n \"0.48312643\",\n \"0.4826281\",\n \"0.4825617\",\n \"0.4804036\",\n \"0.48017725\",\n \"0.479152\",\n \"0.47914115\",\n \"0.47900197\",\n \"0.47887787\",\n \"0.47874033\",\n \"0.47833297\",\n \"0.47712794\",\n \"0.47702995\",\n \"0.47699434\",\n \"0.47696918\",\n \"0.47692567\",\n \"0.47671145\",\n \"0.47671145\",\n \"0.47666252\",\n \"0.4760194\",\n \"0.47576863\",\n \"0.47506124\",\n \"0.47275782\",\n \"0.47275782\",\n \"0.472612\",\n \"0.47218496\",\n \"0.471954\",\n \"0.47113478\",\n \"0.4706816\",\n \"0.4702629\",\n \"0.4701189\",\n \"0.46970272\",\n \"0.46968034\",\n \"0.46862486\",\n \"0.46852416\",\n \"0.4683609\",\n \"0.46781927\",\n \"0.46733356\",\n \"0.46665892\",\n \"0.46616155\",\n \"0.46608523\",\n \"0.4650697\",\n \"0.46500838\",\n \"0.46486163\",\n \"0.46486163\",\n \"0.4648399\",\n \"0.46395594\",\n \"0.4638845\",\n \"0.46360627\",\n \"0.46278203\",\n \"0.46265042\",\n \"0.46176174\",\n \"0.46160293\",\n \"0.4615276\",\n \"0.4614845\",\n \"0.46069705\",\n \"0.45988095\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62036276"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84662,"cells":{"query":{"kind":"string","value":"Mask everything up to the n_scanline scan line of the n_repetition repetition. If n_scanline is None, mask the whole repetition. Arguments"},"document":{"kind":"string","value":"def step_scanline_masking(obs, n_repetition=0, n_scanline=None):\n if n_scanline == None:\n for i in xrange(n_repetition):\n obs.pointing.masked[obs.status.Repetition == i] = True\n else:\n for i in xrange(n_repetition - 1):\n obs.pointing.masked[obs.status.Repetition == i] = True\n for j in xrange(1, n_scanline):\n obs.pointing.masked[(obs.status.Repetition == n_repetition) *\n (obs.status.ScanLineNumber == j)] = True"},"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 maskgroup(x, n):\n # create running lists\n index = []\n length = []\n count = 0\n\n # count indices and lengths of unmasked data groups\n for i in range(x.mask.size):\n if i==0:\n if not x.mask[i]:\n index += [i]\n count = 1\n if i>0:\n if not x.mask[i] and x.mask[i-1]:\n index += [i]\n count = 1\n elif not x.mask[i]:\n count += 1\n elif x.mask[i] and not x.mask[i-1]:\n length += [count]\n count = 0\n else:\n pass\n if count>0:\n length += [count]\n\n # create new mask\n new_mask = np.copy(x.mask)\n for i in range(len(index)):\n if length[i]<=n:\n new_mask[index[i]:index[i]+length[i]] = True\n\n return new_mask","def fix_generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n i = 0\r\n for _ in range(1, int(0.3 * self.width)):\r\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\r\n x1 = index_xline[i]\r\n i += 1\r\n thickness = 1\r\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\r\n\r\n return 1 - mask","def mask(n, start, end):\n columns = []\n value = 1\n for i in range(n):\n if start <= end:\n columns.append(value if (start <= i < end) else 0)\n else:\n columns.append(value if (start <= i or i < end) else 0)\n value <<= 1\n return BitColumnMatrix(columns)","def morphological_dilation(masked_image, n): #n=3\r\n\tmask = np.isnan(masked_image)\r\n\ts = ndimage.morphology.generate_binary_structure(2, 1)\r\n\textended_mask = ndimage.binary_dilation(mask, structure=s, iterations=3).astype(mask.dtype)\r\n\treturn extended_mask\r\n\t#mask = np.isnan(masked_image)\r\n\t#idx = np.flatnonzero(mask)\r\n\t#expanded_idx = idx[:,None] + np.arange(1, n)\r\n\t#np.put(mask, expanded_idx, True, 'clip')\r\n\t#return mask\r","def _generate_mask(self):\r\n mask = np.zeros((self.width, self.height), np.uint8)\r\n size = int((self.width + self.height) * 0.01)\r\n if self.width < 32 or self.height < 32:\r\n raise Exception(\"Width and Height of mask must be at least 64!\")\r\n for _ in range(randint(1,int(0.5*self.width))):\r\n x1 = randint(0, self.width-1)\r\n thickness = 1\r\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\r\n return 1 - mask","def fastKineticsCrop(self,rawArray,n):\n rowCount = rawArray.shape[0] /2\n atomStart = 0 # inclusive\n atomEnd = rowCount # exclusive\n lightStart = rowCount+self.optionsDict[\"Shift Light Picture Vertically by rows\"] #inclusive\n lightEnd = 2*rowCount+self.optionsDict[\"Shift Light Picture Vertically by rows\"] # exclusive\n skipFinal = max(0,self.optionsDict[\"Shift Light Picture Vertically by rows\"]) + self.optionsDict[\"Skip final rows\"]\n skipInitial = max(0,-self.optionsDict[\"Shift Light Picture Vertically by rows\"]) + self.optionsDict[\"Skip initial rows\"]\n pic1 = rawArray[atomStart+skipInitial:atomEnd-skipFinal] # e.g. [0:512] -> 0-511\n pic2 = rawArray[lightStart+skipInitial:lightEnd-skipFinal] # e.g. [512:1024] -> 512-1023\n return pic1, pic2","def create_all_mask(mask, num, stride):\n scale_factor = 1.0 / stride\n small_mask = cv2.resize(mask, (0, 0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC)\n small_mask = small_mask[:, :, np.newaxis]\n return np.repeat(small_mask, num, axis=2)","def Mask(self) -> int:","def mask_indices(n,mask_func,k=0):\r\n m = ones((n,n),int)\r\n a = mask_func(m,k)\r\n return where(a != 0)","def n_ary_mask(d, n, offset):\n return [(i + offset) % n == 0 for i in range(d)]","def get_mask(m, n, i):\n\n row = i // n\n col = i % n\n \n ind = np.arange(m*n)\n \n mask = np.bitwise_and(np.abs(ind % n - col) <= 1, # indicies are 1 (or less) columns away\n np.abs(ind // n - row) <= 1) # and indicies are 1 (or less) rows away\n mask = mask.astype(int)\n return mask","def setNSlices(self,n):\n assert(n> 0)\n self._c_param.lee_richards_n_slices = n","def mask_tokens(self, sequence):\n n_tokens = len(sequence)\n n_masked_tokens = int(self.masking_proportion*n_tokens/100)\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\n while len(set(indexes))!=n_masked_tokens:\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\n sequence = np.array(sequence)\n sequence[indexes] = 4\n return list(sequence)","def generate_inpaint_mask(n_samples, n_colors, spatial_width):\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\n # simple mask -- just mask out half the image\n mask[:,:,:,spatial_width/2:] = True\n return mask.ravel()","def rslices(n, allow_empty=False):\n for _ in range(5):\n yield rslice(n, allow_empty)","def rslices(n, allow_empty=False):\n for _ in range(5):\n yield rslice(n, allow_empty)","def check_pattern(knitpaint) -> List[Loop]:\n bitmap = knitpaint.get_np_bitmap_data()\n min_height = 10\n min_vertical_repetitions = math.ceil(min_height / bitmap.shape[0])\n vertical_repetitions = max(2, min_vertical_repetitions)\n tiled = np.tile(bitmap, (vertical_repetitions, 2))\n padded = np.pad(tiled, ((2, 2), (7, 7)), 'constant', constant_values=((1, 1), (1, 1)))\n from .. import KnitPaint\n return check(KnitPaint(padded))","def apply_mask(file: str, nlines: int, nsamples: int, mask_file: str):\n data = read_bin(file, nlines, nsamples)\n mask = read_bmp(mask_file)\n\n data[mask == 0] = 0\n\n outfile = \"{file}_masked\".format(file=file)\n data.tofile(outfile)\n\n return outfile","def mask_region(self, ypos, xpos, r):\r\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\r\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r ** 2 and 0 <= j<= self.shapes[0] - 1 and 0<= i <=self.shapes[1] - 1:\r\n j = int(j)\r\n i = int(i)\r\n self.masked[j, i] = 0","def mask_indices(n, mask_func, k=0):\r\n m = np.ones((n, n), int)\r\n a = mask_func(m, k)\r\n return np.where(a != 0)","def unpadding(img, n):\n img = img[n:img.shape[0]-n, n:img.shape[1]-n]\n\n return img","def zero_crossing_before(self, n):\n n_in_samples = int(n * self.samplerate)\n\n search_start = n_in_samples - self.samplerate\n if search_start < 0:\n search_start = 0\n\n frame = zero_crossing_last(\n self.range_as_mono(search_start, n_in_samples)) + search_start\n\n return frame / float(self.samplerate)","def skip(self, n):\n return self.__class__(itertools.islice(self, n, None))","def unrank_nonlex(self, n, r):\n def _unrank1(n, r, a):\n if n > 0:\n a[n - 1], a[r % n] = a[r % n], a[n - 1]\n _unrank1(n - 1, r//n, a)\n\n id_perm = range(n)\n n = int(n)\n r = r % ifac(n)\n _unrank1(n, r, id_perm)\n return _new_from_array_form(id_perm)","def _mask3d(self, n, i, window):\n\n n = np.array(n)\n i = np.array(i)\n\n w2 = (window - 1) // 2\n\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\n\n mask = np.zeros(n, dtype=np.bool)\n mask[x1:x2, y1:y2, z1:z2] = True\n\n return mask","def scan(self, mask):","def mask_incoherent(self):\n self.MaskPrefix = 'i' + self.MaskPrefix\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\n for ig in self.Set:\n igram = self.load_ma(ig)\n mskFile = ig.Path[:-3] + 'msk'\n coherence = roipy.tools.load_half(ig, 2, mskFile)\n incoherent = ma.masked_less(coherence, self.Cothresh)\n igram[incoherent.mask] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n\n print('Done')","def mask(self):\n\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\n\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\n\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\n\n cv2.floodFill(image=mask,\n mask=mask_with_border,\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\n newVal=constants.COLOR_WHITE_MONO)\n\n return mask","def image_erosion(filter_size=3, repeat=1):\n def img_op(image: np.ndarray,**kwargs):\n structure_shape = [1] * image.ndim\n structure_shape[0]=filter_size\n structure_shape[1] = filter_size\n for i in range(repeat):\n image =ndimage.morphology.grey_erosion(image,size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\n return clip(image,0,255)\n\n return img_op","def zero_crossing_after(self, n):\n n_in_samples = int(n * self.samplerate)\n search_end = n_in_samples + self.samplerate\n if search_end > self.duration:\n search_end = self.duration\n\n frame = zero_crossing_first(\n self.range_as_mono(n_in_samples, search_end)) + n_in_samples\n\n return frame / float(self.samplerate)","def _calc_missile_scan(self):\n self._scan_line = [False] * Stella.FRAME_WIDTH\n\n if self.enam & 0x02:\n for n in range(self._number):\n # Uses same stretching as 'ball'\n width = 1 << ((self.nusiz & 0x30) >> 4)\n # Uses similar position to 'player'\n for i in range(width):\n x = (i +self.resm + n*self._gap*8 - Stella.HORIZONTAL_BLANK) % Stella.FRAME_WIDTH \n self._scan_line[x] = True","def remove_polylines_in_masked_area(\n polyline_table, narr_mask_matrix, verbose=True):\n\n error_checking.assert_is_integer_numpy_array(narr_mask_matrix)\n error_checking.assert_is_geq_numpy_array(narr_mask_matrix, 0)\n error_checking.assert_is_leq_numpy_array(narr_mask_matrix, 1)\n error_checking.assert_is_boolean(verbose)\n\n num_grid_rows, num_grid_columns = nwp_model_utils.get_grid_dimensions(\n model_name=nwp_model_utils.NARR_MODEL_NAME)\n expected_dimensions = numpy.array(\n [num_grid_rows, num_grid_columns], dtype=int)\n error_checking.assert_is_numpy_array(\n narr_mask_matrix, exact_dimensions=expected_dimensions)\n\n num_fronts = len(polyline_table.index)\n indices_to_drop = []\n\n for i in range(num_fronts):\n if numpy.mod(i, 25) == 0 and verbose:\n print (\n 'Have checked {0:d} of {1:d} polylines; have removed {2:d} of '\n '{0:d} because they exist only in masked area...'\n ).format(i, num_fronts, len(indices_to_drop))\n\n skip_this_front = _is_polyline_closed(\n latitudes_deg=polyline_table[LATITUDES_COLUMN].values[i],\n longitudes_deg=polyline_table[LONGITUDES_COLUMN].values[i])\n\n if skip_this_front:\n indices_to_drop.append(i)\n continue\n\n this_binary_matrix = polyline_to_narr_grid(\n polyline_latitudes_deg=polyline_table[LATITUDES_COLUMN].values[i],\n polyline_longitudes_deg=polyline_table[LONGITUDES_COLUMN].values[i],\n dilation_distance_metres=1.)\n\n if not numpy.any(\n numpy.logical_and(\n this_binary_matrix == 1, narr_mask_matrix == 1)):\n indices_to_drop.append(i)\n\n if len(indices_to_drop) == 0:\n return polyline_table\n\n indices_to_drop = numpy.array(indices_to_drop, dtype=int)\n return polyline_table.drop(\n polyline_table.index[indices_to_drop], axis=0, inplace=False)","def mask_emissionlines(self, element_emission_lines):\n\t\t#Dictionary of corrosponding elements to their emission lines\n\t\temission_dict = {'He-II' : (3202.15, 4685.74),\n\t\t\t\t\t\t 'Ne-V' : (3345.81, 3425.81),\n\t\t\t\t\t\t 'O-II' : (3726.03, 3728.73),\n\t\t\t\t\t\t 'Ne-III': (3868.69, 3967.40),\n\t\t\t\t\t\t 'H-ζ' : 3889.05,\n\t\t\t\t\t\t 'H-ε' : 3970.07,\n\t\t\t\t\t\t 'H-δ' : 4101.73,\n\t\t\t\t\t\t 'H-γ' : 4340.46,\n\t\t\t\t\t\t 'O-III' : (4363.15, 4958.83, 5006.77),\n\t\t\t\t\t\t 'Ar-IV' : (4711.30, 4740.10),\n\t\t\t\t\t\t 'H-β' : 4861.32,\n\t\t\t\t\t\t 'N-I' : (5197.90, 5200.39),\n\t\t\t\t\t\t 'He-I' : 5875.60,\n\t\t\t\t\t\t 'O-I' : (6300.20, 6363.67),\n\t\t\t\t\t\t 'N-II' : (6547.96, 6583.34),\n\t\t\t\t\t\t 'H-α' : 6562.80,\n\t\t\t\t\t\t 'S-II' : (6716.31, 6730.68),\n\t\t\t\t\t\t 'Ar-III': 7135.67}\n\n\t\t#Create an array full of booleans equal to False, same size as the restframe_wavelength\n\t\tself.lines_mask = np.zeros_like(self.restframe_wavelength,dtype=bool)\n\n\t\t#Loop through the input of the emission lines list\n\t\tfor i in range(len(element_emission_lines)):\n\n\t\t\t#Check if the value is in the dictionary\n\t\t\tif element_emission_lines[i] in emission_dict:\n\n\t\t\t\tele_line = element_emission_lines[i]\n\t\t\t\tline = emission_dict[ele_line]\n\n\t\t\t\t#Check if it contains a tuple (some elements have more then one emission line)\n\t\t\t\tif type(line) == tuple:\n\n\t\t\t\t\t#Find the number of emission lines for this value\n\t\t\t\t\tn_lines = len(line)\n\n\t\t\t\t\t#Loop through and mask them\n\t\t\t\t\tfor n in range(n_lines):\n\n\t\t\t\t\t\tn_line = line[n]\n\n\t\t\t\t\t\t#Creates the boolean array\n\t\t\t\t\t\ttemp_lines_mask = ((self.restframe_wavelength > n_line - self.N_angstrom_masked) & (self.restframe_wavelength < n_line + self.N_angstrom_masked))\n\t\t\t\t\t\t#Adds the boolean array to the exisiting one to save it\n\t\t\t\t\t\tself.lines_mask = (temp_lines_mask | self.lines_mask)\n\t\t\t\t\t\t\n\t\t\t\telse:\n\t\t\t\t\ttemp_lines_mask = ((self.restframe_wavelength > line - self.N_angstrom_masked) & (self.restframe_wavelength < line + self.N_angstrom_masked))\n\t\t\t\t\tself.lines_mask = (temp_lines_mask | self.lines_mask)\n\n\t\t\telse:\n\t\t\t\tprint(element_emission_lines[i])\n\t\t\t\traise KeyError","def mask_image(image_path, export_path, size, layover=0.5, input_size=1000):\n\n # Loads the image and make sure that all images have the same size\n image = cv2.imread(image_path)\n image = cv2.resize(image, (input_size, input_size))\n\n # Calculating a valid stride size\n stride_size = (1 - layover) * size\n sliding_space = image.shape[0] - size\n possible_factors = factors(sliding_space)\n stride_size = min(possible_factors, key=lambda factor_number: abs(factor_number - stride_size))\n\n iterations = int(sliding_space / stride_size)\n\n name = image_path.split('/')[-1].split('.')[0]\n img_format = image_path.split('/')[-1].split('.')[-1]\n\n for i in range(iterations):\n y = i * stride_size\n for j in range(iterations):\n x = j * stride_size\n crop_img = image[y:y + size, x:x + size]\n path = \"{}{}-{}_{}.{}\".format(export_path, name, i, j, img_format)\n cv2.imwrite(path, crop_img)","def block_repeat(self, board, n):\r\n this_block = []\r\n row_start = 3 * (n // 4)\r\n col_start = 3 * (n % 4)\r\n for r in range(3):\r\n this_row = board[(12 * (row_start + r) + col_start):(12 * (row_start + r) + col_start + 3)]\r\n for x in this_row:\r\n this_block.append(x)\r\n # println(n)\r\n # println(this_block)\r\n for letter in 'abcdef':\r\n if this_block.count(letter) > 1:\r\n # println(this_block)\r\n return True\r\n return False","def repeat(self, fn, *args, **kwargs):\n return repeat_n_times(self.n, fn, *args, **kwargs)","def _source_mask(self, ilens):\n x_masks = make_non_pad_mask(ilens)\n return x_masks.unsqueeze(-2)","def infill_small_regions(I):\n n_tiles = 4 # ntiles horizontally.\n assert I.shape[0] == I.shape[1]\n tile_size = I.shape[0] // (n_tiles - 1)\n tile_delta = tile_size // 2\n\n k = 0\n I_stack = np.ones(I.shape + (2, 2)) * np.nan\n for j in range(n_tiles * 2 - 1):\n for i in range(n_tiles * 2 - 1):\n dy = slice(tile_delta * j, tile_delta * (j + 2))\n dx = slice(tile_delta * i, tile_delta * (i + 2))\n S = I[dy, dx]\n M = ndimage.binary_dilation(np.isnan(S), iterations=2)\n image_inpainted = inpaint.inpaint_biharmonic(S, M, multichannel=False)\n I_stack[dy, dx, j % 2, i % 2] = image_inpainted\n k += 1\n return np.nanmean(np.nanmean(I_stack, axis=2), axis=2)","def make_pattern(pixels, origin, pattern_size, ndots):\n\tw,h = pattern_size\n\tow,oh = origin\n\tcoordinates = itertools.product(range(h), range(w))\n\twith_offset = [(c+ow, r+oh) for r,c in coordinates]\n\t# take only n dots\n\twith_offset = with_offset[:ndots]\n\tfor c,r in with_offset:\n\t\tpixels[c, r] = 0","def maskbits(x: int, n:int) -> int:\n if n >= 0:\n return x & ((1 << n) - 1)\n else:\n return x & (-1 << -n)","def filter_input_fasta(input_file, output_file, n=60):\n all_lines = get_n_lines(input_file)\n with open(input_file, 'r') as i, \\\n open(output_file, 'w') as out:\n index = 0\n for sequence in i:\n percent = int(index / all_lines * 100)\n sys.stdout.write(f'\\r{index}/{all_lines} - {percent}% done!')\n sequence = sequence.strip()\n if sequence.startswith(\">\"):\n out.write(sequence + '\\n')\n if not sequence.startswith(\">\"):\n split_sequence = [sequence[i:i + n] for i in range(0, len(sequence), n)]\n out.write('\\n'.join(split_sequence) + '\\n')\n index += 1\n sys.stdout.write(f'\\r{all_lines}/{all_lines} - 100% done!')","def infill_large_regions(I, npixels=10000, precision=1000):\n assert I.shape[0] == I.shape[1]\n xgrid, ygrid = np.meshgrid(np.arange(I.shape[1]),\n np.arange(I.shape[0]))\n\n I_ = I.copy()\n\n # Exclude two pixels on the border during infilling.\n bad_regions, n_bad_regions = ndimage.label(\n ndimage.binary_dilation(np.isnan(I), iterations=2))\n\n # Use 5 pixel regions surrounding each hole.\n surround = ndimage.grey_dilation(bad_regions, size=5)\n counts, _ = np.histogram(bad_regions, np.arange(n_bad_regions + 1) - .5)\n\n for i in range(1, n_bad_regions):\n if counts[i] > npixels:\n # This is a big region, infill using the GPR method.\n surround_data = (surround == i) & (bad_regions == 0)\n xgrid_s, ygrid_s = xgrid[surround_data], ygrid[surround_data]\n\n # Take N_points points at random, fit a Gaussian process.\n subs = np.random.permutation(np.arange(len(xgrid_s)))[:precision]\n gp_kernel = Matern(length_scale=1,\n length_scale_bounds=(.01, 100), nu=1.5)\n gpr = GaussianProcessRegressor(kernel=gp_kernel, normalize_y=True)\n\n X = np.concatenate((xgrid_s.reshape(-1, 1),\n ygrid_s.reshape(-1, 1)), axis=1)\n gpr.fit(X[subs, :], I[surround_data][subs])\n xgrid_s, ygrid_s = xgrid[bad_regions == i], ygrid[bad_regions == i]\n X_ = np.concatenate((xgrid_s.reshape(-1, 1),\n ygrid_s.reshape(-1, 1)), axis=1)\n y_ = gpr.predict(X_)\n I_[bad_regions == i] = y_\n return I_","def tril_indices(n,k=0):\r\n return mask_indices(n,tril,k)","def drawN(self,n):\n c = self.cards[:n]\n self.cards = self.cards[n:]\n self.discards += c\n return(c)","def mask_image(image):\n pass","def gen_mask(components):\n masks_segments = components[7]\n hh = components[1]\n ww = components[2]\n\n if masks_segments:\n mask_miss = np.ones((hh, ww), dtype=np.uint8)\n for seg in masks_segments:\n bin_mask = maskUtils.decode(seg)\n bin_mask = np.logical_not(bin_mask)\n mask_miss = np.bitwise_and(mask_miss, bin_mask)\n\n components[11] = mask_miss\n\n return components","def __set_mask_regions(self):\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\n [299,719], [100, 550], [640, 425]]]))","def generate_effective_mask(self, mask_size: tuple, polygons_ignore):\n mask = np.ones(mask_size, dtype=np.uint8)\n\n for poly in polygons_ignore:\n instance = poly.astype(np.int32).reshape(1, -1, 2)\n cv2.fillPoly(mask, instance, 0)\n\n return mask","def lookahead(n, iterable):\n for value in islice(copy.copy(iterable), n, None):\n return value\n raise IndexError(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)","def mask_particle_rect(image,bounded_rectangle, color):\r\n\r\n \r\n masked_image = cv2.rectangle(image, (int(bounded_rectangle[0])-1, int(bounded_rectangle[1])-1),\r\n (int(bounded_rectangle[0]+bounded_rectangle[2])+1, \r\n int(bounded_rectangle[1]+bounded_rectangle[3])+1),\r\n color, -1)\r\n\r\n return masked_image","def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\n all_ones = 2 ** n_bits - 1\n cancel_bits = 2 ** n - 1\n return all_ones - cancel_bits","def output_n(self,\n n: int,\n ) -> abjad.Selection:\n if not isinstance(n, int):\n raise TypeError(\"first positional argument must be 'int'\")\n if n < 1:\n raise ValueError(\"first positional argument must be a positive \"\n \"'int'\")\n dummy_container = abjad.Container()\n for _ in range(n):\n dummy_container.append(self.__call__())\n mutate.remove_repeated_time_signatures(dummy_container[:])\n mutate.remove_repeated_dynamics(dummy_container[:])\n output = dummy_container[:]\n dummy_container[:] = []\n return output","def caipi(r,ry,shifts):\n rz = int(r/ry)\n patterns = np.zeros((len(shifts),r,r))\n l = 0\n for i, shift in enumerate(shifts):\n cell = np.zeros((r,r))\n for row in range(rz):\n if (shift*row+rz)>= r:\n l = (shift*row%r+rz)%rz\n else:\n l = shift*row\n cell[row*ry,l::rz]=1\n patterns[i] = np.copy(cell)\n return patterns","def _fillcache(self, n: int | None) -> None:\n if not n:\n n = 1\n try:\n while len(self._cache) < n:\n self._cache.append(self.modifier(next(self._iterable))) # type: ignore\n except StopIteration:\n while len(self._cache) < n:\n self._cache.append(self.sentinel)","def calcmask(self, *args, **kwargs):\n return _image.image_calcmask(self, *args, **kwargs)","def create_masks(image_folder: str, annotation_path: str, outpath: str):\n\n train_reader = ReaderAnnotation(annotation_path)\n\n all_images = os.listdir(image_folder)\n annotated_images = train_reader.annotation.keys()\n\n creator = MaskCreator()\n\n for key in annotated_images:\n file_extension = \".JPG\"\n if not os.path.isfile(\n os.path.join(\n image_folder,\n key.split(\".\")[0] + file_extension,\n )\n ):\n file_extension = file_extension.lower()\n\n image_name = os.path.join(\n image_folder,\n key.split(\".\")[0] + file_extension,\n )\n print(image_name)\n\n out_image_path = os.path.join(outpath, os.path.split(image_name)[-1])\n assert os.path.exists(out_image_path), \"Out image path doesn't exist\"\n\n image = plt.imread(image_name)\n h, w, c = image.shape\n\n regions = train_reader.get(key)[\"regions\"]\n # less than minimal distance\n radius = int(train_reader.get_radius_min(regions=regions) * 0.9)\n\n masks = []\n for _, center in regions.items():\n masks.append(\n creator.create_circular_mask(\n h=h,\n w=w,\n center=(\n int(center[\"shape_attributes\"][\"cx\"]),\n int(center[\"shape_attributes\"][\"cy\"]),\n ),\n radius=radius,\n )\n )\n\n if len(masks) > 50:\n masks = [creator._unite_masks(masks)]\n\n if masks:\n creator.visualize(\n image=image,\n masks=masks,\n filename=out_image_path,\n use_image=False,\n )\n else:\n creator._create_empty_mask(image=image, filename=out_image_path)\n\n print(\"Empty images:\")\n for empty_image in list(set(all_images) - set(annotated_images)):\n if os.path.exists(out_image_path):\n continue\n empty_image = os.path.join(image_folder, empty_image)\n print(empty_image)\n image = plt.imread(empty_image)\n creator._create_empty_mask(\n image=image,\n filename=os.path.join(\n outpath,\n os.path.split(empty_image)[-1],\n ),\n )","def remove_repeats(self,tri,n_c):\n tri = order_tris(np.mod(tri,n_c))\n sorted_tri = tri[np.lexsort(tri.T), :]\n row_mask = np.append([True], np.any(np.diff(sorted_tri, axis=0), 1))\n return sorted_tri[row_mask]","def mask(self):\n mask = np.zeros((self.height, self.width))\n pts = [\n np.array(anno).reshape(-1, 2).round().astype(int)\n for anno in self.segmentation\n ]\n mask = cv2.fillPoly(mask, pts, 1)\n return mask","def lookahead(self, n=1):\n while len(self._remaining) < n:\n self._remaining.append(next(self))\n return [self._remaining[i] for i in range(n)]","def _islice_batched(it: Iterator[np.ndarray], n: int) -> Iterator[np.ndarray]:\n while n > 0:\n arr: np.ndarray = next(it)\n k = arr.shape[0]\n yield arr[:n, :]\n n -= k","def colormap_masked(ncolors=256, knee_index=None, cmap='inferno', alpha=0.3):\n cm = plt.cm.get_cmap(cmap)(np.linspace(0, 1, ncolors))\n if knee_index is None:\n # Then map to pvals, as -log(p) between 0 and 3.5, and threshold at 0.05\n knee_index = np.argmin(abs(np.linspace(0., 3.5, ncolors)+np.log10(0.05)))\n \n cm[:knee_index, :] = np.c_[cm[:knee_index, 0], cm[:knee_index, 1], cm[:knee_index, 2], alpha*np.ones((len(cm[:knee_index, 1])))]\n return LinearSegmentedColormap.from_list('my_colormap', cm)","def fillNDIGap(self, knn):\n nirrho = self.readImage(self.nirfile, self.rhoband).astype(np.float_)\n nirnhits = self.readImage(self.nirfile, self.nhitsband).astype(np.int)\n nirmask = self.readImage(self.nirfile, self.maskband).astype(np.bool_)\n \n swirrho = self.readImage(self.swirfile, self.rhoband).astype(np.float_)\n swirnhits = self.readImage(self.swirfile, self.nhitsband).astype(np.int)\n swirmask = self.readImage(self.swirfile, self.maskband).astype(np.bool_)\n\n hitmask = np.logical_and(np.greater(nirnhits, 0), np.greater(swirnhits, 0))\n if not hitmask.any():\n # no valid hit at all!\n print \"Error, no shot has returns! Check your data\"\n sys.exit()\n xhit, yhit = np.where(hitmask)\n nirrhohit = nirrho[hitmask]/nirnhits[hitmask]\n swirrhohit = swirrho[hitmask]/swirnhits[hitmask]\n\n ndi = np.zeros_like(nirrho)\n mask = np.zeros_like(nirrho, dtype=int) + 3\n tmpflag = np.logical_and(np.invert(nirmask), np.invert(swirmask))\n mask[tmpflag] = 0\n \n ndihit = (nirrhohit - swirrhohit) / (nirrhohit + swirrhohit)\n ndi[hitmask] = ndihit\n mask[hitmask] = 1\n \n nirgapmask = np.logical_and(np.equal(nirnhits, 0), np.greater(swirnhits, 0))\n swirgapmask = np.logical_and(np.greater(nirnhits, 0), np.equal(swirnhits, 0))\n\n if (not nirgapmask.any()) and (not swirgapmask.any()):\n # no gap\n print \"No fillable gap.\"\n return ndi, mask\n\n gapmask = np.logical_or(nirgapmask, swirgapmask)\n xgap, ygap = np.where(gapmask)\n\n X = np.hstack((xhit.reshape(len(xhit), 1), yhit.reshape(len(yhit), 1))).astype(np.float32)\n T = np.hstack((xgap.reshape(len(xgap), 1), ygap.reshape(len(ygap), 1))).astype(np.float32)\n ndigap = self.fillGap(X, ndihit, T, knn)\n ndi[gapmask] = ndigap\n mask[gapmask] = 2\n\n self.ndi = ndi\n self.mask = mask\n \n return ndi, mask","def crop(self, N):\n self.data = self.data[:,:N]","def drizzle_mask(source, dest, output):\n if os.path.exists(output):\n os.system('rm %s' % output)\n coord_src = flatten_pixcoord(source)\n print \"Transforming coordinates...\"\n coord_dest = transform_pixcoord(source, dest)\n hdr_dest = pyfits.getheader(dest)\n mask_in = pyfits.getdata(source)\n mask_out = np.zeros((hdr_dest['naxis1'], hdr_dest['naxis2']))\n # Now this might take a lot of time... is there a more clever way?\n print \"Start looping all the pixels, might take a while...\"\n for i in range(coord_src.shape[0]):\n x0, y0 = coord_src[i]\n if mask_in[y0-1,x0-1] > 0:\n x1, y1 = coord_dest[i]\n mask_out[y1-1,x1-1] = 1\n # write output\n pyfits.append(output, data=mask_out, header=hdr_dest)","def sharpened(image, n):\n #store image width and height\n image_width = image['width']\n image_height = image['height']\n #intialize new image and stores blurred image\n new_image = {'height': image['height'], 'width': image['width'], 'pixels': len(image['pixels'])*[0]}\n blurred_image = blurred(image, n)\n \n #loop through every coordinate\n for x in range(image_width):\n for y in range(image_height):\n #perform calculation and set pixel\n a = 2*get_pixel(image, x, y) - get_pixel(blurred_image, x, y)\n set_pixel(new_image, x, y, a)\n return round_and_clip_image(new_image)","def image_dilation(filter_size=3, repeat=1):\n def img_op(image: np.ndarray,**kwargs):\n structure_shape = [1] * image.ndim\n structure_shape[0]=filter_size\n structure_shape[1] = filter_size\n for i in range(repeat):\n image = ndimage.morphology.grey_dilation(image, size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\n\n return clip(image,0,255)\n\n return img_op","def removedigits(self,n):\r\n if n == 1:\r\n for i in range(30):\r\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\r\n self.print(self.puzzle)\r\n self.play()\r\n if n == 2:\r\n for i in range(40):\r\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\r\n self.print(self.puzzle)\r\n self.play()\r\n if n == 3:\r\n for i in range(50):\r\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\r\n self.print(self.puzzle)\r\n self.play()","def padding(img, n):\n img = np.pad(img, [(n, n), (n, n)], mode='constant', constant_values=0)\n\n return img","def rslice(n, allow_empty=False):\n minlen = 0 if allow_empty or n == 0 else 1\n slicelen = randrange(minlen, n + 1)\n return randslice_from_slicelen(slicelen, n)","def simulate_source_mask(binary, n_holes, hole_radius_arcmin):\n\n mask = binary.copy()\n if binary.pixel == \"HEALPIX\":\n idx = np.where(binary.data == 1)\n for i in range(n_holes):\n random_index1 = np.random.choice(idx[0])\n vec = hp.pixelfunc.pix2vec(binary.nside, random_index1)\n disc = hp.query_disc(binary.nside, vec, hole_radius_arcmin / (60.0 * 180) * np.pi)\n mask.data[disc] = 0\n\n if binary.pixel == \"CAR\":\n random_index1 = np.random.randint(0, binary.data.shape[0], size=n_holes)\n random_index2 = np.random.randint(0, binary.data.shape[1], size=n_holes)\n mask.data[random_index1, random_index2] = 0\n dist = enmap.distance_transform(mask.data)\n mask.data[dist * 60 * 180 / np.pi < hole_radius_arcmin] = 0\n\n return mask","def test_RobustMNINormalizationRPT_masked(self):\n ants_rpt = RobustMNINormalizationRPT(\n generate_report=True, moving_image=self.moving,\n reference_mask=self.reference_mask, flavor='testing')\n _smoke_test_report(ants_rpt, 'testRobustMNINormalizationRPT_masked.svg')","def __setitem__(self, n, bit):\n self.num ^= (np.uint64(-bit) ^ self.num) & (UINT64_ONE << np.uint64(n))","def mask(n):\n if n >= 0:\n return 2**n - 1\n else:\n return 0","def mask(n):\n if n >= 0:\n return 2**n - 1\n else:\n return 0","def grouper(iterable: Iterable, n: int = 100, fillvalue: Any = None) -> Any:\r\n args = [iter(iterable)] * n\r\n return zip_discard_compr(*args)","def rslice(n, allow_empty=False):\n minlen = 0 if allow_empty or n == 0 else 1\n slicelen = randrange(minlen, n+1)\n return randslice_from_slicelen(slicelen, n)","def tril_indices(n, k=0):\r\n return mask_indices(n, np.tril, k)","def rshift(val: int, n: int) -> int:\n return (val % 0x100000000) >> n","def repeatfunc(func, n, *args):\n return starmap(func, repeat(args, n))","def mask_region_ends(self, n_days=20):\n for rg in self.Rs:\n i = self.Rs.index(rg)\n self.Active.mask[i, -n_days:] = True\n self.Confirmed.mask[i, -n_days:] = True\n self.Deaths.mask[i, -n_days:] = True\n self.NewDeaths.mask[i, -n_days:] = True\n self.NewCases.mask[i, -n_days:] = True","def mask_step(self, step):\n m = step * self.mask_full()\n return m.astype(np.int32)","def northpole_unmasked(res='4x5', mask2D=False):\n # Create a dummy array of zeros\n m = np.zeros(get_dims4res(res))\n # adjust for resolution at grid start points at 62\n if res == '4x5':\n lats = np.arange(62, 90, 1) # define N pole as > 60N\n else:\n lats = np.arange(60, 90, 1) # define N pole as > 60N\n lats = [get_gc_lat(i, res=res) for i in lats]\n for i in lats:\n m[:, i, :] = 1\n\n # Create a np.ma mask\n m = np.ma.masked_not_equal(m, 1)\n\n # Return 2D or 3D?\n if mask2D:\n return m[..., 0].mask\n else:\n return m.mask","def __init__(self, iterable_input, n=1, name='re-repeat', verbose=True):\n super().__init__(iterable_input=iterable_input, name=name, verbose=verbose)\n self.n = n","def Repeater(arr,n):\n new_arr = np.zeros((arr.shape[0]*n,arr.shape[1]),dtype=object)\n for i in range(0,arr.shape[0]):\n new_row = np.tile(arr[i,:],(n,1))\n new_arr[i*n:(i+1)*n,:] = new_row\n return new_arr","def keep_ints(n):\n\tdef f(cond):\n\t\ti=1\n\t\twhile i<=n:\n\t\t\tif cond(i)==True:\n\t\t\t\tprint(i)\n\t\t\ti += 1\n\treturn f","def _clear_last_lines(n=1):\n for _ in range(n):\n sys.stdout.write(CURSOR_UP_ONE)\n sys.stdout.write(ERASE_LINE)","def _repeat_pattern(pattern, width):\n assert width % pattern.width == 0\n return operation.repeat(pattern, width // pattern.width)","def get_test_pattern(img_size=(2048, 2048)):\n ny, nx = img_size\n # mask = np.zeros((ny, nx))\n\n # patterns with variable spacing\n periods = range(2, 20, 2)\n # vcounter = 0\n for ii, p in enumerate(periods):\n cell = np.zeros((p, nx))\n on_pix = int(np.ceil(p / 2))\n cell[:on_pix, :] = 1\n cell = np.tile(cell, [4, 1])\n\n if ii == 0:\n mask = cell\n else:\n mask = np.concatenate((mask, cell), axis=0)\n\n mask = mask[:, :mask.shape[0]]\n\n mask_block = np.concatenate((mask, np.rot90(mask)), axis=1)\n mask_block2 = np.concatenate((np.rot90(mask), mask), axis=1)\n\n mask_superblock = np.concatenate((mask_block, mask_block2))\n\n ny_reps = int(np.ceil(ny / mask_superblock.shape[0]))\n nx_reps = int(np.ceil(nx / mask_superblock.shape[1]))\n mask = np.tile(mask_superblock, [ny_reps, nx_reps])\n mask = mask[0:ny, 0:nx]\n\n return mask","def cartesian_mask(self, shape, centred=False, uniform=True):\n\t\tR = self.R\n\t\tsample_n = self.sample_n\n\t\tif uniform:\n\t\t\tN, Nx, Ny = int(np.prod(shape[:-2])), shape[-2], shape[-1]\n\t\t\tn_lines = int(Nx / R)\n\t\t\t\n\t\t\tmask = np.zeros((N, Nx, Ny))\n\t\t\tfor i in range(N):\n\t\t\t\tidx = np.arange(0,Nx,R)\n\t\t\t\tmask[i, idx, :] = 1\n\t\t\t\t\n\t\t\tif sample_n:\n\t\t\t\tmask[:, Nx//2-sample_n//2:(Nx//2+sample_n//2),:] = 1\n \n\t\telse:\n\t\t\tN, Nx, Ny = int(np.prod(shape[:-2])), shape[-2], shape[-1]\n\t\t\tpdf_x = self.normal_pdf(Nx, 0.5/(Nx/10.)**2)\n\t\t\tlmda = Nx/(2.*R)\n\t\t\tn_lines = int(Nx / R)\n \n # add uniform distribution\n\t\t\tpdf_x += lmda * 1./Nx\n \n\t\t\tif sample_n:\n\t\t\t\tpdf_x[Nx//2-sample_n//2:Nx//2+sample_n//2] = 0\n\t\t\t\tpdf_x /= np.sum(pdf_x)\n\t\t\t\tn_lines -= sample_n\n \n\t\t\tmask = np.zeros((N, Nx))\n\t\t\tfor i in range(N):\n\t\t\t\tidx = np.random.choice(Nx, n_lines, False, pdf_x)\n\t\t\t\tmask[i, idx] = 1\n \n\t\t\tif sample_n:\n\t\t\t\tmask[:, Nx//2-sample_n//2:Nx//2+sample_n//2] = 1\n \n\t\t\tsize = mask.itemsize\n\t\t\tmask = as_strided(mask, (N, Nx, Ny), (size * Nx, size, 0))\n \n\t\t\tmask = mask.reshape(shape)\n \n\t\tif not centred:\n\t\t\tmask = np.fft.ifftshift(mask, axes=(-1, -2))\n \n\t\treturn mask","def regenerate_masks(sensor):\n N = len(sensor.data[\"counter\"])\n mask_moving = np.zeros(N, dtype=bool)\n\n for I in sensor.data[\"interval_steps\"]:\n mask_moving[I[0]:I[1]] = True\n\n mask_resting = np.logical_not(mask_moving)\n\n sensor.data[\"mask_a_resting\"] = mask_resting\n sensor.data[\"mask_a_moving\"] = mask_moving","def mask_border(self, left=3, right=3, top=3, bottom=3):\n self.MaskPrefix = 'b' + self.MaskPrefix #prepend 'b' for border\n print('Masking edge pixels: left={0}, right={1}, top={2}, bottom={3}'.format(left,right,top,bottom))\n for ig in self.Set:\n igram = self.load_ma(ig)\n igram[:top,:] = ma.masked\n igram[-bottom:,:] = ma.masked\n igram[:,:left] = ma.masked\n igram[:,-right:] = ma.masked\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\n print(mskFile)\n print('mask_border() complete: {0} interferograms'.format(self.Set.Nig))","def chop_rle(source, n):\n\n result = ''\n for v in source:\n # Count the minimum number of chunks we need to represent v.\n numChunks = (count_bits(v) + n - 1) / n\n\n # We write out a number of zeroes to indicate this.\n zeroCount = numChunks - 1\n for z in range(zeroCount):\n yield 0\n\n mask = (1 << n) - 1\n for x in range(numChunks):\n b = (v >> ((numChunks - x - 1) * n)) & mask\n assert b != 0 or x != 0\n yield b","def crop_image(filename, n):\n image = SimpleImage(filename)\n width = image.width\n new_width = width - (2 * n)\n height = image.height\n new_height = height - (2 * n)\n image_crop_width = SimpleImage.blank(new_width, height)\n for y in range(height):\n for x in range(new_width):\n pixel = image.get_pixel((x + n), y)\n image_crop_width.set_pixel(x, y, pixel)\n image_crop_width.show()\n\n image_crop_height = SimpleImage.blank(width, new_height)\n for y in range(new_height):\n for x in range(width):\n pixel = image.get_pixel(x, y + n)\n image_crop_height.set_pixel(x, y, pixel)\n image_crop_height.show()\n\n image_crop_width_height = SimpleImage.blank(new_width, new_height)\n for y in range(new_height):\n for x in range(new_width):\n pixel = image.get_pixel(x + n, y + n)\n image_crop_width_height.set_pixel(x, y, pixel)\n image_crop_width_height.show()","def static_mask(self, frames):\r\n c, t, h, w = frames.shape\r\n rand_t = random.randint(0, t-1)\r\n mask_size_ratio = random.uniform(self.mask_size_ratio[0], self.mask_size_ratio[1])\r\n mask_size_x, mask_size_y = [int(w*mask_size_ratio), int(h*mask_size_ratio)]\r\n start_x = random.randint(0, w-mask_size_x)\r\n start_y = random.randint(0, h-mask_size_y)\r\n frames_out = frames[:, rand_t].unsqueeze(1).expand(-1, t, -1, -1).clone()\r\n frames_out[:, :, start_y:start_y+mask_size_y, start_x:start_x+mask_size_x] = frames[\r\n :, :, start_y:start_y+mask_size_y, start_x:start_x+mask_size_x\r\n ]\r\n return frames_out","def regex_grid(n):\n cx = 2 ** (n - 1)\n cy = 2 ** (n - 1)\n grid = [[grid_numbering(n, i , j, cx, cy) for i in range(2 ** n)] for j in range(2 ** n)]\n \n return grid","def one_mask(self):\n accum = 0\n for i in range(self.data.itemsize):\n accum += (0xAA << (i << 3))\n return accum","def check_modulus(n):\n # type: (int) -> List[RE]\n return [check_composite(n), check_modulus_size(n)]","def _pattern01(width):\n zeroes = core.Constant(0, width)\n return operation.Concat(zeroes, ~zeroes)","def square_mask(ys_in_pad, ignore_id):\n ys_mask = (ys_in_pad != ignore_id).unsqueeze(-2)\n ymax = ys_mask.size(-1)\n ys_mask_tmp = ys_mask.transpose(1, 2).repeat(1, 1, ymax)\n ys_mask = ys_mask.repeat(1, ymax, 1) & ys_mask_tmp\n\n return ys_mask"],"string":"[\n \"def maskgroup(x, n):\\n # create running lists\\n index = []\\n length = []\\n count = 0\\n\\n # count indices and lengths of unmasked data groups\\n for i in range(x.mask.size):\\n if i==0:\\n if not x.mask[i]:\\n index += [i]\\n count = 1\\n if i>0:\\n if not x.mask[i] and x.mask[i-1]:\\n index += [i]\\n count = 1\\n elif not x.mask[i]:\\n count += 1\\n elif x.mask[i] and not x.mask[i-1]:\\n length += [count]\\n count = 0\\n else:\\n pass\\n if count>0:\\n length += [count]\\n\\n # create new mask\\n new_mask = np.copy(x.mask)\\n for i in range(len(index)):\\n if length[i]<=n:\\n new_mask[index[i]:index[i]+length[i]] = True\\n\\n return new_mask\",\n \"def fix_generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n i = 0\\r\\n for _ in range(1, int(0.3 * self.width)):\\r\\n index_xline = random.sample(range(0, self.width), int(0.5 * self.width))\\r\\n x1 = index_xline[i]\\r\\n i += 1\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1), (self.height - 1, x1), 1, thickness)\\r\\n\\r\\n return 1 - mask\",\n \"def mask(n, start, end):\\n columns = []\\n value = 1\\n for i in range(n):\\n if start <= end:\\n columns.append(value if (start <= i < end) else 0)\\n else:\\n columns.append(value if (start <= i or i < end) else 0)\\n value <<= 1\\n return BitColumnMatrix(columns)\",\n \"def morphological_dilation(masked_image, n): #n=3\\r\\n\\tmask = np.isnan(masked_image)\\r\\n\\ts = ndimage.morphology.generate_binary_structure(2, 1)\\r\\n\\textended_mask = ndimage.binary_dilation(mask, structure=s, iterations=3).astype(mask.dtype)\\r\\n\\treturn extended_mask\\r\\n\\t#mask = np.isnan(masked_image)\\r\\n\\t#idx = np.flatnonzero(mask)\\r\\n\\t#expanded_idx = idx[:,None] + np.arange(1, n)\\r\\n\\t#np.put(mask, expanded_idx, True, 'clip')\\r\\n\\t#return mask\\r\",\n \"def _generate_mask(self):\\r\\n mask = np.zeros((self.width, self.height), np.uint8)\\r\\n size = int((self.width + self.height) * 0.01)\\r\\n if self.width < 32 or self.height < 32:\\r\\n raise Exception(\\\"Width and Height of mask must be at least 64!\\\")\\r\\n for _ in range(randint(1,int(0.5*self.width))):\\r\\n x1 = randint(0, self.width-1)\\r\\n thickness = 1\\r\\n cv2.line(mask, (0, x1),(self.height-1, x1), 1, thickness)\\r\\n return 1 - mask\",\n \"def fastKineticsCrop(self,rawArray,n):\\n rowCount = rawArray.shape[0] /2\\n atomStart = 0 # inclusive\\n atomEnd = rowCount # exclusive\\n lightStart = rowCount+self.optionsDict[\\\"Shift Light Picture Vertically by rows\\\"] #inclusive\\n lightEnd = 2*rowCount+self.optionsDict[\\\"Shift Light Picture Vertically by rows\\\"] # exclusive\\n skipFinal = max(0,self.optionsDict[\\\"Shift Light Picture Vertically by rows\\\"]) + self.optionsDict[\\\"Skip final rows\\\"]\\n skipInitial = max(0,-self.optionsDict[\\\"Shift Light Picture Vertically by rows\\\"]) + self.optionsDict[\\\"Skip initial rows\\\"]\\n pic1 = rawArray[atomStart+skipInitial:atomEnd-skipFinal] # e.g. [0:512] -> 0-511\\n pic2 = rawArray[lightStart+skipInitial:lightEnd-skipFinal] # e.g. [512:1024] -> 512-1023\\n return pic1, pic2\",\n \"def create_all_mask(mask, num, stride):\\n scale_factor = 1.0 / stride\\n small_mask = cv2.resize(mask, (0, 0), fx=scale_factor, fy=scale_factor, interpolation=cv2.INTER_CUBIC)\\n small_mask = small_mask[:, :, np.newaxis]\\n return np.repeat(small_mask, num, axis=2)\",\n \"def Mask(self) -> int:\",\n \"def mask_indices(n,mask_func,k=0):\\r\\n m = ones((n,n),int)\\r\\n a = mask_func(m,k)\\r\\n return where(a != 0)\",\n \"def n_ary_mask(d, n, offset):\\n return [(i + offset) % n == 0 for i in range(d)]\",\n \"def get_mask(m, n, i):\\n\\n row = i // n\\n col = i % n\\n \\n ind = np.arange(m*n)\\n \\n mask = np.bitwise_and(np.abs(ind % n - col) <= 1, # indicies are 1 (or less) columns away\\n np.abs(ind // n - row) <= 1) # and indicies are 1 (or less) rows away\\n mask = mask.astype(int)\\n return mask\",\n \"def setNSlices(self,n):\\n assert(n> 0)\\n self._c_param.lee_richards_n_slices = n\",\n \"def mask_tokens(self, sequence):\\n n_tokens = len(sequence)\\n n_masked_tokens = int(self.masking_proportion*n_tokens/100)\\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\\n while len(set(indexes))!=n_masked_tokens:\\n indexes = [random.randint(0, n_tokens-1) for i in range(n_masked_tokens)]\\n sequence = np.array(sequence)\\n sequence[indexes] = 4\\n return list(sequence)\",\n \"def generate_inpaint_mask(n_samples, n_colors, spatial_width):\\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\\n # simple mask -- just mask out half the image\\n mask[:,:,:,spatial_width/2:] = True\\n return mask.ravel()\",\n \"def rslices(n, allow_empty=False):\\n for _ in range(5):\\n yield rslice(n, allow_empty)\",\n \"def rslices(n, allow_empty=False):\\n for _ in range(5):\\n yield rslice(n, allow_empty)\",\n \"def check_pattern(knitpaint) -> List[Loop]:\\n bitmap = knitpaint.get_np_bitmap_data()\\n min_height = 10\\n min_vertical_repetitions = math.ceil(min_height / bitmap.shape[0])\\n vertical_repetitions = max(2, min_vertical_repetitions)\\n tiled = np.tile(bitmap, (vertical_repetitions, 2))\\n padded = np.pad(tiled, ((2, 2), (7, 7)), 'constant', constant_values=((1, 1), (1, 1)))\\n from .. import KnitPaint\\n return check(KnitPaint(padded))\",\n \"def apply_mask(file: str, nlines: int, nsamples: int, mask_file: str):\\n data = read_bin(file, nlines, nsamples)\\n mask = read_bmp(mask_file)\\n\\n data[mask == 0] = 0\\n\\n outfile = \\\"{file}_masked\\\".format(file=file)\\n data.tofile(outfile)\\n\\n return outfile\",\n \"def mask_region(self, ypos, xpos, r):\\r\\n for j, i in product(np.arange(ypos - r, ypos + r + 1), np.arange(xpos - r, xpos + 1 + r)): # Create square\\r\\n if (j - ypos) ** 2 + (i - xpos) ** 2 <= r ** 2 and 0 <= j<= self.shapes[0] - 1 and 0<= i <=self.shapes[1] - 1:\\r\\n j = int(j)\\r\\n i = int(i)\\r\\n self.masked[j, i] = 0\",\n \"def mask_indices(n, mask_func, k=0):\\r\\n m = np.ones((n, n), int)\\r\\n a = mask_func(m, k)\\r\\n return np.where(a != 0)\",\n \"def unpadding(img, n):\\n img = img[n:img.shape[0]-n, n:img.shape[1]-n]\\n\\n return img\",\n \"def zero_crossing_before(self, n):\\n n_in_samples = int(n * self.samplerate)\\n\\n search_start = n_in_samples - self.samplerate\\n if search_start < 0:\\n search_start = 0\\n\\n frame = zero_crossing_last(\\n self.range_as_mono(search_start, n_in_samples)) + search_start\\n\\n return frame / float(self.samplerate)\",\n \"def skip(self, n):\\n return self.__class__(itertools.islice(self, n, None))\",\n \"def unrank_nonlex(self, n, r):\\n def _unrank1(n, r, a):\\n if n > 0:\\n a[n - 1], a[r % n] = a[r % n], a[n - 1]\\n _unrank1(n - 1, r//n, a)\\n\\n id_perm = range(n)\\n n = int(n)\\n r = r % ifac(n)\\n _unrank1(n, r, id_perm)\\n return _new_from_array_form(id_perm)\",\n \"def _mask3d(self, n, i, window):\\n\\n n = np.array(n)\\n i = np.array(i)\\n\\n w2 = (window - 1) // 2\\n\\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\\n\\n mask = np.zeros(n, dtype=np.bool)\\n mask[x1:x2, y1:y2, z1:z2] = True\\n\\n return mask\",\n \"def scan(self, mask):\",\n \"def mask_incoherent(self):\\n self.MaskPrefix = 'i' + self.MaskPrefix\\n print('Masking pixel values where .msk value is less than {0}...'.format(threshold))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n mskFile = ig.Path[:-3] + 'msk'\\n coherence = roipy.tools.load_half(ig, 2, mskFile)\\n incoherent = ma.masked_less(coherence, self.Cothresh)\\n igram[incoherent.mask] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n\\n print('Done')\",\n \"def mask(self):\\n\\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\\n\\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\\n\\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\\n\\n cv2.floodFill(image=mask,\\n mask=mask_with_border,\\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\\n newVal=constants.COLOR_WHITE_MONO)\\n\\n return mask\",\n \"def image_erosion(filter_size=3, repeat=1):\\n def img_op(image: np.ndarray,**kwargs):\\n structure_shape = [1] * image.ndim\\n structure_shape[0]=filter_size\\n structure_shape[1] = filter_size\\n for i in range(repeat):\\n image =ndimage.morphology.grey_erosion(image,size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\\n return clip(image,0,255)\\n\\n return img_op\",\n \"def zero_crossing_after(self, n):\\n n_in_samples = int(n * self.samplerate)\\n search_end = n_in_samples + self.samplerate\\n if search_end > self.duration:\\n search_end = self.duration\\n\\n frame = zero_crossing_first(\\n self.range_as_mono(n_in_samples, search_end)) + n_in_samples\\n\\n return frame / float(self.samplerate)\",\n \"def _calc_missile_scan(self):\\n self._scan_line = [False] * Stella.FRAME_WIDTH\\n\\n if self.enam & 0x02:\\n for n in range(self._number):\\n # Uses same stretching as 'ball'\\n width = 1 << ((self.nusiz & 0x30) >> 4)\\n # Uses similar position to 'player'\\n for i in range(width):\\n x = (i +self.resm + n*self._gap*8 - Stella.HORIZONTAL_BLANK) % Stella.FRAME_WIDTH \\n self._scan_line[x] = True\",\n \"def remove_polylines_in_masked_area(\\n polyline_table, narr_mask_matrix, verbose=True):\\n\\n error_checking.assert_is_integer_numpy_array(narr_mask_matrix)\\n error_checking.assert_is_geq_numpy_array(narr_mask_matrix, 0)\\n error_checking.assert_is_leq_numpy_array(narr_mask_matrix, 1)\\n error_checking.assert_is_boolean(verbose)\\n\\n num_grid_rows, num_grid_columns = nwp_model_utils.get_grid_dimensions(\\n model_name=nwp_model_utils.NARR_MODEL_NAME)\\n expected_dimensions = numpy.array(\\n [num_grid_rows, num_grid_columns], dtype=int)\\n error_checking.assert_is_numpy_array(\\n narr_mask_matrix, exact_dimensions=expected_dimensions)\\n\\n num_fronts = len(polyline_table.index)\\n indices_to_drop = []\\n\\n for i in range(num_fronts):\\n if numpy.mod(i, 25) == 0 and verbose:\\n print (\\n 'Have checked {0:d} of {1:d} polylines; have removed {2:d} of '\\n '{0:d} because they exist only in masked area...'\\n ).format(i, num_fronts, len(indices_to_drop))\\n\\n skip_this_front = _is_polyline_closed(\\n latitudes_deg=polyline_table[LATITUDES_COLUMN].values[i],\\n longitudes_deg=polyline_table[LONGITUDES_COLUMN].values[i])\\n\\n if skip_this_front:\\n indices_to_drop.append(i)\\n continue\\n\\n this_binary_matrix = polyline_to_narr_grid(\\n polyline_latitudes_deg=polyline_table[LATITUDES_COLUMN].values[i],\\n polyline_longitudes_deg=polyline_table[LONGITUDES_COLUMN].values[i],\\n dilation_distance_metres=1.)\\n\\n if not numpy.any(\\n numpy.logical_and(\\n this_binary_matrix == 1, narr_mask_matrix == 1)):\\n indices_to_drop.append(i)\\n\\n if len(indices_to_drop) == 0:\\n return polyline_table\\n\\n indices_to_drop = numpy.array(indices_to_drop, dtype=int)\\n return polyline_table.drop(\\n polyline_table.index[indices_to_drop], axis=0, inplace=False)\",\n \"def mask_emissionlines(self, element_emission_lines):\\n\\t\\t#Dictionary of corrosponding elements to their emission lines\\n\\t\\temission_dict = {'He-II' : (3202.15, 4685.74),\\n\\t\\t\\t\\t\\t\\t 'Ne-V' : (3345.81, 3425.81),\\n\\t\\t\\t\\t\\t\\t 'O-II' : (3726.03, 3728.73),\\n\\t\\t\\t\\t\\t\\t 'Ne-III': (3868.69, 3967.40),\\n\\t\\t\\t\\t\\t\\t 'H-ζ' : 3889.05,\\n\\t\\t\\t\\t\\t\\t 'H-ε' : 3970.07,\\n\\t\\t\\t\\t\\t\\t 'H-δ' : 4101.73,\\n\\t\\t\\t\\t\\t\\t 'H-γ' : 4340.46,\\n\\t\\t\\t\\t\\t\\t 'O-III' : (4363.15, 4958.83, 5006.77),\\n\\t\\t\\t\\t\\t\\t 'Ar-IV' : (4711.30, 4740.10),\\n\\t\\t\\t\\t\\t\\t 'H-β' : 4861.32,\\n\\t\\t\\t\\t\\t\\t 'N-I' : (5197.90, 5200.39),\\n\\t\\t\\t\\t\\t\\t 'He-I' : 5875.60,\\n\\t\\t\\t\\t\\t\\t 'O-I' : (6300.20, 6363.67),\\n\\t\\t\\t\\t\\t\\t 'N-II' : (6547.96, 6583.34),\\n\\t\\t\\t\\t\\t\\t 'H-α' : 6562.80,\\n\\t\\t\\t\\t\\t\\t 'S-II' : (6716.31, 6730.68),\\n\\t\\t\\t\\t\\t\\t 'Ar-III': 7135.67}\\n\\n\\t\\t#Create an array full of booleans equal to False, same size as the restframe_wavelength\\n\\t\\tself.lines_mask = np.zeros_like(self.restframe_wavelength,dtype=bool)\\n\\n\\t\\t#Loop through the input of the emission lines list\\n\\t\\tfor i in range(len(element_emission_lines)):\\n\\n\\t\\t\\t#Check if the value is in the dictionary\\n\\t\\t\\tif element_emission_lines[i] in emission_dict:\\n\\n\\t\\t\\t\\tele_line = element_emission_lines[i]\\n\\t\\t\\t\\tline = emission_dict[ele_line]\\n\\n\\t\\t\\t\\t#Check if it contains a tuple (some elements have more then one emission line)\\n\\t\\t\\t\\tif type(line) == tuple:\\n\\n\\t\\t\\t\\t\\t#Find the number of emission lines for this value\\n\\t\\t\\t\\t\\tn_lines = len(line)\\n\\n\\t\\t\\t\\t\\t#Loop through and mask them\\n\\t\\t\\t\\t\\tfor n in range(n_lines):\\n\\n\\t\\t\\t\\t\\t\\tn_line = line[n]\\n\\n\\t\\t\\t\\t\\t\\t#Creates the boolean array\\n\\t\\t\\t\\t\\t\\ttemp_lines_mask = ((self.restframe_wavelength > n_line - self.N_angstrom_masked) & (self.restframe_wavelength < n_line + self.N_angstrom_masked))\\n\\t\\t\\t\\t\\t\\t#Adds the boolean array to the exisiting one to save it\\n\\t\\t\\t\\t\\t\\tself.lines_mask = (temp_lines_mask | self.lines_mask)\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttemp_lines_mask = ((self.restframe_wavelength > line - self.N_angstrom_masked) & (self.restframe_wavelength < line + self.N_angstrom_masked))\\n\\t\\t\\t\\t\\tself.lines_mask = (temp_lines_mask | self.lines_mask)\\n\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint(element_emission_lines[i])\\n\\t\\t\\t\\traise KeyError\",\n \"def mask_image(image_path, export_path, size, layover=0.5, input_size=1000):\\n\\n # Loads the image and make sure that all images have the same size\\n image = cv2.imread(image_path)\\n image = cv2.resize(image, (input_size, input_size))\\n\\n # Calculating a valid stride size\\n stride_size = (1 - layover) * size\\n sliding_space = image.shape[0] - size\\n possible_factors = factors(sliding_space)\\n stride_size = min(possible_factors, key=lambda factor_number: abs(factor_number - stride_size))\\n\\n iterations = int(sliding_space / stride_size)\\n\\n name = image_path.split('/')[-1].split('.')[0]\\n img_format = image_path.split('/')[-1].split('.')[-1]\\n\\n for i in range(iterations):\\n y = i * stride_size\\n for j in range(iterations):\\n x = j * stride_size\\n crop_img = image[y:y + size, x:x + size]\\n path = \\\"{}{}-{}_{}.{}\\\".format(export_path, name, i, j, img_format)\\n cv2.imwrite(path, crop_img)\",\n \"def block_repeat(self, board, n):\\r\\n this_block = []\\r\\n row_start = 3 * (n // 4)\\r\\n col_start = 3 * (n % 4)\\r\\n for r in range(3):\\r\\n this_row = board[(12 * (row_start + r) + col_start):(12 * (row_start + r) + col_start + 3)]\\r\\n for x in this_row:\\r\\n this_block.append(x)\\r\\n # println(n)\\r\\n # println(this_block)\\r\\n for letter in 'abcdef':\\r\\n if this_block.count(letter) > 1:\\r\\n # println(this_block)\\r\\n return True\\r\\n return False\",\n \"def repeat(self, fn, *args, **kwargs):\\n return repeat_n_times(self.n, fn, *args, **kwargs)\",\n \"def _source_mask(self, ilens):\\n x_masks = make_non_pad_mask(ilens)\\n return x_masks.unsqueeze(-2)\",\n \"def infill_small_regions(I):\\n n_tiles = 4 # ntiles horizontally.\\n assert I.shape[0] == I.shape[1]\\n tile_size = I.shape[0] // (n_tiles - 1)\\n tile_delta = tile_size // 2\\n\\n k = 0\\n I_stack = np.ones(I.shape + (2, 2)) * np.nan\\n for j in range(n_tiles * 2 - 1):\\n for i in range(n_tiles * 2 - 1):\\n dy = slice(tile_delta * j, tile_delta * (j + 2))\\n dx = slice(tile_delta * i, tile_delta * (i + 2))\\n S = I[dy, dx]\\n M = ndimage.binary_dilation(np.isnan(S), iterations=2)\\n image_inpainted = inpaint.inpaint_biharmonic(S, M, multichannel=False)\\n I_stack[dy, dx, j % 2, i % 2] = image_inpainted\\n k += 1\\n return np.nanmean(np.nanmean(I_stack, axis=2), axis=2)\",\n \"def make_pattern(pixels, origin, pattern_size, ndots):\\n\\tw,h = pattern_size\\n\\tow,oh = origin\\n\\tcoordinates = itertools.product(range(h), range(w))\\n\\twith_offset = [(c+ow, r+oh) for r,c in coordinates]\\n\\t# take only n dots\\n\\twith_offset = with_offset[:ndots]\\n\\tfor c,r in with_offset:\\n\\t\\tpixels[c, r] = 0\",\n \"def maskbits(x: int, n:int) -> int:\\n if n >= 0:\\n return x & ((1 << n) - 1)\\n else:\\n return x & (-1 << -n)\",\n \"def filter_input_fasta(input_file, output_file, n=60):\\n all_lines = get_n_lines(input_file)\\n with open(input_file, 'r') as i, \\\\\\n open(output_file, 'w') as out:\\n index = 0\\n for sequence in i:\\n percent = int(index / all_lines * 100)\\n sys.stdout.write(f'\\\\r{index}/{all_lines} - {percent}% done!')\\n sequence = sequence.strip()\\n if sequence.startswith(\\\">\\\"):\\n out.write(sequence + '\\\\n')\\n if not sequence.startswith(\\\">\\\"):\\n split_sequence = [sequence[i:i + n] for i in range(0, len(sequence), n)]\\n out.write('\\\\n'.join(split_sequence) + '\\\\n')\\n index += 1\\n sys.stdout.write(f'\\\\r{all_lines}/{all_lines} - 100% done!')\",\n \"def infill_large_regions(I, npixels=10000, precision=1000):\\n assert I.shape[0] == I.shape[1]\\n xgrid, ygrid = np.meshgrid(np.arange(I.shape[1]),\\n np.arange(I.shape[0]))\\n\\n I_ = I.copy()\\n\\n # Exclude two pixels on the border during infilling.\\n bad_regions, n_bad_regions = ndimage.label(\\n ndimage.binary_dilation(np.isnan(I), iterations=2))\\n\\n # Use 5 pixel regions surrounding each hole.\\n surround = ndimage.grey_dilation(bad_regions, size=5)\\n counts, _ = np.histogram(bad_regions, np.arange(n_bad_regions + 1) - .5)\\n\\n for i in range(1, n_bad_regions):\\n if counts[i] > npixels:\\n # This is a big region, infill using the GPR method.\\n surround_data = (surround == i) & (bad_regions == 0)\\n xgrid_s, ygrid_s = xgrid[surround_data], ygrid[surround_data]\\n\\n # Take N_points points at random, fit a Gaussian process.\\n subs = np.random.permutation(np.arange(len(xgrid_s)))[:precision]\\n gp_kernel = Matern(length_scale=1,\\n length_scale_bounds=(.01, 100), nu=1.5)\\n gpr = GaussianProcessRegressor(kernel=gp_kernel, normalize_y=True)\\n\\n X = np.concatenate((xgrid_s.reshape(-1, 1),\\n ygrid_s.reshape(-1, 1)), axis=1)\\n gpr.fit(X[subs, :], I[surround_data][subs])\\n xgrid_s, ygrid_s = xgrid[bad_regions == i], ygrid[bad_regions == i]\\n X_ = np.concatenate((xgrid_s.reshape(-1, 1),\\n ygrid_s.reshape(-1, 1)), axis=1)\\n y_ = gpr.predict(X_)\\n I_[bad_regions == i] = y_\\n return I_\",\n \"def tril_indices(n,k=0):\\r\\n return mask_indices(n,tril,k)\",\n \"def drawN(self,n):\\n c = self.cards[:n]\\n self.cards = self.cards[n:]\\n self.discards += c\\n return(c)\",\n \"def mask_image(image):\\n pass\",\n \"def gen_mask(components):\\n masks_segments = components[7]\\n hh = components[1]\\n ww = components[2]\\n\\n if masks_segments:\\n mask_miss = np.ones((hh, ww), dtype=np.uint8)\\n for seg in masks_segments:\\n bin_mask = maskUtils.decode(seg)\\n bin_mask = np.logical_not(bin_mask)\\n mask_miss = np.bitwise_and(mask_miss, bin_mask)\\n\\n components[11] = mask_miss\\n\\n return components\",\n \"def __set_mask_regions(self):\\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\\n [299,719], [100, 550], [640, 425]]]))\",\n \"def generate_effective_mask(self, mask_size: tuple, polygons_ignore):\\n mask = np.ones(mask_size, dtype=np.uint8)\\n\\n for poly in polygons_ignore:\\n instance = poly.astype(np.int32).reshape(1, -1, 2)\\n cv2.fillPoly(mask, instance, 0)\\n\\n return mask\",\n \"def lookahead(n, iterable):\\n for value in islice(copy.copy(iterable), n, None):\\n return value\\n raise IndexError(n)\",\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 mask_particle_rect(image,bounded_rectangle, color):\\r\\n\\r\\n \\r\\n masked_image = cv2.rectangle(image, (int(bounded_rectangle[0])-1, int(bounded_rectangle[1])-1),\\r\\n (int(bounded_rectangle[0]+bounded_rectangle[2])+1, \\r\\n int(bounded_rectangle[1]+bounded_rectangle[3])+1),\\r\\n color, -1)\\r\\n\\r\\n return masked_image\",\n \"def _generate_bitmask(n: int = 2, n_bits: int = 8) -> int:\\n all_ones = 2 ** n_bits - 1\\n cancel_bits = 2 ** n - 1\\n return all_ones - cancel_bits\",\n \"def output_n(self,\\n n: int,\\n ) -> abjad.Selection:\\n if not isinstance(n, int):\\n raise TypeError(\\\"first positional argument must be 'int'\\\")\\n if n < 1:\\n raise ValueError(\\\"first positional argument must be a positive \\\"\\n \\\"'int'\\\")\\n dummy_container = abjad.Container()\\n for _ in range(n):\\n dummy_container.append(self.__call__())\\n mutate.remove_repeated_time_signatures(dummy_container[:])\\n mutate.remove_repeated_dynamics(dummy_container[:])\\n output = dummy_container[:]\\n dummy_container[:] = []\\n return output\",\n \"def caipi(r,ry,shifts):\\n rz = int(r/ry)\\n patterns = np.zeros((len(shifts),r,r))\\n l = 0\\n for i, shift in enumerate(shifts):\\n cell = np.zeros((r,r))\\n for row in range(rz):\\n if (shift*row+rz)>= r:\\n l = (shift*row%r+rz)%rz\\n else:\\n l = shift*row\\n cell[row*ry,l::rz]=1\\n patterns[i] = np.copy(cell)\\n return patterns\",\n \"def _fillcache(self, n: int | None) -> None:\\n if not n:\\n n = 1\\n try:\\n while len(self._cache) < n:\\n self._cache.append(self.modifier(next(self._iterable))) # type: ignore\\n except StopIteration:\\n while len(self._cache) < n:\\n self._cache.append(self.sentinel)\",\n \"def calcmask(self, *args, **kwargs):\\n return _image.image_calcmask(self, *args, **kwargs)\",\n \"def create_masks(image_folder: str, annotation_path: str, outpath: str):\\n\\n train_reader = ReaderAnnotation(annotation_path)\\n\\n all_images = os.listdir(image_folder)\\n annotated_images = train_reader.annotation.keys()\\n\\n creator = MaskCreator()\\n\\n for key in annotated_images:\\n file_extension = \\\".JPG\\\"\\n if not os.path.isfile(\\n os.path.join(\\n image_folder,\\n key.split(\\\".\\\")[0] + file_extension,\\n )\\n ):\\n file_extension = file_extension.lower()\\n\\n image_name = os.path.join(\\n image_folder,\\n key.split(\\\".\\\")[0] + file_extension,\\n )\\n print(image_name)\\n\\n out_image_path = os.path.join(outpath, os.path.split(image_name)[-1])\\n assert os.path.exists(out_image_path), \\\"Out image path doesn't exist\\\"\\n\\n image = plt.imread(image_name)\\n h, w, c = image.shape\\n\\n regions = train_reader.get(key)[\\\"regions\\\"]\\n # less than minimal distance\\n radius = int(train_reader.get_radius_min(regions=regions) * 0.9)\\n\\n masks = []\\n for _, center in regions.items():\\n masks.append(\\n creator.create_circular_mask(\\n h=h,\\n w=w,\\n center=(\\n int(center[\\\"shape_attributes\\\"][\\\"cx\\\"]),\\n int(center[\\\"shape_attributes\\\"][\\\"cy\\\"]),\\n ),\\n radius=radius,\\n )\\n )\\n\\n if len(masks) > 50:\\n masks = [creator._unite_masks(masks)]\\n\\n if masks:\\n creator.visualize(\\n image=image,\\n masks=masks,\\n filename=out_image_path,\\n use_image=False,\\n )\\n else:\\n creator._create_empty_mask(image=image, filename=out_image_path)\\n\\n print(\\\"Empty images:\\\")\\n for empty_image in list(set(all_images) - set(annotated_images)):\\n if os.path.exists(out_image_path):\\n continue\\n empty_image = os.path.join(image_folder, empty_image)\\n print(empty_image)\\n image = plt.imread(empty_image)\\n creator._create_empty_mask(\\n image=image,\\n filename=os.path.join(\\n outpath,\\n os.path.split(empty_image)[-1],\\n ),\\n )\",\n \"def remove_repeats(self,tri,n_c):\\n tri = order_tris(np.mod(tri,n_c))\\n sorted_tri = tri[np.lexsort(tri.T), :]\\n row_mask = np.append([True], np.any(np.diff(sorted_tri, axis=0), 1))\\n return sorted_tri[row_mask]\",\n \"def mask(self):\\n mask = np.zeros((self.height, self.width))\\n pts = [\\n np.array(anno).reshape(-1, 2).round().astype(int)\\n for anno in self.segmentation\\n ]\\n mask = cv2.fillPoly(mask, pts, 1)\\n return mask\",\n \"def lookahead(self, n=1):\\n while len(self._remaining) < n:\\n self._remaining.append(next(self))\\n return [self._remaining[i] for i in range(n)]\",\n \"def _islice_batched(it: Iterator[np.ndarray], n: int) -> Iterator[np.ndarray]:\\n while n > 0:\\n arr: np.ndarray = next(it)\\n k = arr.shape[0]\\n yield arr[:n, :]\\n n -= k\",\n \"def colormap_masked(ncolors=256, knee_index=None, cmap='inferno', alpha=0.3):\\n cm = plt.cm.get_cmap(cmap)(np.linspace(0, 1, ncolors))\\n if knee_index is None:\\n # Then map to pvals, as -log(p) between 0 and 3.5, and threshold at 0.05\\n knee_index = np.argmin(abs(np.linspace(0., 3.5, ncolors)+np.log10(0.05)))\\n \\n cm[:knee_index, :] = np.c_[cm[:knee_index, 0], cm[:knee_index, 1], cm[:knee_index, 2], alpha*np.ones((len(cm[:knee_index, 1])))]\\n return LinearSegmentedColormap.from_list('my_colormap', cm)\",\n \"def fillNDIGap(self, knn):\\n nirrho = self.readImage(self.nirfile, self.rhoband).astype(np.float_)\\n nirnhits = self.readImage(self.nirfile, self.nhitsband).astype(np.int)\\n nirmask = self.readImage(self.nirfile, self.maskband).astype(np.bool_)\\n \\n swirrho = self.readImage(self.swirfile, self.rhoband).astype(np.float_)\\n swirnhits = self.readImage(self.swirfile, self.nhitsband).astype(np.int)\\n swirmask = self.readImage(self.swirfile, self.maskband).astype(np.bool_)\\n\\n hitmask = np.logical_and(np.greater(nirnhits, 0), np.greater(swirnhits, 0))\\n if not hitmask.any():\\n # no valid hit at all!\\n print \\\"Error, no shot has returns! Check your data\\\"\\n sys.exit()\\n xhit, yhit = np.where(hitmask)\\n nirrhohit = nirrho[hitmask]/nirnhits[hitmask]\\n swirrhohit = swirrho[hitmask]/swirnhits[hitmask]\\n\\n ndi = np.zeros_like(nirrho)\\n mask = np.zeros_like(nirrho, dtype=int) + 3\\n tmpflag = np.logical_and(np.invert(nirmask), np.invert(swirmask))\\n mask[tmpflag] = 0\\n \\n ndihit = (nirrhohit - swirrhohit) / (nirrhohit + swirrhohit)\\n ndi[hitmask] = ndihit\\n mask[hitmask] = 1\\n \\n nirgapmask = np.logical_and(np.equal(nirnhits, 0), np.greater(swirnhits, 0))\\n swirgapmask = np.logical_and(np.greater(nirnhits, 0), np.equal(swirnhits, 0))\\n\\n if (not nirgapmask.any()) and (not swirgapmask.any()):\\n # no gap\\n print \\\"No fillable gap.\\\"\\n return ndi, mask\\n\\n gapmask = np.logical_or(nirgapmask, swirgapmask)\\n xgap, ygap = np.where(gapmask)\\n\\n X = np.hstack((xhit.reshape(len(xhit), 1), yhit.reshape(len(yhit), 1))).astype(np.float32)\\n T = np.hstack((xgap.reshape(len(xgap), 1), ygap.reshape(len(ygap), 1))).astype(np.float32)\\n ndigap = self.fillGap(X, ndihit, T, knn)\\n ndi[gapmask] = ndigap\\n mask[gapmask] = 2\\n\\n self.ndi = ndi\\n self.mask = mask\\n \\n return ndi, mask\",\n \"def crop(self, N):\\n self.data = self.data[:,:N]\",\n \"def drizzle_mask(source, dest, output):\\n if os.path.exists(output):\\n os.system('rm %s' % output)\\n coord_src = flatten_pixcoord(source)\\n print \\\"Transforming coordinates...\\\"\\n coord_dest = transform_pixcoord(source, dest)\\n hdr_dest = pyfits.getheader(dest)\\n mask_in = pyfits.getdata(source)\\n mask_out = np.zeros((hdr_dest['naxis1'], hdr_dest['naxis2']))\\n # Now this might take a lot of time... is there a more clever way?\\n print \\\"Start looping all the pixels, might take a while...\\\"\\n for i in range(coord_src.shape[0]):\\n x0, y0 = coord_src[i]\\n if mask_in[y0-1,x0-1] > 0:\\n x1, y1 = coord_dest[i]\\n mask_out[y1-1,x1-1] = 1\\n # write output\\n pyfits.append(output, data=mask_out, header=hdr_dest)\",\n \"def sharpened(image, n):\\n #store image width and height\\n image_width = image['width']\\n image_height = image['height']\\n #intialize new image and stores blurred image\\n new_image = {'height': image['height'], 'width': image['width'], 'pixels': len(image['pixels'])*[0]}\\n blurred_image = blurred(image, n)\\n \\n #loop through every coordinate\\n for x in range(image_width):\\n for y in range(image_height):\\n #perform calculation and set pixel\\n a = 2*get_pixel(image, x, y) - get_pixel(blurred_image, x, y)\\n set_pixel(new_image, x, y, a)\\n return round_and_clip_image(new_image)\",\n \"def image_dilation(filter_size=3, repeat=1):\\n def img_op(image: np.ndarray,**kwargs):\\n structure_shape = [1] * image.ndim\\n structure_shape[0]=filter_size\\n structure_shape[1] = filter_size\\n for i in range(repeat):\\n image = ndimage.morphology.grey_dilation(image, size=(filter_size,filter_size),structure=np.ones(tuple(structure_shape)))\\n\\n return clip(image,0,255)\\n\\n return img_op\",\n \"def removedigits(self,n):\\r\\n if n == 1:\\r\\n for i in range(30):\\r\\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\\r\\n self.print(self.puzzle)\\r\\n self.play()\\r\\n if n == 2:\\r\\n for i in range(40):\\r\\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\\r\\n self.print(self.puzzle)\\r\\n self.play()\\r\\n if n == 3:\\r\\n for i in range(50):\\r\\n self.puzzle[random.randrange(0, 9)][random.randrange(0,9)] = 0\\r\\n self.print(self.puzzle)\\r\\n self.play()\",\n \"def padding(img, n):\\n img = np.pad(img, [(n, n), (n, n)], mode='constant', constant_values=0)\\n\\n return img\",\n \"def rslice(n, allow_empty=False):\\n minlen = 0 if allow_empty or n == 0 else 1\\n slicelen = randrange(minlen, n + 1)\\n return randslice_from_slicelen(slicelen, n)\",\n \"def simulate_source_mask(binary, n_holes, hole_radius_arcmin):\\n\\n mask = binary.copy()\\n if binary.pixel == \\\"HEALPIX\\\":\\n idx = np.where(binary.data == 1)\\n for i in range(n_holes):\\n random_index1 = np.random.choice(idx[0])\\n vec = hp.pixelfunc.pix2vec(binary.nside, random_index1)\\n disc = hp.query_disc(binary.nside, vec, hole_radius_arcmin / (60.0 * 180) * np.pi)\\n mask.data[disc] = 0\\n\\n if binary.pixel == \\\"CAR\\\":\\n random_index1 = np.random.randint(0, binary.data.shape[0], size=n_holes)\\n random_index2 = np.random.randint(0, binary.data.shape[1], size=n_holes)\\n mask.data[random_index1, random_index2] = 0\\n dist = enmap.distance_transform(mask.data)\\n mask.data[dist * 60 * 180 / np.pi < hole_radius_arcmin] = 0\\n\\n return mask\",\n \"def test_RobustMNINormalizationRPT_masked(self):\\n ants_rpt = RobustMNINormalizationRPT(\\n generate_report=True, moving_image=self.moving,\\n reference_mask=self.reference_mask, flavor='testing')\\n _smoke_test_report(ants_rpt, 'testRobustMNINormalizationRPT_masked.svg')\",\n \"def __setitem__(self, n, bit):\\n self.num ^= (np.uint64(-bit) ^ self.num) & (UINT64_ONE << np.uint64(n))\",\n \"def mask(n):\\n if n >= 0:\\n return 2**n - 1\\n else:\\n return 0\",\n \"def mask(n):\\n if n >= 0:\\n return 2**n - 1\\n else:\\n return 0\",\n \"def grouper(iterable: Iterable, n: int = 100, fillvalue: Any = None) -> Any:\\r\\n args = [iter(iterable)] * n\\r\\n return zip_discard_compr(*args)\",\n \"def rslice(n, allow_empty=False):\\n minlen = 0 if allow_empty or n == 0 else 1\\n slicelen = randrange(minlen, n+1)\\n return randslice_from_slicelen(slicelen, n)\",\n \"def tril_indices(n, k=0):\\r\\n return mask_indices(n, np.tril, k)\",\n \"def rshift(val: int, n: int) -> int:\\n return (val % 0x100000000) >> n\",\n \"def repeatfunc(func, n, *args):\\n return starmap(func, repeat(args, n))\",\n \"def mask_region_ends(self, n_days=20):\\n for rg in self.Rs:\\n i = self.Rs.index(rg)\\n self.Active.mask[i, -n_days:] = True\\n self.Confirmed.mask[i, -n_days:] = True\\n self.Deaths.mask[i, -n_days:] = True\\n self.NewDeaths.mask[i, -n_days:] = True\\n self.NewCases.mask[i, -n_days:] = True\",\n \"def mask_step(self, step):\\n m = step * self.mask_full()\\n return m.astype(np.int32)\",\n \"def northpole_unmasked(res='4x5', mask2D=False):\\n # Create a dummy array of zeros\\n m = np.zeros(get_dims4res(res))\\n # adjust for resolution at grid start points at 62\\n if res == '4x5':\\n lats = np.arange(62, 90, 1) # define N pole as > 60N\\n else:\\n lats = np.arange(60, 90, 1) # define N pole as > 60N\\n lats = [get_gc_lat(i, res=res) for i in lats]\\n for i in lats:\\n m[:, i, :] = 1\\n\\n # Create a np.ma mask\\n m = np.ma.masked_not_equal(m, 1)\\n\\n # Return 2D or 3D?\\n if mask2D:\\n return m[..., 0].mask\\n else:\\n return m.mask\",\n \"def __init__(self, iterable_input, n=1, name='re-repeat', verbose=True):\\n super().__init__(iterable_input=iterable_input, name=name, verbose=verbose)\\n self.n = n\",\n \"def Repeater(arr,n):\\n new_arr = np.zeros((arr.shape[0]*n,arr.shape[1]),dtype=object)\\n for i in range(0,arr.shape[0]):\\n new_row = np.tile(arr[i,:],(n,1))\\n new_arr[i*n:(i+1)*n,:] = new_row\\n return new_arr\",\n \"def keep_ints(n):\\n\\tdef f(cond):\\n\\t\\ti=1\\n\\t\\twhile i<=n:\\n\\t\\t\\tif cond(i)==True:\\n\\t\\t\\t\\tprint(i)\\n\\t\\t\\ti += 1\\n\\treturn f\",\n \"def _clear_last_lines(n=1):\\n for _ in range(n):\\n sys.stdout.write(CURSOR_UP_ONE)\\n sys.stdout.write(ERASE_LINE)\",\n \"def _repeat_pattern(pattern, width):\\n assert width % pattern.width == 0\\n return operation.repeat(pattern, width // pattern.width)\",\n \"def get_test_pattern(img_size=(2048, 2048)):\\n ny, nx = img_size\\n # mask = np.zeros((ny, nx))\\n\\n # patterns with variable spacing\\n periods = range(2, 20, 2)\\n # vcounter = 0\\n for ii, p in enumerate(periods):\\n cell = np.zeros((p, nx))\\n on_pix = int(np.ceil(p / 2))\\n cell[:on_pix, :] = 1\\n cell = np.tile(cell, [4, 1])\\n\\n if ii == 0:\\n mask = cell\\n else:\\n mask = np.concatenate((mask, cell), axis=0)\\n\\n mask = mask[:, :mask.shape[0]]\\n\\n mask_block = np.concatenate((mask, np.rot90(mask)), axis=1)\\n mask_block2 = np.concatenate((np.rot90(mask), mask), axis=1)\\n\\n mask_superblock = np.concatenate((mask_block, mask_block2))\\n\\n ny_reps = int(np.ceil(ny / mask_superblock.shape[0]))\\n nx_reps = int(np.ceil(nx / mask_superblock.shape[1]))\\n mask = np.tile(mask_superblock, [ny_reps, nx_reps])\\n mask = mask[0:ny, 0:nx]\\n\\n return mask\",\n \"def cartesian_mask(self, shape, centred=False, uniform=True):\\n\\t\\tR = self.R\\n\\t\\tsample_n = self.sample_n\\n\\t\\tif uniform:\\n\\t\\t\\tN, Nx, Ny = int(np.prod(shape[:-2])), shape[-2], shape[-1]\\n\\t\\t\\tn_lines = int(Nx / R)\\n\\t\\t\\t\\n\\t\\t\\tmask = np.zeros((N, Nx, Ny))\\n\\t\\t\\tfor i in range(N):\\n\\t\\t\\t\\tidx = np.arange(0,Nx,R)\\n\\t\\t\\t\\tmask[i, idx, :] = 1\\n\\t\\t\\t\\t\\n\\t\\t\\tif sample_n:\\n\\t\\t\\t\\tmask[:, Nx//2-sample_n//2:(Nx//2+sample_n//2),:] = 1\\n \\n\\t\\telse:\\n\\t\\t\\tN, Nx, Ny = int(np.prod(shape[:-2])), shape[-2], shape[-1]\\n\\t\\t\\tpdf_x = self.normal_pdf(Nx, 0.5/(Nx/10.)**2)\\n\\t\\t\\tlmda = Nx/(2.*R)\\n\\t\\t\\tn_lines = int(Nx / R)\\n \\n # add uniform distribution\\n\\t\\t\\tpdf_x += lmda * 1./Nx\\n \\n\\t\\t\\tif sample_n:\\n\\t\\t\\t\\tpdf_x[Nx//2-sample_n//2:Nx//2+sample_n//2] = 0\\n\\t\\t\\t\\tpdf_x /= np.sum(pdf_x)\\n\\t\\t\\t\\tn_lines -= sample_n\\n \\n\\t\\t\\tmask = np.zeros((N, Nx))\\n\\t\\t\\tfor i in range(N):\\n\\t\\t\\t\\tidx = np.random.choice(Nx, n_lines, False, pdf_x)\\n\\t\\t\\t\\tmask[i, idx] = 1\\n \\n\\t\\t\\tif sample_n:\\n\\t\\t\\t\\tmask[:, Nx//2-sample_n//2:Nx//2+sample_n//2] = 1\\n \\n\\t\\t\\tsize = mask.itemsize\\n\\t\\t\\tmask = as_strided(mask, (N, Nx, Ny), (size * Nx, size, 0))\\n \\n\\t\\t\\tmask = mask.reshape(shape)\\n \\n\\t\\tif not centred:\\n\\t\\t\\tmask = np.fft.ifftshift(mask, axes=(-1, -2))\\n \\n\\t\\treturn mask\",\n \"def regenerate_masks(sensor):\\n N = len(sensor.data[\\\"counter\\\"])\\n mask_moving = np.zeros(N, dtype=bool)\\n\\n for I in sensor.data[\\\"interval_steps\\\"]:\\n mask_moving[I[0]:I[1]] = True\\n\\n mask_resting = np.logical_not(mask_moving)\\n\\n sensor.data[\\\"mask_a_resting\\\"] = mask_resting\\n sensor.data[\\\"mask_a_moving\\\"] = mask_moving\",\n \"def mask_border(self, left=3, right=3, top=3, bottom=3):\\n self.MaskPrefix = 'b' + self.MaskPrefix #prepend 'b' for border\\n print('Masking edge pixels: left={0}, right={1}, top={2}, bottom={3}'.format(left,right,top,bottom))\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n igram[:top,:] = ma.masked\\n igram[-bottom:,:] = ma.masked\\n igram[:,:left] = ma.masked\\n igram[:,-right:] = ma.masked\\n mskFile = self.MaskPrefix + 'Mask_' + ig.Name[:-4]\\n np.save(os.path.join(self.ProcDir, mskFile), igram.mask)\\n print(mskFile)\\n print('mask_border() complete: {0} interferograms'.format(self.Set.Nig))\",\n \"def chop_rle(source, n):\\n\\n result = ''\\n for v in source:\\n # Count the minimum number of chunks we need to represent v.\\n numChunks = (count_bits(v) + n - 1) / n\\n\\n # We write out a number of zeroes to indicate this.\\n zeroCount = numChunks - 1\\n for z in range(zeroCount):\\n yield 0\\n\\n mask = (1 << n) - 1\\n for x in range(numChunks):\\n b = (v >> ((numChunks - x - 1) * n)) & mask\\n assert b != 0 or x != 0\\n yield b\",\n \"def crop_image(filename, n):\\n image = SimpleImage(filename)\\n width = image.width\\n new_width = width - (2 * n)\\n height = image.height\\n new_height = height - (2 * n)\\n image_crop_width = SimpleImage.blank(new_width, height)\\n for y in range(height):\\n for x in range(new_width):\\n pixel = image.get_pixel((x + n), y)\\n image_crop_width.set_pixel(x, y, pixel)\\n image_crop_width.show()\\n\\n image_crop_height = SimpleImage.blank(width, new_height)\\n for y in range(new_height):\\n for x in range(width):\\n pixel = image.get_pixel(x, y + n)\\n image_crop_height.set_pixel(x, y, pixel)\\n image_crop_height.show()\\n\\n image_crop_width_height = SimpleImage.blank(new_width, new_height)\\n for y in range(new_height):\\n for x in range(new_width):\\n pixel = image.get_pixel(x + n, y + n)\\n image_crop_width_height.set_pixel(x, y, pixel)\\n image_crop_width_height.show()\",\n \"def static_mask(self, frames):\\r\\n c, t, h, w = frames.shape\\r\\n rand_t = random.randint(0, t-1)\\r\\n mask_size_ratio = random.uniform(self.mask_size_ratio[0], self.mask_size_ratio[1])\\r\\n mask_size_x, mask_size_y = [int(w*mask_size_ratio), int(h*mask_size_ratio)]\\r\\n start_x = random.randint(0, w-mask_size_x)\\r\\n start_y = random.randint(0, h-mask_size_y)\\r\\n frames_out = frames[:, rand_t].unsqueeze(1).expand(-1, t, -1, -1).clone()\\r\\n frames_out[:, :, start_y:start_y+mask_size_y, start_x:start_x+mask_size_x] = frames[\\r\\n :, :, start_y:start_y+mask_size_y, start_x:start_x+mask_size_x\\r\\n ]\\r\\n return frames_out\",\n \"def regex_grid(n):\\n cx = 2 ** (n - 1)\\n cy = 2 ** (n - 1)\\n grid = [[grid_numbering(n, i , j, cx, cy) for i in range(2 ** n)] for j in range(2 ** n)]\\n \\n return grid\",\n \"def one_mask(self):\\n accum = 0\\n for i in range(self.data.itemsize):\\n accum += (0xAA << (i << 3))\\n return accum\",\n \"def check_modulus(n):\\n # type: (int) -> List[RE]\\n return [check_composite(n), check_modulus_size(n)]\",\n \"def _pattern01(width):\\n zeroes = core.Constant(0, width)\\n return operation.Concat(zeroes, ~zeroes)\",\n \"def square_mask(ys_in_pad, ignore_id):\\n ys_mask = (ys_in_pad != ignore_id).unsqueeze(-2)\\n ymax = ys_mask.size(-1)\\n ys_mask_tmp = ys_mask.transpose(1, 2).repeat(1, 1, ymax)\\n ys_mask = ys_mask.repeat(1, ymax, 1) & ys_mask_tmp\\n\\n return ys_mask\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5703053","0.5262323","0.5123203","0.51200473","0.5092291","0.49722835","0.49684605","0.49445692","0.49437836","0.491899","0.4886753","0.48616335","0.48601496","0.48428234","0.48108998","0.48108998","0.4792055","0.4777932","0.47722837","0.4742274","0.47373512","0.4711676","0.47053996","0.4682111","0.46651107","0.4652202","0.46494442","0.46416214","0.4624971","0.46084505","0.46028677","0.45469362","0.45341787","0.45335522","0.4531556","0.4529826","0.45289508","0.45284888","0.45262912","0.4514679","0.45081156","0.4501338","0.44994363","0.44882745","0.44843188","0.44675025","0.44618264","0.44572452","0.4450033","0.44451827","0.44386292","0.4434398","0.44186795","0.440805","0.44009328","0.43932053","0.4391505","0.43907532","0.43831205","0.4377002","0.4374964","0.4373122","0.43708733","0.4361518","0.43573087","0.43544698","0.43529612","0.43527463","0.43471378","0.43341917","0.43317336","0.43304196","0.43262443","0.4325965","0.4325965","0.43213803","0.43209106","0.4317818","0.43062666","0.4301221","0.4300035","0.43000123","0.42978123","0.42869547","0.42841378","0.42808306","0.42766953","0.42765215","0.42730644","0.42699656","0.42677918","0.42674327","0.42613903","0.42613578","0.42569464","0.42490053","0.42461386","0.42426673","0.42426223","0.42415145"],"string":"[\n \"0.5703053\",\n \"0.5262323\",\n \"0.5123203\",\n \"0.51200473\",\n \"0.5092291\",\n \"0.49722835\",\n \"0.49684605\",\n \"0.49445692\",\n \"0.49437836\",\n \"0.491899\",\n \"0.4886753\",\n \"0.48616335\",\n \"0.48601496\",\n \"0.48428234\",\n \"0.48108998\",\n \"0.48108998\",\n \"0.4792055\",\n \"0.4777932\",\n \"0.47722837\",\n \"0.4742274\",\n \"0.47373512\",\n \"0.4711676\",\n \"0.47053996\",\n \"0.4682111\",\n \"0.46651107\",\n \"0.4652202\",\n \"0.46494442\",\n \"0.46416214\",\n \"0.4624971\",\n \"0.46084505\",\n \"0.46028677\",\n \"0.45469362\",\n \"0.45341787\",\n \"0.45335522\",\n \"0.4531556\",\n \"0.4529826\",\n \"0.45289508\",\n \"0.45284888\",\n \"0.45262912\",\n \"0.4514679\",\n \"0.45081156\",\n \"0.4501338\",\n \"0.44994363\",\n \"0.44882745\",\n \"0.44843188\",\n \"0.44675025\",\n \"0.44618264\",\n \"0.44572452\",\n \"0.4450033\",\n \"0.44451827\",\n \"0.44386292\",\n \"0.4434398\",\n \"0.44186795\",\n \"0.440805\",\n \"0.44009328\",\n \"0.43932053\",\n \"0.4391505\",\n \"0.43907532\",\n \"0.43831205\",\n \"0.4377002\",\n \"0.4374964\",\n \"0.4373122\",\n \"0.43708733\",\n \"0.4361518\",\n \"0.43573087\",\n \"0.43544698\",\n \"0.43529612\",\n \"0.43527463\",\n \"0.43471378\",\n \"0.43341917\",\n \"0.43317336\",\n \"0.43304196\",\n \"0.43262443\",\n \"0.4325965\",\n \"0.4325965\",\n \"0.43213803\",\n \"0.43209106\",\n \"0.4317818\",\n \"0.43062666\",\n \"0.4301221\",\n \"0.4300035\",\n \"0.43000123\",\n \"0.42978123\",\n \"0.42869547\",\n \"0.42841378\",\n \"0.42808306\",\n \"0.42766953\",\n \"0.42765215\",\n \"0.42730644\",\n \"0.42699656\",\n \"0.42677918\",\n \"0.42674327\",\n \"0.42613903\",\n \"0.42613578\",\n \"0.42569464\",\n \"0.42490053\",\n \"0.42461386\",\n \"0.42426673\",\n \"0.42426223\",\n \"0.42415145\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77437854"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84663,"cells":{"query":{"kind":"string","value":"The mask of a 3d image should be 2d"},"document":{"kind":"string","value":"def test_05_01_mask_of3D(self):\n x=cpi.Image()\n x.image = np.ones((10,10,3))\n self.assertTrue(x.mask.ndim==2)"},"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_mask(self):\n\t\treturn pygame.mask.from_surface(self.img)","def getHitmask(self,image):\n\t\tmask = []\n\t\tfor x in range(image.get_width()):\n\t\t\tmask.append([])\n\t\t\tfor y in range(image.get_height()):\n\t\t\t\tmask[x].append(bool(image.get_at((x,y))[3]))\n\t\treturn mask","def get_mask(self, img):\n raise NotImplementedError()","def _mask3d(self, n, i, window):\n\n n = np.array(n)\n i = np.array(i)\n\n w2 = (window - 1) // 2\n\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\n\n mask = np.zeros(n, dtype=np.bool)\n mask[x1:x2, y1:y2, z1:z2] = True\n\n return mask","def testMask2D(self):\n mask = np.ones((3, 3), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\n conv1 = snt.Conv3D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def testMask3D(self):\n mask = np.ones((3, 3, 2), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\n conv1 = snt.Conv2D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 18 * np.ones((1, 3, 3, 1))\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def make_attention_mask_3d(source_mask, target_mask):\n mask = target_mask[:, None, :] * source_mask[:, :, None]\n return mask","def testMask3D(self):\n mask = np.ones((3, 3, 3), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\n conv1 = snt.Conv3D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def getHitmask(image):\n mask = []\n for x in range(image.get_width()):\n mask.append([])\n for y in range(image.get_height()):\n mask[x].append(bool(image.get_at((x,y))[3]))\n return mask","def mask_image(image):\n pass","def GetMaskImage(self) -> \"itkImageF3 const *\":\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIF3_GetMaskImage(self)","def testMask3D(self):\n mask = np.ones((3, 2, 1), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(1, 5, 2))\n conv1 = snt.Conv1D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = np.reshape(np.array([6, 6, 6]), (1, 3, 1))\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def prepareMask(self, mask):\n\n # Make sure that the mask has the same\n # number of voxels as the atlas image.\n # Use nearest neighbour interpolation\n # for resampling, as it is most likely\n # that the mask is binary.\n try:\n mask, xform = resample.resample(\n mask, self.shape[:3], dtype=np.float32, order=0)\n\n except ValueError:\n raise MaskError('Mask has wrong number of dimensions')\n\n # TODO allow non-aligned mask - as long as it overlaps\n # in world coordinates, it should be allowed\n if not fslimage.Image(mask, xform=xform).sameSpace(self):\n raise MaskError('Mask is not in the same space as atlas')\n\n return mask","def build3D(imMask, imInout, grid=m3D.DEFAULT_GRID3D):\r\n \r\n if imInout.getDepth()==1:\r\n _build3D_1(imMask, imInout, grid)\r\n elif imInout.getDepth()==8:\r\n _build3D_8(imMask, imInout, grid)\r\n else:\r\n _build3D_32(imMask, imInout, grid)","def GetMaskImage(self) -> \"itkImageSS3 const *\":\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterISS3_GetMaskImage(self)","def testMask2D(self):\n\n # This mask, applied on an image filled with 1, should result in an image\n # filled with 8 (since we sum 4 elements per channel and there are 2 input\n # channels).\n mask = np.array([[1, 1, 1],\n [1, 0, 0],\n [0, 0, 0]], dtype=np.float32)\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\n conv1 = snt.Conv2D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = np.array([[8] * 3] * 3)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(np.reshape(out.eval(), [3, 3]), expected_out)","def calcmask(self, *args, **kwargs):\n return _image.image_calcmask(self, *args, **kwargs)","def GetMaskImage(self) -> \"itkImageUC3 const *\":\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUC3_GetMaskImage(self)","def GetMaskImage(self) -> \"itkImageUS3 const *\":\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUS3_GetMaskImage(self)","def show_mask(image, mask): \n plt.subplot(1,2,1)\n plt.title('image')\n plt.imshow(image)\n plt.subplot(1,2,2)\n plt.title('mask')\n plt.imshow(mask)\n plt.show()","def apply_mask(components):\n img = components[10]\n mask = components[11]\n if mask is not None:\n img[:, :, 0] = img[:, :, 0] * mask\n img[:, :, 1] = img[:, :, 1] * mask\n img[:, :, 2] = img[:, :, 2] * mask\n img[img == 0] = 128\n return components","def test(shape=(1000,2000)):\n mask = Mask()\n mask.addCircle(400,300,250)\n mask.subtractCircle(400,300,150)\n mask.addRectangle(350,250,1500,700)\n plt.imshow( mask.getMask(shape) )\n return mask","def mask_img(img, mask):\n masked_img = np.zeros(img.shape)\n masked_img[mask] = img[mask]\n return masked_img","def mask(self):","def _get_mask(self, anno, idx):\n coco = self.coco\n img_info = coco.loadImgs(self.img_ids[idx])[0]\n\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\n\n for obj in anno:\n if 'segmentation' in obj:\n if obj['iscrowd']:\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n m += pycocotools.mask.decode(rle)\n elif obj['num_keypoints'] == 0:\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\n img_info['height'],\n img_info['width'])\n for rle in rles:\n m += pycocotools.mask.decode(rle)\n\n return m < 0.5","def __mask(input, mask):\n return cv2.bitwise_and(input, input, mask=mask)","def extract_object(image, mask):\r\n\r\n\tassert image.ndim == 3 and image.shape[2] == 3 and image.shape[:2] == mask.shape[:2]\r\n\r\n\tif mask.ndim == 2:\r\n\t\t## expand dimension so that the array is 3-d\r\n\t\tmask = np.expand_dims(mask, axis = -1)\r\n\t\toutput = np.multiply(image, mask).astype(np.uint8)\r\n\telse:\r\n\r\n\t\t## **there may be faster way to perform this operation\r\n\t\tmask = np.expand_dims(mask, axis = 2)\r\n\r\n\t\toutput = 0\r\n\t\tfor i in range(mask.shape[-1]):\r\n\t\t\toutput += np.multiply(image, mask[:, :, :, i])\r\n\r\n\t\toutput = output.astype(np.uint8)\r\n\r\n\r\n\treturn output","def build_attention_mask_3d_padding(source_mask, target_mask):\n mask = make_attention_mask_3d(source_mask, target_mask)\n # invert mask for Megatron\n return mask < 0.5","def testMask4D(self):\n mask = np.ones((3, 3, 3, 5), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\n conv1 = snt.Conv3D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def apply_mask_to_image(image, mask, return_as_image=True):\n (n,m,k) = np.shape(image)\n image = np.reshape(image, (n*m, k))\n mask = np.ravel(mask)\n\n if return_as_image:\n image[np.invert(mask), :] = 0\n image = np.reshape(image, (n,m,k))\n else:\n image = image[mask, :]\n return image","def overlay(image, mask):\n if len(image.shape) == 3:\n image = image[:, :, 0]\n if len(mask.shape) == 3:\n mask = mask[:, :, 0]\n if np.amax(image) > 100:\n image = image / 255\n\n masked = np.ma.masked_where(mask == 0, mask)\n\n plt.figure()\n plt.subplot(1, 2, 1)\n plt.imshow(image, 'gray', interpolation='nearest')\n plt.subplot(1, 2, 2)\n plt.imshow(image, 'gray', interpolation='nearest')\n plt.imshow(masked, 'jet', interpolation='nearest', alpha=0.5)\n plt.show()","def _get_mask_volume(mask_img):\n affine = mask_img.affine\n prod_vox_dims = 1.0 * np.abs(np.linalg.det(affine[:3, :3]))\n return prod_vox_dims * _get_data(mask_img).astype(bool).sum()","def __call__(self, image: np.ndarray) -> np.ndarray:\n # convert PIL image to numpy array\n image = np.asarray(image)\n\n # get masks, all pixels\n np_mask = np.array(np.ones(image.shape[0:2]), dtype=bool)\n\n return np_mask","def make_niimage_3d(map, mask, affine, zscore=False):\n\tV = map.size\n\tnx, ny, nz = mask.shape\n\tassert(V == mask.sum())\n\tmask = mask == True\n\n\tif zscore:\n\t\tmap = (map - map.mean()) / map.var()\n\n\tdata = np.zeros((nx, ny, nz))\n\tdata[mask] = map \n\n\tnifti_image = nib.Nifti1Image(data, affine)\n\treturn nifti_image","def get_mask(self, anno, img_info) -> np.ndarray:\n m = np.zeros((img_info[\"height\"], img_info[\"width\"]), dtype=np.float32)\n\n for obj in anno:\n if obj[\"iscrowd\"]:\n rle = pycocotools.mask.frPyObjects(obj[\"segmentation\"], img_info[\"height\"], img_info[\"width\"])\n mask = pycocotools.mask.decode(rle)\n if mask.shape != m.shape:\n logger.warning(f\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\")\n continue\n m += mask\n elif obj[\"num_keypoints\"] == 0:\n rles = pycocotools.mask.frPyObjects(obj[\"segmentation\"], img_info[\"height\"], img_info[\"width\"])\n for rle in rles:\n mask = pycocotools.mask.decode(rle)\n if mask.shape != m.shape:\n logger.warning(f\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\")\n continue\n\n m += mask\n\n return (m < 0.5).astype(np.float32)","def layer_masks(self, module):\n pass\n # return masks","def load_mask(self, image_id):\n image_info = self.image_info[image_id]\n if image_info[\"source\"] != \"face\":\n return super(self.__class__, self).load_mask(image_id)\n info = self.image_info[image_id]\n mask = np.zeros([info['height'], info['width'], len(info['boundingbox'])], dtype=np.uint8)\n for i, p in enumerate(info['boundingbox'].values()):\n rr, cc = skimage.draw.polygon(p['y'], p['x'])\n mask[rr, cc, i] = 1\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)","def get_pred_mask(test_image, model):\n\n test_image= test_image=transforms.ToPILImage()(test_image)\n #test_image=Image.fromarray(test_image)\n new_mask = model(transforms.ToTensor()(test_image).unsqueeze(1).cuda())[1].transpose(1,2).transpose(2,3).cpu().detach().numpy().squeeze()\n return new_mask","def inflate_mask(mask):\n kernel = np.ones((12, 12), np.uint8)\n return cv2.dilate(mask, kernel, 1)","def testMask4D(self):\n\n # This mask, applied on an image filled with 1, should result in an image\n # filled with 17, as there are 18 weights but we zero out one of them.\n mask = np.ones([3, 3, 2, 1], dtype=np.float32)\n mask[0, 0, 0, :] = 0\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\n conv1 = snt.Conv2D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = np.array([[17] * 3] * 3)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(np.reshape(out.eval(), [3, 3]), expected_out)","def generate_inpaint_mask(n_samples, n_colors, spatial_width):\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\n # simple mask -- just mask out half the image\n mask[:,:,:,spatial_width/2:] = True\n return mask.ravel()","def dualBuild3D(imMask, imInout, grid=m3D.DEFAULT_GRID3D):\r\n \r\n if imInout.getDepth()==1:\r\n _dualBuild3D_1(imMask, imInout, grid)\r\n elif imInout.getDepth()==8:\r\n _dualBuild3D_8(imMask, imInout, grid)\r\n else:\r\n _dualBuild3D_32(imMask, imInout, grid)","def get_mask(self, image):\n mask = self.get_gradients(image)\n return mask","def testMask5D(self):\n mask = np.ones((3, 3, 3, 5, 1), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\n conv1 = snt.Conv3D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def embed(im, mask, clipfloor=0., randomfloor=False):\n j=0\n out=np.zeros(len(mask))\n for i in range(len(mask)):\n if mask[i]:\n out[i] = im[j]\n j += 1\n else:\n # prevent total variation gradient singularities\n if randomfloor: out[i] = clipfloor * np.random.normal()\n else: out[i] = clipfloor\n\n return out","def build_attention_mask_3d(source_mask, target_mask, attn_mask_type):\n if attn_mask_type == AttnMaskType.padding:\n mask = build_attention_mask_3d_padding(source_mask, target_mask)\n elif attn_mask_type == AttnMaskType.causal:\n mask = build_attention_mask_3d_causal(source_mask, target_mask)\n else:\n raise ValueError(f\"Unsupported attention mask attn_mask_type = {attn_mask_type}\")\n\n return mask","def get_mask(self):\n w, h = self.rect.w, self.rect.h\n colorkey = (0, 0, 0)\n surface = pg.Surface((w, h))\n surface.set_colorkey(colorkey)\n # fill the surface with the spherical object\n color, center, radius = (255, 255, 255), self.rect.center, round(self.rect.w/2)\n pg.draw.circle(surface, color, center, radius)\n mask = pg.mask.from_surface(surface)\n return mask","def _mask(self):\n if self.__mask is None:\n # need this to be *exactly* the numpy boolean False\n return nomask\n return self.__mask","def testMask1D(self):\n mask = 0.5 * np.ones((3,), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\n conv1 = snt.Conv3D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = 67.5 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def load_mask(path, image, mask_name='module_unet', center=True):\n with open(path, 'r') as file:\n data = json.load(file)\n # if len(data[\"objects\"]) == 0:\n # return None\n # code = data[\"objects\"][0][\"bitmap\"][\"data\"]\n # origin = data[\"objects\"][0][\"bitmap\"][\"origin\"]\n # else:\n # flag = True\n # for obj in data[\"objects\"]:\n # if obj['classTitle'] == mask_name:\n inx = has_mask(mask_name, data=data)\n if inx is not False:\n obj = data[\"objects\"][inx]\n code = obj[\"bitmap\"][\"data\"]\n origin = obj[\"bitmap\"][\"origin\"]\n else:\n mask = np.zeros((image.shape[0], image.shape[1]))\n mask = mask.astype('uint8')\n mask_center = np.array([mask.shape[1]/2, mask.shape[0]/2])\n if center:\n return mask, mask_center\n else:\n return mask\n mask = base64_2_mask(code)\n mask_center = np.array([mask.shape[1]/2, mask.shape[0]/2])\n mask_center += origin\n\n up = np.zeros((origin[1], mask.shape[1]))\n mask2 = np.vstack((up, mask))\n left = np.zeros((mask2.shape[0], origin[0]))\n mask3 = np.hstack((left, mask2))\n down = np.zeros((image.shape[0] - mask3.shape[0], mask3.shape[1]))\n mask4 = np.vstack((mask3, down))\n right = np.zeros((mask4.shape[0], image.shape[1] - mask4.shape[1]))\n mask5 = np.hstack((mask4, right))\n\n if center:\n return mask5.astype('uint8'), mask_center.astype(int)\n else:\n return mask5.astype('uint8')","def get_mask ( self, iloc ):\n mask = self._mask[iloc]\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n sat = g.ReadAsArray()\n m3 = sat == 0\n\n the_mask = mask.replace(\"SAT\", \"DIV\")\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n div = g.ReadAsArray()\n m1 = div == 0\n\n the_mask = mask.replace(\"SAT\", \"NUA\")\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n nua = g.ReadAsArray()\n m2 = np.logical_not ( np.bitwise_and ( nua, 1 ).astype ( np.bool ) )\n return m1 * m2 * m3","def get_mask ( self, iloc ):\n mask = self._mask[iloc]\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n sat = g.ReadAsArray()\n m3 = sat == 0\n\n the_mask = mask.replace(\"SAT\", \"DIV\")\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n div = g.ReadAsArray()\n m1 = div == 0\n\n the_mask = mask.replace(\"SAT\", \"NUA\")\n if self.resample_opts is not None:\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\n **self.resample_opts )\n\n g = gdal.Open( the_mask )\n nua = g.ReadAsArray()\n m2 = np.logical_not ( np.bitwise_and ( nua, 1 ).astype ( np.bool ) )\n return m1 * m2 * m3","def lstm_mask_layer(proj, mask):\n\n return proj * mask[:, :, None]","def apply_mask_image(img: PIL.Image.Image, mask: np.ndarray) -> PIL.Image.Image:\n img_arr = np.array(img)\n\n if mask.ndim == 2 and img_arr.ndim != 2:\n masked_image = np.zeros(img_arr.shape, \"uint8\")\n n_channels = img_arr.shape[2]\n for channel_i in range(n_channels):\n masked_image[:, :, channel_i] = img_arr[:, :, channel_i] * mask\n else:\n masked_image = img_arr * mask\n return np_to_pil(masked_image)","def overlay_mask(img, mask, transparency=0.5):\n im_over = np.ndarray(img.shape)\n im_over[:, :, 0] = (1 - mask[:, :, 0]) * img[:, :, 0] + mask[:, :, 0] * (\n 255 * transparency + (1 - transparency) * img[:, :, 0])\n im_over[:, :, 1] = (1 - mask[:, :, 1]) * img[:, :, 1] + mask[:, :, 1] * (\n 255 * transparency + (1 - transparency) * img[:, :, 1])\n im_over[:, :, 2] = (1 - mask[:, :, 2]) * img[:, :, 2] + mask[:, :, 2] * (\n 255 * transparency + (1 - transparency) * img[:, :, 2])\n return im_over","def get_regions_mask(self, input):","def normalization_mask(img, mask):\n zone1 = img[mask != 0]\n zone2 = img[mask == 0]\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\n imge = img.copy()\n imge[mask != 0] = zone1\n imge[mask == 0] = zone2\n return imge","def unmask_3D(X, mask):\n\n if mask.dtype != np.bool:\n raise ValueError(\"mask must be a boolean array\")\n if X.ndim != 1:\n raise ValueError(\"X must be a 1-dimensional array\")\n\n data = np.zeros(\n (mask.shape[0], mask.shape[1], mask.shape[2]),\n dtype=X.dtype)\n data[mask] = X\n return data","def apply_mask(image, mask, cls2color=cityscapes_cls2color, alpha=0.5):\n masks = []\n for c in range(3):\n mask_copy = mask.copy()\n for k, v in cls2color.items():\n mask_copy[mask == k] = v[c]\n mask_copy = np.expand_dims(mask_copy, 2)\n masks.append(mask_copy)\n mask = np.concatenate(masks, axis=-1)\n if image is not None:\n ret = image*(1-alpha)+alpha*mask/255.0\n else:\n ret = mask/255.0\n\n return ret","def mask(self):\n\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\n\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\n\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\n\n cv2.floodFill(image=mask,\n mask=mask_with_border,\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\n newVal=constants.COLOR_WHITE_MONO)\n\n return mask","def mask(self, mask):\n ds_out = self._obj\n for var in self.vars:\n ds_out[var] = ds_out[var].raster.mask(mask)\n return ds_out","def get_contest_mask():\n return createmaskdf(\"data/fcstrodeo_nctemplates/fcstrodeo_mask.nc\")","def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\n orig_scene = orig.copy()\n mask_scene = mask.copy()\n orig_scene_no_mask = orig.copy()\n \n mask_info = np.where(mask_scene == 0) \n min_x = max(min(mask_info[0]) - local_context_size, 0)\n max_x = max(mask_info[0]) + local_context_size\n min_y = max(min(mask_info[1]) - local_context_size, 0)\n max_y = max(mask_info[1]) + local_context_size\n \n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\n \n dialation_mask = np.zeros(mask_scene.shape) + 255\n \n if dilation:\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\n \n #implot(dialation_mask)\n #plt.imshow(dialation_mask, 'gray')\n \n for x in range(mask_scene.shape[0]):\n for y in range(mask_scene.shape[1]):\n if mask_scene[x, y] == 0:\n orig_scene[x, y, :] = 0\n orig_scene_no_mask[x,y,:] = 0\n if dilation:\n if dialation_mask[x,y] == 0:\n orig_scene[x, y, :] = 0\n \n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask","def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\n # create binary mask\n mask = np.zeros(img_slice.shape)\n mask[min_x:max_x, min_y:max_y] = 1\n # keep a copy of original to have background later \n img_orig = np.copy(img_slice)\n mask_binary = np.copy(mask)\n\n # rotate image if coronal\n if views=='coronal':\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\n mask = np.rot90(mask, axes=(1, 0))\n \n # prepare binary mask for net\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask = torch.Tensor(mask) # gives dtype float32\n mask = mask.unsqueeze(0)\n mask = mask.unsqueeze(0)\n\n # prepare seg mask for net\n mask_slice[mask_slice==self.vertebra_id] = 0\n # resize to network size\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\n\n mask_seg = self.map_vert_to_class(mask_seg)\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n mask_seg = mask_seg.unsqueeze(0)\n\n # prepare img for net \n img_slice = cv2.resize(img_slice, self.resize_size)\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \n img_slice = img_slice[:,:, None]\n img_slice = self.toTensor(img_slice)\n img_slice = img_slice.unsqueeze(0)\n corrupt_img = (1-mask)*img_slice\n\n if self.use_cuda:\n mask = mask.cuda()\n mask_seg = mask_seg.cuda()\n corrupt_img = corrupt_img.cuda() \n\n # inpaint\n if views=='lateral':\n netG = self.netGlat\n elif views=='coronal':\n netG = self.netGcor\n\n # get prediction\n with torch.no_grad():\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\n inpainted_mask = self.softmax(inpainted_mask)\n\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\n\n # set img back to how it was\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\n # set mask back\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\n for i in range(6):\n if views=='coronal':\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\n else:\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\n inpainted_mask = inpainted_mask_resized\n \n if views=='coronal':\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\n\n return inpainted_img, inpainted_mask, mask_binary","def make_inference_attention_mask_3d(source_block, target_block, pad_id):\n # mask = (target_block[:, None, :] != pad_id) * (source_block[:, :, None] != pad_id)\n return make_attention_mask_3d(source_block != pad_id, target_block != pad_id)","def _prepare_mask_file(mask):\n result = np.ndarray((mask.shape[0], mask.shape[1]), dtype=np.uint8)\n for i in range(mask.shape[0]):\n for j in range(mask.shape[1]):\n\n if mask[i][j] > 0:\n result[i][j] = 1\n else:\n result[i][j] = 0\n \n return result","def load_mask_one_layer(self, image_id):\r\n mask_path = self.mask_path[self.ids[image_id]]\r\n file_pattern = os.path.join(mask_path, \"*.png\")\r\n info = self.image_info[image_id]\r\n mask_files = glob.glob(file_pattern)\r\n #mask_tmp = cv2.imread(mask_files[0])\r\n mask_new = np.zeros([info['width'], info['height'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\r\n count = 1\r\n mask_total = 0\r\n for i in mask_files:\r\n mask = cv2.imread(i)\r\n mask = mask[:, :, 1] / 255.0\r\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\r\n mask_new[:, :, count] = (mask)\r\n mask_total = mask_total * (mask == 0)\r\n mask_total = mask_total + (mask>0) * count\r\n count = count + 1\r\n return mask_total","def get_mask(self, shape):\n h, w = shape[0:2]\n y, x = np.mgrid[:h, :w]\n points = np.transpose((x.ravel(), y.ravel()))\n\n mask = _nxutils_points_inside_poly(points, self.verts)\n #mask = nxutils.points_inside_poly(points, self.verts)\n return mask.reshape(h, w)","def __set_mask_regions(self):\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\n [299,719], [100, 550], [640, 425]]]))","def mask(self):\n return self._mask","def mask(self):\n return self._mask","def mask(self):\n return self._mask","def mask(self):\n return self._mask","def preprocess_3d(im_stack):\n im_stack /= 127.5\n im_stack -= 1.0\n return im_stack","def get_binary_mask(self,index):\n mask = self.load_mask_png(index)\n (rows,cols) = np.where(mask>0)[0:2] #pixels in mask disregarding the color\n new_mask = np.zeros(shape=mask.shape[0:2], dtype=np.uint8)\n new_mask[(rows,cols)] = 255\n return new_mask","def dynamic_masking(image):\n image = img_as_float(image)\n background = gaussian_filter(median_filter(image,3),1)\n image[background > threshold_otsu(background)/5.0] = 0.0\n \n return image","def _get_bolean_mask(self, mask):\n if mask.dtype.kind == 'f':\n warnings.warn(\"mask image should be unsigned byte between 0\"\n \" and 255. Got a float array\")\n if mask.ndim == 2:\n boolean_mask = mask == 255\n elif mask.ndim == 3:\n # if all channels are white, mask out\n boolean_mask = np.all(mask[:, :, :3] == 255, axis=-1)\n else:\n raise ValueError(\"Got mask of invalid shape: %s\" % str(mask.shape))\n return boolean_mask","def addMaskImage(img):\r\n [h, w, c] = img.shape\r\n h_start = np.random.randint(h/2,h-1)\r\n w_start = np.random.randint(w/2, w-1)\r\n img[h_start:h-1, :,0]= np.random.randint(0,120)\r\n img[h_start:h-1, :,1]= np.random.randint(0,120) \r\n img[h_start:h-1, :,2]= np.random.randint(0,120) \r\n img[:,w_start:w-1,0]= np.random.randint(0,120)\r\n img[:,w_start:w-1,1]= np.random.randint(0,120) \r\n img[:,w_start:w-1,2]= np.random.randint(0,120) \r\n img = np.uint8(img)\r\n return img, h_start, w_start","def surface_unmasked(res='4x5', trop_limit=False, mask2D=False,\n debug=False):\n # Create a np.ma mask\n m = np.ma.array(np.zeros(get_dims4res(res)), mask=False)\n m[..., 0] = 1\n m = np.ma.masked_not_equal(m, 1)\n\n if trop_limit:\n m = m[..., :38]\n if debug:\n print((mask, mask.shape))\n\n # Return 2D or 3D?\n if mask2D:\n return m[..., 0].mask\n else:\n return m.mask","def _cvt_mask3d_to_mask2d(m, mapper={(1,1,1):1, (2,2,2):2}, default = 0):\n #mapping\n sub_masks = []\n for k,v in mapper.items():\n # check elementwise equal\n sub_masks.append(np.where(np.all(m == k, axis=-1), v, default))\n\n # o = reduce(np.add, sub_masks)\n o = reduce(np.bitwise_or, sub_masks)\n # o = o[:,:,0] # remove redundant channels\n return o","def gen_background_mask( img ):\n\t\t\n\tif len( img.shape ) == 3: t = img[0]\n\telif len( img.shape ) == 2: t = img\n\n\tmask = img > filters.threshold_li(t)\n\n\treturn mask","def as_boolean_mask(self):\n bbox = self.bbox()\n zs = np.unique([c.image_z_position for c in self.contours])\n z_to_index = dict(zip(zs,range(len(zs))))\n\n # Get dimensions, initialize mask.\n nx,ny = np.diff(bbox[:2], axis=1).astype(int) + 1\n nx = int(nx); ny = int(ny)\n nz = int(zs.shape[0])\n mask = np.zeros((nx,ny,nz), dtype=np.bool)\n\n # We check if these points are enclosed within each contour \n # for a given slice. `test_points` is a list of image coordinate \n # points, offset by the bounding box.\n test_points = bbox[:2,0] + np.c_[ np.where(~mask[:,:,0]) ]\n\n # First we \"turn on\" pixels enclosed by inclusion contours.\n for contour in self.contours:\n if contour.inclusion:\n zi = z_to_index[contour.image_z_position]\n contour_matrix = contour.to_matrix()[:,:2]\n\n # Turn the contour closed if it's not.\n if (contour_matrix[0] != contour_matrix[-1]).all():\n contour_matrix = np.append(contour_matrix,\n contour_matrix[0].reshape(1,2),\n axis=0)\n\n # Create path object and test all pixels\n # within the contour's bounding box.\n path = mplpath.Path(contour_matrix, closed=True)\n contains_pts = path.contains_points(test_points)\n mask[:,:,zi] = contains_pts.reshape(mask.shape[:2])\n\n # Second, we \"turn off\" pixels enclosed by exclusion contours.\n for contour in self.contours:\n if not contour.inclusion:\n zi = z_to_index[contour.image_z_position]\n contour_matrix = contour.to_matrix()[:,:2]\n\n # Turn the contour closed if it's not.\n if (contour_matrix[0] != contour_matrix[-1]).all():\n contour_matrix = np.append(contour_matrix,\n contour_matrix[0].reshape(1,2),\n axis=0)\n\n path = mplpath.Path(contour_matrix, closed=True)\n not_contains_pts = ~path.contains_points(test_points)\n not_contains_pts = not_contains_pts.reshape(mask.shape[:2])\n mask[:,:,zi] = np.logical_and(mask[:,:,zi], not_contains_pts)\n\n # The first and second axes have to \n # be swapped because of the reshape.\n return mask.swapaxes(0,1), bbox[[1,0,2]]","def mask(self):\n return self.mask_index","def _draw_mask_on_image(self, mask):\n mask = self.STANDARD_COLORS_ARRAY[mask]\n cv2.addWeighted(mask,self.config.ALPHA,self.image,1.0,0,self.image)","def _mask_grid(self):\n xg, yg = self._build_grid()\n mask = self._build_mask(xg, yg)\n mask = mask.reshape(xg.shape)\n\n return xg, yg, mask","def testMask2D(self):\n mask = np.ones((3, 2), dtype=np.float32)\n inputs = tf.constant(1.0, shape=(1, 5, 2))\n conv1 = snt.Conv1D(\n output_channels=1,\n kernel_shape=3,\n mask=mask,\n padding=snt.VALID,\n use_bias=False,\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\n out = conv1(inputs)\n expected_out = np.reshape(np.array([6, 6, 6]), (1, 3, 1))\n with self.test_session():\n tf.variables_initializer([conv1.w]).run()\n self.assertAllClose(out.eval(), expected_out)","def cfmask_to_mask(raster):\r\n mask = raster.ReadAsArray()\r\n # A value of 0 is clear of clouds/water. Make all other values = 1.\r\n mask[mask != 0] = 1\r\n\r\n # That's it, just return the result...\r\n return mask","def get_pca_mask(self):\n return self.get_pca_images()[1]","def vis_mask(img, mask,width,height, col, alpha=0.4, show_border=True, border_thick= -1):\n\n img = img.astype(np.float32)\n idx = np.nonzero(mask)\n #np.PredictionBoxes(col)\n img[idx[0], idx[1], :] *= 1.0 - alpha\n img[idx[0], idx[1], :] += alpha * (400/255.0)\n\n if show_border:\n _, contours, _ = cv2.findContours(\n mask.copy(), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\n cv2.drawContours(img, contours, -1,col, border_thick, cv2.LINE_AA)\n #cv2.drawContours(c, contours, -1, 1, border_thick, cv2.LINE_AA)\n\n return img.astype(np.uint8)","def read_mask(mask_path, mask_type, mask_name,patch_size,show_image=None):\n path_test = mask_path\n\n mask= Image.open(path_test+\"/\"+\"{}\".format(mask_type)+\n \"/\"+\"{}.tif\".format(mask_name))\n mask_list = np.asarray(list (mask.getdata() ))\n\n mask_list = mask_list / np.amax(mask_list)\n #either use from future or use // to get float result\n mask_list = np.reshape(mask_list,(patch_size,patch_size))\n if (show_image == True):\n\n print(mask_list.shape)\n plt.figure()\n plt.imshow(mask_list,cmap='gray')\n plt.show()\n print(mask_list)\n return mask_list","def process_mask(self, image):\n image = np.array(image)\n image[image == 5] = 1 # set un-classified to undestroyed\n return Image.fromarray(image)","def cube_fix_badpix_isolated(array, bpm_mask=None, sigma_clip=3, num_neig=5, \n size=5, frame_by_frame=False, protect_mask=0, \n cxy=None, mad=False, ignore_nan=True, verbose=True, \n full_output=False):\n if array.ndim != 3:\n raise TypeError('Array is not a 3d array or cube')\n if size % 2 == 0:\n raise TypeError('Size of the median blur kernel must be an odd integer')\n \n if bpm_mask is not None:\n bpm_mask = bpm_mask.astype('bool')\n \n if verbose: start = time_ini()\n \n if num_neig > 0:\n neigh = True\n else:\n neigh = False\n \n nz = array.shape[0]\n \n if cxy is None:\n cy, cx = frame_center(array[0])\n elif isinstance(cxy, tuple):\n cx, cy = cxy\n elif isinstance(cxy, np.ndarray):\n if cxy.shape[0] != nz or cxy.shape[1] != 2 or cxy.ndim != 2:\n raise ValueError(\"cxy does not have right shape\")\n elif not frame_by_frame:\n msg = \"cxy must be a tuple or None if not in frame_by_frame mode\"\n raise ValueError(msg)\n else:\n cx = cxy[:,0]\n cy = cxy[:,1]\n\n \n array_out = array.copy()\n final_bpm = np.zeros_like(array_out, dtype=bool)\n n_frames = array.shape[0]\n count_bp = 0\n if frame_by_frame:\n if np.isscalar(cx):\n cx = [cx]*nz\n cy = [cy]*nz\n if bpm_mask is not None:\n if bpm_mask.ndim == 2:\n bpm_mask = [bpm_mask]*n_frames\n bpm_mask = np.array(bpm_mask)\n for i in Progressbar(range(n_frames), desc=\"processing frames\"):\n if bpm_mask is not None:\n bpm_mask_tmp = bpm_mask[i]\n else:\n bpm_mask_tmp = None\n res = frame_fix_badpix_isolated(array[i], bpm_mask=bpm_mask_tmp, \n sigma_clip=sigma_clip,\n num_neig=num_neig, size=size, \n protect_mask=protect_mask, \n verbose=False, cxy=(cx[i],cy[i]), \n ignore_nan=ignore_nan,\n full_output=True)\n array_out[i] = res[0]\n final_bpm[i] = res[1] \n count_bp = np.sum(final_bpm) \n else: \n if bpm_mask is None:\n ori_nan_mask = np.where(np.isnan(np.nanmean(array, axis=0)))\n ind = clip_array(np.nanmean(array, axis=0), sigma_clip, sigma_clip,\n neighbor=neigh, num_neighbor=num_neig, mad=mad)\n final_bpm = np.zeros_like(array[0], dtype=bool)\n final_bpm[ind] = 1\n if ignore_nan:\n final_bpm[ori_nan_mask] = 0\n if protect_mask:\n cir = disk((cy, cx), protect_mask, shape=final_bpm.shape)\n final_bpm[cir] = 0\n final_bpm = final_bpm.astype('bool')\n else:\n if bpm_mask.ndim == 3:\n final_bpm = np.median(bpm_mask, axis=0)\n else:\n final_bpm = bpm_mask.copy()\n \n for i in Progressbar(range(n_frames), desc=\"processing frames\"):\n frame = array_out[i]\n smoothed = median_filter(frame, size, mode='mirror')\n frame[np.where(final_bpm)] = smoothed[np.where(final_bpm)]\n if verbose: \n count_bp += np.sum(final_bpm)\n \n if verbose: \n msg = \"Done replacing {:.0f} bad pixels using the median of neighbors\"\n print(msg.format(count_bp))\n if not frame_by_frame:\n msg = \"(i.e. {:.0f} static bad pixels per channel))\"\n print(msg.format(count_bp/n_frames)) \n timing(start)\n \n if full_output:\n return array_out, final_bpm\n else:\n return array_out","def bbox_3D(img):\n\tr = np.any(img, axis=(1, 2))\n\tc = np.any(img, axis=(0, 2))\n\tz = np.any(img, axis=(0, 1))\n\n\trmin, rmax = np.where(r)[0][[0, -1]]\n\tcmin, cmax = np.where(c)[0][[0, -1]]\n\tzmin, zmax = np.where(z)[0][[0, -1]]\n\n\treturn rmin, rmax, cmin, cmax, zmin, zmax","def test_make_mask(self):\n output_mask = footprint_mask(os.path.join(data_dir, 'sample.csv'),\n geom_col=\"PolygonWKT_Pix\")\n truth_mask = skimage.io.imread(os.path.join(data_dir,\n 'sample_fp_mask.tif'))\n\n assert np.array_equal(output_mask, truth_mask)","def setMask(self, mask):\n try:\n self.mask = mask\n self.inds = na.nonzero(self.mask.flat)[0]\n #print \"length of self.inds\",len(self.inds)\n #print self.inds\n self.dim = self.mask.shape[::-1]\n #print self.mask.shape\n return True\n except Exception as error:\n print(\"failed in setMask\", error)","def get_hitmask(image_alpha):\n mask = []\n for x in range(image_alpha.get_width()):\n mask.append([])\n for y in range(image_alpha.get_height()):\n mask[x].append(bool(image_alpha.get_at((x, y))[3]))\n return mask","def apply_mask(im, mask, color=(1, 0, 0)):\n masked = np.zeros(im.shape)\n for x, y in mask: masked[x][y] = color\n return masked","def load_mask_pre(self, image_id, mask_path):\n img = Image.open(mask_path)\n colors = img.getcolors()\n n_dim = np.shape(colors)\n num_obj = n_dim[0]-1 #not include the background\n\n mask = np.zeros([np.shape(img)[0], np.shape(img)[1], num_obj], dtype=np.uint8)\n mask = self.draw_mask(num_obj, mask, img, colors)\n\n # Map class names to class IDs.\n class_ids = []\n for i in range(num_obj):\n class_ids.append(colors[i+1][1])\n\n return mask.astype(np.bool), np.array(class_ids, dtype=np.int32) #mask.astype(np.bool)"],"string":"[\n \"def get_mask(self):\\n\\t\\treturn pygame.mask.from_surface(self.img)\",\n \"def getHitmask(self,image):\\n\\t\\tmask = []\\n\\t\\tfor x in range(image.get_width()):\\n\\t\\t\\tmask.append([])\\n\\t\\t\\tfor y in range(image.get_height()):\\n\\t\\t\\t\\tmask[x].append(bool(image.get_at((x,y))[3]))\\n\\t\\treturn mask\",\n \"def get_mask(self, img):\\n raise NotImplementedError()\",\n \"def _mask3d(self, n, i, window):\\n\\n n = np.array(n)\\n i = np.array(i)\\n\\n w2 = (window - 1) // 2\\n\\n x1, y1, z1 = np.clip(i - w2, 0 * n, n)\\n x2, y2, z2 = np.clip(i + w2 + 1, 0 * n, n)\\n\\n mask = np.zeros(n, dtype=np.bool)\\n mask[x1:x2, y1:y2, z1:z2] = True\\n\\n return mask\",\n \"def testMask2D(self):\\n mask = np.ones((3, 3), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\\n conv1 = snt.Conv3D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def testMask3D(self):\\n mask = np.ones((3, 3, 2), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\\n conv1 = snt.Conv2D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 18 * np.ones((1, 3, 3, 1))\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def make_attention_mask_3d(source_mask, target_mask):\\n mask = target_mask[:, None, :] * source_mask[:, :, None]\\n return mask\",\n \"def testMask3D(self):\\n mask = np.ones((3, 3, 3), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\\n conv1 = snt.Conv3D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def getHitmask(image):\\n mask = []\\n for x in range(image.get_width()):\\n mask.append([])\\n for y in range(image.get_height()):\\n mask[x].append(bool(image.get_at((x,y))[3]))\\n return mask\",\n \"def mask_image(image):\\n pass\",\n \"def GetMaskImage(self) -> \\\"itkImageF3 const *\\\":\\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIF3_GetMaskImage(self)\",\n \"def testMask3D(self):\\n mask = np.ones((3, 2, 1), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(1, 5, 2))\\n conv1 = snt.Conv1D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = np.reshape(np.array([6, 6, 6]), (1, 3, 1))\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def prepareMask(self, mask):\\n\\n # Make sure that the mask has the same\\n # number of voxels as the atlas image.\\n # Use nearest neighbour interpolation\\n # for resampling, as it is most likely\\n # that the mask is binary.\\n try:\\n mask, xform = resample.resample(\\n mask, self.shape[:3], dtype=np.float32, order=0)\\n\\n except ValueError:\\n raise MaskError('Mask has wrong number of dimensions')\\n\\n # TODO allow non-aligned mask - as long as it overlaps\\n # in world coordinates, it should be allowed\\n if not fslimage.Image(mask, xform=xform).sameSpace(self):\\n raise MaskError('Mask is not in the same space as atlas')\\n\\n return mask\",\n \"def build3D(imMask, imInout, grid=m3D.DEFAULT_GRID3D):\\r\\n \\r\\n if imInout.getDepth()==1:\\r\\n _build3D_1(imMask, imInout, grid)\\r\\n elif imInout.getDepth()==8:\\r\\n _build3D_8(imMask, imInout, grid)\\r\\n else:\\r\\n _build3D_32(imMask, imInout, grid)\",\n \"def GetMaskImage(self) -> \\\"itkImageSS3 const *\\\":\\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterISS3_GetMaskImage(self)\",\n \"def testMask2D(self):\\n\\n # This mask, applied on an image filled with 1, should result in an image\\n # filled with 8 (since we sum 4 elements per channel and there are 2 input\\n # channels).\\n mask = np.array([[1, 1, 1],\\n [1, 0, 0],\\n [0, 0, 0]], dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\\n conv1 = snt.Conv2D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = np.array([[8] * 3] * 3)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(np.reshape(out.eval(), [3, 3]), expected_out)\",\n \"def calcmask(self, *args, **kwargs):\\n return _image.image_calcmask(self, *args, **kwargs)\",\n \"def GetMaskImage(self) -> \\\"itkImageUC3 const *\\\":\\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUC3_GetMaskImage(self)\",\n \"def GetMaskImage(self) -> \\\"itkImageUS3 const *\\\":\\n return _itkScalarImageToRunLengthFeaturesFilterPython.itkScalarImageToRunLengthFeaturesFilterIUS3_GetMaskImage(self)\",\n \"def show_mask(image, mask): \\n plt.subplot(1,2,1)\\n plt.title('image')\\n plt.imshow(image)\\n plt.subplot(1,2,2)\\n plt.title('mask')\\n plt.imshow(mask)\\n plt.show()\",\n \"def apply_mask(components):\\n img = components[10]\\n mask = components[11]\\n if mask is not None:\\n img[:, :, 0] = img[:, :, 0] * mask\\n img[:, :, 1] = img[:, :, 1] * mask\\n img[:, :, 2] = img[:, :, 2] * mask\\n img[img == 0] = 128\\n return components\",\n \"def test(shape=(1000,2000)):\\n mask = Mask()\\n mask.addCircle(400,300,250)\\n mask.subtractCircle(400,300,150)\\n mask.addRectangle(350,250,1500,700)\\n plt.imshow( mask.getMask(shape) )\\n return mask\",\n \"def mask_img(img, mask):\\n masked_img = np.zeros(img.shape)\\n masked_img[mask] = img[mask]\\n return masked_img\",\n \"def mask(self):\",\n \"def _get_mask(self, anno, idx):\\n coco = self.coco\\n img_info = coco.loadImgs(self.img_ids[idx])[0]\\n\\n m = np.zeros((img_info['height'], img_info['width']), dtype=np.float32)\\n\\n for obj in anno:\\n if 'segmentation' in obj:\\n if obj['iscrowd']:\\n rle = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n m += pycocotools.mask.decode(rle)\\n elif obj['num_keypoints'] == 0:\\n rles = pycocotools.mask.frPyObjects(obj['segmentation'],\\n img_info['height'],\\n img_info['width'])\\n for rle in rles:\\n m += pycocotools.mask.decode(rle)\\n\\n return m < 0.5\",\n \"def __mask(input, mask):\\n return cv2.bitwise_and(input, input, mask=mask)\",\n \"def extract_object(image, mask):\\r\\n\\r\\n\\tassert image.ndim == 3 and image.shape[2] == 3 and image.shape[:2] == mask.shape[:2]\\r\\n\\r\\n\\tif mask.ndim == 2:\\r\\n\\t\\t## expand dimension so that the array is 3-d\\r\\n\\t\\tmask = np.expand_dims(mask, axis = -1)\\r\\n\\t\\toutput = np.multiply(image, mask).astype(np.uint8)\\r\\n\\telse:\\r\\n\\r\\n\\t\\t## **there may be faster way to perform this operation\\r\\n\\t\\tmask = np.expand_dims(mask, axis = 2)\\r\\n\\r\\n\\t\\toutput = 0\\r\\n\\t\\tfor i in range(mask.shape[-1]):\\r\\n\\t\\t\\toutput += np.multiply(image, mask[:, :, :, i])\\r\\n\\r\\n\\t\\toutput = output.astype(np.uint8)\\r\\n\\r\\n\\r\\n\\treturn output\",\n \"def build_attention_mask_3d_padding(source_mask, target_mask):\\n mask = make_attention_mask_3d(source_mask, target_mask)\\n # invert mask for Megatron\\n return mask < 0.5\",\n \"def testMask4D(self):\\n mask = np.ones((3, 3, 3, 5), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\\n conv1 = snt.Conv3D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def apply_mask_to_image(image, mask, return_as_image=True):\\n (n,m,k) = np.shape(image)\\n image = np.reshape(image, (n*m, k))\\n mask = np.ravel(mask)\\n\\n if return_as_image:\\n image[np.invert(mask), :] = 0\\n image = np.reshape(image, (n,m,k))\\n else:\\n image = image[mask, :]\\n return image\",\n \"def overlay(image, mask):\\n if len(image.shape) == 3:\\n image = image[:, :, 0]\\n if len(mask.shape) == 3:\\n mask = mask[:, :, 0]\\n if np.amax(image) > 100:\\n image = image / 255\\n\\n masked = np.ma.masked_where(mask == 0, mask)\\n\\n plt.figure()\\n plt.subplot(1, 2, 1)\\n plt.imshow(image, 'gray', interpolation='nearest')\\n plt.subplot(1, 2, 2)\\n plt.imshow(image, 'gray', interpolation='nearest')\\n plt.imshow(masked, 'jet', interpolation='nearest', alpha=0.5)\\n plt.show()\",\n \"def _get_mask_volume(mask_img):\\n affine = mask_img.affine\\n prod_vox_dims = 1.0 * np.abs(np.linalg.det(affine[:3, :3]))\\n return prod_vox_dims * _get_data(mask_img).astype(bool).sum()\",\n \"def __call__(self, image: np.ndarray) -> np.ndarray:\\n # convert PIL image to numpy array\\n image = np.asarray(image)\\n\\n # get masks, all pixels\\n np_mask = np.array(np.ones(image.shape[0:2]), dtype=bool)\\n\\n return np_mask\",\n \"def make_niimage_3d(map, mask, affine, zscore=False):\\n\\tV = map.size\\n\\tnx, ny, nz = mask.shape\\n\\tassert(V == mask.sum())\\n\\tmask = mask == True\\n\\n\\tif zscore:\\n\\t\\tmap = (map - map.mean()) / map.var()\\n\\n\\tdata = np.zeros((nx, ny, nz))\\n\\tdata[mask] = map \\n\\n\\tnifti_image = nib.Nifti1Image(data, affine)\\n\\treturn nifti_image\",\n \"def get_mask(self, anno, img_info) -> np.ndarray:\\n m = np.zeros((img_info[\\\"height\\\"], img_info[\\\"width\\\"]), dtype=np.float32)\\n\\n for obj in anno:\\n if obj[\\\"iscrowd\\\"]:\\n rle = pycocotools.mask.frPyObjects(obj[\\\"segmentation\\\"], img_info[\\\"height\\\"], img_info[\\\"width\\\"])\\n mask = pycocotools.mask.decode(rle)\\n if mask.shape != m.shape:\\n logger.warning(f\\\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\\\")\\n continue\\n m += mask\\n elif obj[\\\"num_keypoints\\\"] == 0:\\n rles = pycocotools.mask.frPyObjects(obj[\\\"segmentation\\\"], img_info[\\\"height\\\"], img_info[\\\"width\\\"])\\n for rle in rles:\\n mask = pycocotools.mask.decode(rle)\\n if mask.shape != m.shape:\\n logger.warning(f\\\"Mask shape {mask.shape} does not match image shape {m.shape} for image {img_info['file_name']}\\\")\\n continue\\n\\n m += mask\\n\\n return (m < 0.5).astype(np.float32)\",\n \"def layer_masks(self, module):\\n pass\\n # return masks\",\n \"def load_mask(self, image_id):\\n image_info = self.image_info[image_id]\\n if image_info[\\\"source\\\"] != \\\"face\\\":\\n return super(self.__class__, self).load_mask(image_id)\\n info = self.image_info[image_id]\\n mask = np.zeros([info['height'], info['width'], len(info['boundingbox'])], dtype=np.uint8)\\n for i, p in enumerate(info['boundingbox'].values()):\\n rr, cc = skimage.draw.polygon(p['y'], p['x'])\\n mask[rr, cc, i] = 1\\n return mask, np.ones([mask.shape[-1]], dtype=np.int32)\",\n \"def get_pred_mask(test_image, model):\\n\\n test_image= test_image=transforms.ToPILImage()(test_image)\\n #test_image=Image.fromarray(test_image)\\n new_mask = model(transforms.ToTensor()(test_image).unsqueeze(1).cuda())[1].transpose(1,2).transpose(2,3).cpu().detach().numpy().squeeze()\\n return new_mask\",\n \"def inflate_mask(mask):\\n kernel = np.ones((12, 12), np.uint8)\\n return cv2.dilate(mask, kernel, 1)\",\n \"def testMask4D(self):\\n\\n # This mask, applied on an image filled with 1, should result in an image\\n # filled with 17, as there are 18 weights but we zero out one of them.\\n mask = np.ones([3, 3, 2, 1], dtype=np.float32)\\n mask[0, 0, 0, :] = 0\\n inputs = tf.constant(1.0, shape=(1, 5, 5, 2))\\n conv1 = snt.Conv2D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = np.array([[17] * 3] * 3)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(np.reshape(out.eval(), [3, 3]), expected_out)\",\n \"def generate_inpaint_mask(n_samples, n_colors, spatial_width):\\n mask = np.zeros((n_samples, n_colors, spatial_width, spatial_width), dtype=bool)\\n # simple mask -- just mask out half the image\\n mask[:,:,:,spatial_width/2:] = True\\n return mask.ravel()\",\n \"def dualBuild3D(imMask, imInout, grid=m3D.DEFAULT_GRID3D):\\r\\n \\r\\n if imInout.getDepth()==1:\\r\\n _dualBuild3D_1(imMask, imInout, grid)\\r\\n elif imInout.getDepth()==8:\\r\\n _dualBuild3D_8(imMask, imInout, grid)\\r\\n else:\\r\\n _dualBuild3D_32(imMask, imInout, grid)\",\n \"def get_mask(self, image):\\n mask = self.get_gradients(image)\\n return mask\",\n \"def testMask5D(self):\\n mask = np.ones((3, 3, 3, 5, 1), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\\n conv1 = snt.Conv3D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 135 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def embed(im, mask, clipfloor=0., randomfloor=False):\\n j=0\\n out=np.zeros(len(mask))\\n for i in range(len(mask)):\\n if mask[i]:\\n out[i] = im[j]\\n j += 1\\n else:\\n # prevent total variation gradient singularities\\n if randomfloor: out[i] = clipfloor * np.random.normal()\\n else: out[i] = clipfloor\\n\\n return out\",\n \"def build_attention_mask_3d(source_mask, target_mask, attn_mask_type):\\n if attn_mask_type == AttnMaskType.padding:\\n mask = build_attention_mask_3d_padding(source_mask, target_mask)\\n elif attn_mask_type == AttnMaskType.causal:\\n mask = build_attention_mask_3d_causal(source_mask, target_mask)\\n else:\\n raise ValueError(f\\\"Unsupported attention mask attn_mask_type = {attn_mask_type}\\\")\\n\\n return mask\",\n \"def get_mask(self):\\n w, h = self.rect.w, self.rect.h\\n colorkey = (0, 0, 0)\\n surface = pg.Surface((w, h))\\n surface.set_colorkey(colorkey)\\n # fill the surface with the spherical object\\n color, center, radius = (255, 255, 255), self.rect.center, round(self.rect.w/2)\\n pg.draw.circle(surface, color, center, radius)\\n mask = pg.mask.from_surface(surface)\\n return mask\",\n \"def _mask(self):\\n if self.__mask is None:\\n # need this to be *exactly* the numpy boolean False\\n return nomask\\n return self.__mask\",\n \"def testMask1D(self):\\n mask = 0.5 * np.ones((3,), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(5, 5, 5, 5, 5))\\n conv1 = snt.Conv3D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = 67.5 * np.ones((5, 3, 3, 3, 1), dtype=np.float32)\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def load_mask(path, image, mask_name='module_unet', center=True):\\n with open(path, 'r') as file:\\n data = json.load(file)\\n # if len(data[\\\"objects\\\"]) == 0:\\n # return None\\n # code = data[\\\"objects\\\"][0][\\\"bitmap\\\"][\\\"data\\\"]\\n # origin = data[\\\"objects\\\"][0][\\\"bitmap\\\"][\\\"origin\\\"]\\n # else:\\n # flag = True\\n # for obj in data[\\\"objects\\\"]:\\n # if obj['classTitle'] == mask_name:\\n inx = has_mask(mask_name, data=data)\\n if inx is not False:\\n obj = data[\\\"objects\\\"][inx]\\n code = obj[\\\"bitmap\\\"][\\\"data\\\"]\\n origin = obj[\\\"bitmap\\\"][\\\"origin\\\"]\\n else:\\n mask = np.zeros((image.shape[0], image.shape[1]))\\n mask = mask.astype('uint8')\\n mask_center = np.array([mask.shape[1]/2, mask.shape[0]/2])\\n if center:\\n return mask, mask_center\\n else:\\n return mask\\n mask = base64_2_mask(code)\\n mask_center = np.array([mask.shape[1]/2, mask.shape[0]/2])\\n mask_center += origin\\n\\n up = np.zeros((origin[1], mask.shape[1]))\\n mask2 = np.vstack((up, mask))\\n left = np.zeros((mask2.shape[0], origin[0]))\\n mask3 = np.hstack((left, mask2))\\n down = np.zeros((image.shape[0] - mask3.shape[0], mask3.shape[1]))\\n mask4 = np.vstack((mask3, down))\\n right = np.zeros((mask4.shape[0], image.shape[1] - mask4.shape[1]))\\n mask5 = np.hstack((mask4, right))\\n\\n if center:\\n return mask5.astype('uint8'), mask_center.astype(int)\\n else:\\n return mask5.astype('uint8')\",\n \"def get_mask ( self, iloc ):\\n mask = self._mask[iloc]\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n sat = g.ReadAsArray()\\n m3 = sat == 0\\n\\n the_mask = mask.replace(\\\"SAT\\\", \\\"DIV\\\")\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n div = g.ReadAsArray()\\n m1 = div == 0\\n\\n the_mask = mask.replace(\\\"SAT\\\", \\\"NUA\\\")\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n nua = g.ReadAsArray()\\n m2 = np.logical_not ( np.bitwise_and ( nua, 1 ).astype ( np.bool ) )\\n return m1 * m2 * m3\",\n \"def get_mask ( self, iloc ):\\n mask = self._mask[iloc]\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n sat = g.ReadAsArray()\\n m3 = sat == 0\\n\\n the_mask = mask.replace(\\\"SAT\\\", \\\"DIV\\\")\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n div = g.ReadAsArray()\\n m1 = div == 0\\n\\n the_mask = mask.replace(\\\"SAT\\\", \\\"NUA\\\")\\n if self.resample_opts is not None:\\n the_mask = reproject_cut ( os.path.join ( self.datadir, the_mask ),\\n **self.resample_opts )\\n\\n g = gdal.Open( the_mask )\\n nua = g.ReadAsArray()\\n m2 = np.logical_not ( np.bitwise_and ( nua, 1 ).astype ( np.bool ) )\\n return m1 * m2 * m3\",\n \"def lstm_mask_layer(proj, mask):\\n\\n return proj * mask[:, :, None]\",\n \"def apply_mask_image(img: PIL.Image.Image, mask: np.ndarray) -> PIL.Image.Image:\\n img_arr = np.array(img)\\n\\n if mask.ndim == 2 and img_arr.ndim != 2:\\n masked_image = np.zeros(img_arr.shape, \\\"uint8\\\")\\n n_channels = img_arr.shape[2]\\n for channel_i in range(n_channels):\\n masked_image[:, :, channel_i] = img_arr[:, :, channel_i] * mask\\n else:\\n masked_image = img_arr * mask\\n return np_to_pil(masked_image)\",\n \"def overlay_mask(img, mask, transparency=0.5):\\n im_over = np.ndarray(img.shape)\\n im_over[:, :, 0] = (1 - mask[:, :, 0]) * img[:, :, 0] + mask[:, :, 0] * (\\n 255 * transparency + (1 - transparency) * img[:, :, 0])\\n im_over[:, :, 1] = (1 - mask[:, :, 1]) * img[:, :, 1] + mask[:, :, 1] * (\\n 255 * transparency + (1 - transparency) * img[:, :, 1])\\n im_over[:, :, 2] = (1 - mask[:, :, 2]) * img[:, :, 2] + mask[:, :, 2] * (\\n 255 * transparency + (1 - transparency) * img[:, :, 2])\\n return im_over\",\n \"def get_regions_mask(self, input):\",\n \"def normalization_mask(img, mask):\\n zone1 = img[mask != 0]\\n zone2 = img[mask == 0]\\n zone1 = (zone1 - zone1.min()) / (zone1.max() - zone1.min())\\n zone2 = (zone2 - zone2.min()) / (zone2.max() - zone2.min())\\n imge = img.copy()\\n imge[mask != 0] = zone1\\n imge[mask == 0] = zone2\\n return imge\",\n \"def unmask_3D(X, mask):\\n\\n if mask.dtype != np.bool:\\n raise ValueError(\\\"mask must be a boolean array\\\")\\n if X.ndim != 1:\\n raise ValueError(\\\"X must be a 1-dimensional array\\\")\\n\\n data = np.zeros(\\n (mask.shape[0], mask.shape[1], mask.shape[2]),\\n dtype=X.dtype)\\n data[mask] = X\\n return data\",\n \"def apply_mask(image, mask, cls2color=cityscapes_cls2color, alpha=0.5):\\n masks = []\\n for c in range(3):\\n mask_copy = mask.copy()\\n for k, v in cls2color.items():\\n mask_copy[mask == k] = v[c]\\n mask_copy = np.expand_dims(mask_copy, 2)\\n masks.append(mask_copy)\\n mask = np.concatenate(masks, axis=-1)\\n if image is not None:\\n ret = image*(1-alpha)+alpha*mask/255.0\\n else:\\n ret = mask/255.0\\n\\n return ret\",\n \"def mask(self):\\n\\n mask = np.zeros(shape=(self._info.height, self._info.width), dtype=np.uint8)\\n\\n self.draw(image=mask, color=constants.COLOR_WHITE_MONO)\\n\\n mask_with_border = np.pad(mask, 1, 'constant', constant_values=255)\\n\\n cv2.floodFill(image=mask,\\n mask=mask_with_border,\\n seedPoint=(int(self.middle_point[0]), int(self.middle_point[1])),\\n newVal=constants.COLOR_WHITE_MONO)\\n\\n return mask\",\n \"def mask(self, mask):\\n ds_out = self._obj\\n for var in self.vars:\\n ds_out[var] = ds_out[var].raster.mask(mask)\\n return ds_out\",\n \"def get_contest_mask():\\n return createmaskdf(\\\"data/fcstrodeo_nctemplates/fcstrodeo_mask.nc\\\")\",\n \"def get_masked_scene(orig, mask, local_context_size = 80, dilation=False):\\n orig_scene = orig.copy()\\n mask_scene = mask.copy()\\n orig_scene_no_mask = orig.copy()\\n \\n mask_info = np.where(mask_scene == 0) \\n min_x = max(min(mask_info[0]) - local_context_size, 0)\\n max_x = max(mask_info[0]) + local_context_size\\n min_y = max(min(mask_info[1]) - local_context_size, 0)\\n max_y = max(mask_info[1]) + local_context_size\\n \\n orig_scene = orig_scene[min_x:max_x,min_y:max_y]\\n orig_scene_no_mask = orig_scene_no_mask[min_x:max_x,min_y:max_y]\\n mask_scene = mask_scene[min_x:max_x,min_y:max_y]\\n \\n dialation_mask = np.zeros(mask_scene.shape) + 255\\n \\n if dilation:\\n dialation_mask = cv2.dilate(255-mask_scene, np.ones((local_context_size,local_context_size)))\\n \\n #implot(dialation_mask)\\n #plt.imshow(dialation_mask, 'gray')\\n \\n for x in range(mask_scene.shape[0]):\\n for y in range(mask_scene.shape[1]):\\n if mask_scene[x, y] == 0:\\n orig_scene[x, y, :] = 0\\n orig_scene_no_mask[x,y,:] = 0\\n if dilation:\\n if dialation_mask[x,y] == 0:\\n orig_scene[x, y, :] = 0\\n \\n return orig_scene, mask_scene, orig_scene_no_mask, dialation_mask\",\n \"def inpaint(self, img_slice, mask_slice, min_x, max_x, min_y, max_y, views='lateral'):\\n # create binary mask\\n mask = np.zeros(img_slice.shape)\\n mask[min_x:max_x, min_y:max_y] = 1\\n # keep a copy of original to have background later \\n img_orig = np.copy(img_slice)\\n mask_binary = np.copy(mask)\\n\\n # rotate image if coronal\\n if views=='coronal':\\n img_slice = np.rot90(img_slice, axes=(1, 0)) # image is from lat,ax -> ax,lat\\n mask_slice = np.rot90(mask_slice, axes=(1, 0))\\n mask = np.rot90(mask, axes=(1, 0))\\n \\n # prepare binary mask for net\\n mask = cv2.resize(mask, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask = torch.Tensor(mask) # gives dtype float32\\n mask = mask.unsqueeze(0)\\n mask = mask.unsqueeze(0)\\n\\n # prepare seg mask for net\\n mask_slice[mask_slice==self.vertebra_id] = 0\\n # resize to network size\\n mask_seg = cv2.resize(mask_slice, self.resize_size, interpolation=cv2.INTER_NEAREST)\\n mask_seg = np.uint8(np.round(mask_seg)) # just to be sure\\n\\n mask_seg = self.map_vert_to_class(mask_seg)\\n mask_seg = torch.Tensor(mask_seg) # gives dtype float32\\n mask_seg_one_hot = torch.nn.functional.one_hot(mask_seg.long(), num_classes=6)\\n mask_seg_one_hot = mask_seg_one_hot.permute(2,0,1)\\n mask_seg_one_hot = mask_seg_one_hot.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n mask_seg = mask_seg.unsqueeze(0)\\n\\n # prepare img for net \\n img_slice = cv2.resize(img_slice, self.resize_size)\\n img_slice = np.clip(img_slice, -1024, 3071) # clip to HU units\\n img_slice = np.uint8(255*(img_slice+1024)/4095) # normalize to range 0-255 \\n img_slice = img_slice[:,:, None]\\n img_slice = self.toTensor(img_slice)\\n img_slice = img_slice.unsqueeze(0)\\n corrupt_img = (1-mask)*img_slice\\n\\n if self.use_cuda:\\n mask = mask.cuda()\\n mask_seg = mask_seg.cuda()\\n corrupt_img = corrupt_img.cuda() \\n\\n # inpaint\\n if views=='lateral':\\n netG = self.netGlat\\n elif views=='coronal':\\n netG = self.netGcor\\n\\n # get prediction\\n with torch.no_grad():\\n _, inpainted_mask, inpainted_img = netG(corrupt_img, mask_seg, mask)\\n inpainted_mask = self.softmax(inpainted_mask)\\n\\n #inpainted_mask = torch.argmax(inpainted_mask, dim=1)\\n inpainted_img = inpainted_img * mask + corrupt_img * (1. - mask)\\n inpainted_mask = inpainted_mask * mask + mask_seg_one_hot * (1. - mask)\\n #inpainted_mask = self.map_class_to_vert(inpainted_mask)\\n\\n # set img back to how it was\\n inpainted_img = inpainted_img.squeeze().detach().cpu().numpy()\\n inpainted_img = (inpainted_img)*4095 - 1024 # normalize back to HU units \\n inpainted_img = cv2.resize(inpainted_img, (self.orig_ax_length, self.orig_ax_length))\\n # set mask back\\n inpainted_mask = inpainted_mask.squeeze().detach().cpu().numpy()\\n inpainted_mask_resized = np.zeros((6, self.orig_ax_length, self.orig_ax_length))\\n for i in range(6):\\n if views=='coronal':\\n inpainted_mask_resized[i,:,:] = np.rot90(cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length))) #, interpolation=cv2.INTER_NEAREST)\\n else:\\n inpainted_mask_resized[i,:,:] = cv2.resize(inpainted_mask[i,:,:], (self.orig_ax_length, self.orig_ax_length)) #, interpolation=cv2.INTER_NEAREST)\\n inpainted_mask = inpainted_mask_resized\\n \\n if views=='coronal':\\n inpainted_img = np.rot90(inpainted_img) #, axes=(1, 0))\\n\\n return inpainted_img, inpainted_mask, mask_binary\",\n \"def make_inference_attention_mask_3d(source_block, target_block, pad_id):\\n # mask = (target_block[:, None, :] != pad_id) * (source_block[:, :, None] != pad_id)\\n return make_attention_mask_3d(source_block != pad_id, target_block != pad_id)\",\n \"def _prepare_mask_file(mask):\\n result = np.ndarray((mask.shape[0], mask.shape[1]), dtype=np.uint8)\\n for i in range(mask.shape[0]):\\n for j in range(mask.shape[1]):\\n\\n if mask[i][j] > 0:\\n result[i][j] = 1\\n else:\\n result[i][j] = 0\\n \\n return result\",\n \"def load_mask_one_layer(self, image_id):\\r\\n mask_path = self.mask_path[self.ids[image_id]]\\r\\n file_pattern = os.path.join(mask_path, \\\"*.png\\\")\\r\\n info = self.image_info[image_id]\\r\\n mask_files = glob.glob(file_pattern)\\r\\n #mask_tmp = cv2.imread(mask_files[0])\\r\\n mask_new = np.zeros([info['width'], info['height'], mask_files.__len__()+1], dtype=np.uint8) # one more for background\\r\\n count = 1\\r\\n mask_total = 0\\r\\n for i in mask_files:\\r\\n mask = cv2.imread(i)\\r\\n mask = mask[:, :, 1] / 255.0\\r\\n #mask = ski_transform.resize(mask, (info['height'], info['width']), mode='reflect')\\r\\n mask_new[:, :, count] = (mask)\\r\\n mask_total = mask_total * (mask == 0)\\r\\n mask_total = mask_total + (mask>0) * count\\r\\n count = count + 1\\r\\n return mask_total\",\n \"def get_mask(self, shape):\\n h, w = shape[0:2]\\n y, x = np.mgrid[:h, :w]\\n points = np.transpose((x.ravel(), y.ravel()))\\n\\n mask = _nxutils_points_inside_poly(points, self.verts)\\n #mask = nxutils.points_inside_poly(points, self.verts)\\n return mask.reshape(h, w)\",\n \"def __set_mask_regions(self):\\n self.bottom_clip = np.int32(np.int32([[[60,0], [1179,0], [1179,650], [60,650]]]))\\n self.roi_clip = np.int32(np.int32([[[640, 425], [1179,550], [979,719],\\n [299,719], [100, 550], [640, 425]]]))\",\n \"def mask(self):\\n return self._mask\",\n \"def mask(self):\\n return self._mask\",\n \"def mask(self):\\n return self._mask\",\n \"def mask(self):\\n return self._mask\",\n \"def preprocess_3d(im_stack):\\n im_stack /= 127.5\\n im_stack -= 1.0\\n return im_stack\",\n \"def get_binary_mask(self,index):\\n mask = self.load_mask_png(index)\\n (rows,cols) = np.where(mask>0)[0:2] #pixels in mask disregarding the color\\n new_mask = np.zeros(shape=mask.shape[0:2], dtype=np.uint8)\\n new_mask[(rows,cols)] = 255\\n return new_mask\",\n \"def dynamic_masking(image):\\n image = img_as_float(image)\\n background = gaussian_filter(median_filter(image,3),1)\\n image[background > threshold_otsu(background)/5.0] = 0.0\\n \\n return image\",\n \"def _get_bolean_mask(self, mask):\\n if mask.dtype.kind == 'f':\\n warnings.warn(\\\"mask image should be unsigned byte between 0\\\"\\n \\\" and 255. Got a float array\\\")\\n if mask.ndim == 2:\\n boolean_mask = mask == 255\\n elif mask.ndim == 3:\\n # if all channels are white, mask out\\n boolean_mask = np.all(mask[:, :, :3] == 255, axis=-1)\\n else:\\n raise ValueError(\\\"Got mask of invalid shape: %s\\\" % str(mask.shape))\\n return boolean_mask\",\n \"def addMaskImage(img):\\r\\n [h, w, c] = img.shape\\r\\n h_start = np.random.randint(h/2,h-1)\\r\\n w_start = np.random.randint(w/2, w-1)\\r\\n img[h_start:h-1, :,0]= np.random.randint(0,120)\\r\\n img[h_start:h-1, :,1]= np.random.randint(0,120) \\r\\n img[h_start:h-1, :,2]= np.random.randint(0,120) \\r\\n img[:,w_start:w-1,0]= np.random.randint(0,120)\\r\\n img[:,w_start:w-1,1]= np.random.randint(0,120) \\r\\n img[:,w_start:w-1,2]= np.random.randint(0,120) \\r\\n img = np.uint8(img)\\r\\n return img, h_start, w_start\",\n \"def surface_unmasked(res='4x5', trop_limit=False, mask2D=False,\\n debug=False):\\n # Create a np.ma mask\\n m = np.ma.array(np.zeros(get_dims4res(res)), mask=False)\\n m[..., 0] = 1\\n m = np.ma.masked_not_equal(m, 1)\\n\\n if trop_limit:\\n m = m[..., :38]\\n if debug:\\n print((mask, mask.shape))\\n\\n # Return 2D or 3D?\\n if mask2D:\\n return m[..., 0].mask\\n else:\\n return m.mask\",\n \"def _cvt_mask3d_to_mask2d(m, mapper={(1,1,1):1, (2,2,2):2}, default = 0):\\n #mapping\\n sub_masks = []\\n for k,v in mapper.items():\\n # check elementwise equal\\n sub_masks.append(np.where(np.all(m == k, axis=-1), v, default))\\n\\n # o = reduce(np.add, sub_masks)\\n o = reduce(np.bitwise_or, sub_masks)\\n # o = o[:,:,0] # remove redundant channels\\n return o\",\n \"def gen_background_mask( img ):\\n\\t\\t\\n\\tif len( img.shape ) == 3: t = img[0]\\n\\telif len( img.shape ) == 2: t = img\\n\\n\\tmask = img > filters.threshold_li(t)\\n\\n\\treturn mask\",\n \"def as_boolean_mask(self):\\n bbox = self.bbox()\\n zs = np.unique([c.image_z_position for c in self.contours])\\n z_to_index = dict(zip(zs,range(len(zs))))\\n\\n # Get dimensions, initialize mask.\\n nx,ny = np.diff(bbox[:2], axis=1).astype(int) + 1\\n nx = int(nx); ny = int(ny)\\n nz = int(zs.shape[0])\\n mask = np.zeros((nx,ny,nz), dtype=np.bool)\\n\\n # We check if these points are enclosed within each contour \\n # for a given slice. `test_points` is a list of image coordinate \\n # points, offset by the bounding box.\\n test_points = bbox[:2,0] + np.c_[ np.where(~mask[:,:,0]) ]\\n\\n # First we \\\"turn on\\\" pixels enclosed by inclusion contours.\\n for contour in self.contours:\\n if contour.inclusion:\\n zi = z_to_index[contour.image_z_position]\\n contour_matrix = contour.to_matrix()[:,:2]\\n\\n # Turn the contour closed if it's not.\\n if (contour_matrix[0] != contour_matrix[-1]).all():\\n contour_matrix = np.append(contour_matrix,\\n contour_matrix[0].reshape(1,2),\\n axis=0)\\n\\n # Create path object and test all pixels\\n # within the contour's bounding box.\\n path = mplpath.Path(contour_matrix, closed=True)\\n contains_pts = path.contains_points(test_points)\\n mask[:,:,zi] = contains_pts.reshape(mask.shape[:2])\\n\\n # Second, we \\\"turn off\\\" pixels enclosed by exclusion contours.\\n for contour in self.contours:\\n if not contour.inclusion:\\n zi = z_to_index[contour.image_z_position]\\n contour_matrix = contour.to_matrix()[:,:2]\\n\\n # Turn the contour closed if it's not.\\n if (contour_matrix[0] != contour_matrix[-1]).all():\\n contour_matrix = np.append(contour_matrix,\\n contour_matrix[0].reshape(1,2),\\n axis=0)\\n\\n path = mplpath.Path(contour_matrix, closed=True)\\n not_contains_pts = ~path.contains_points(test_points)\\n not_contains_pts = not_contains_pts.reshape(mask.shape[:2])\\n mask[:,:,zi] = np.logical_and(mask[:,:,zi], not_contains_pts)\\n\\n # The first and second axes have to \\n # be swapped because of the reshape.\\n return mask.swapaxes(0,1), bbox[[1,0,2]]\",\n \"def mask(self):\\n return self.mask_index\",\n \"def _draw_mask_on_image(self, mask):\\n mask = self.STANDARD_COLORS_ARRAY[mask]\\n cv2.addWeighted(mask,self.config.ALPHA,self.image,1.0,0,self.image)\",\n \"def _mask_grid(self):\\n xg, yg = self._build_grid()\\n mask = self._build_mask(xg, yg)\\n mask = mask.reshape(xg.shape)\\n\\n return xg, yg, mask\",\n \"def testMask2D(self):\\n mask = np.ones((3, 2), dtype=np.float32)\\n inputs = tf.constant(1.0, shape=(1, 5, 2))\\n conv1 = snt.Conv1D(\\n output_channels=1,\\n kernel_shape=3,\\n mask=mask,\\n padding=snt.VALID,\\n use_bias=False,\\n initializers=create_constant_initializers(1.0, 0.0, use_bias=False))\\n out = conv1(inputs)\\n expected_out = np.reshape(np.array([6, 6, 6]), (1, 3, 1))\\n with self.test_session():\\n tf.variables_initializer([conv1.w]).run()\\n self.assertAllClose(out.eval(), expected_out)\",\n \"def cfmask_to_mask(raster):\\r\\n mask = raster.ReadAsArray()\\r\\n # A value of 0 is clear of clouds/water. Make all other values = 1.\\r\\n mask[mask != 0] = 1\\r\\n\\r\\n # That's it, just return the result...\\r\\n return mask\",\n \"def get_pca_mask(self):\\n return self.get_pca_images()[1]\",\n \"def vis_mask(img, mask,width,height, col, alpha=0.4, show_border=True, border_thick= -1):\\n\\n img = img.astype(np.float32)\\n idx = np.nonzero(mask)\\n #np.PredictionBoxes(col)\\n img[idx[0], idx[1], :] *= 1.0 - alpha\\n img[idx[0], idx[1], :] += alpha * (400/255.0)\\n\\n if show_border:\\n _, contours, _ = cv2.findContours(\\n mask.copy(), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)\\n cv2.drawContours(img, contours, -1,col, border_thick, cv2.LINE_AA)\\n #cv2.drawContours(c, contours, -1, 1, border_thick, cv2.LINE_AA)\\n\\n return img.astype(np.uint8)\",\n \"def read_mask(mask_path, mask_type, mask_name,patch_size,show_image=None):\\n path_test = mask_path\\n\\n mask= Image.open(path_test+\\\"/\\\"+\\\"{}\\\".format(mask_type)+\\n \\\"/\\\"+\\\"{}.tif\\\".format(mask_name))\\n mask_list = np.asarray(list (mask.getdata() ))\\n\\n mask_list = mask_list / np.amax(mask_list)\\n #either use from future or use // to get float result\\n mask_list = np.reshape(mask_list,(patch_size,patch_size))\\n if (show_image == True):\\n\\n print(mask_list.shape)\\n plt.figure()\\n plt.imshow(mask_list,cmap='gray')\\n plt.show()\\n print(mask_list)\\n return mask_list\",\n \"def process_mask(self, image):\\n image = np.array(image)\\n image[image == 5] = 1 # set un-classified to undestroyed\\n return Image.fromarray(image)\",\n \"def cube_fix_badpix_isolated(array, bpm_mask=None, sigma_clip=3, num_neig=5, \\n size=5, frame_by_frame=False, protect_mask=0, \\n cxy=None, mad=False, ignore_nan=True, verbose=True, \\n full_output=False):\\n if array.ndim != 3:\\n raise TypeError('Array is not a 3d array or cube')\\n if size % 2 == 0:\\n raise TypeError('Size of the median blur kernel must be an odd integer')\\n \\n if bpm_mask is not None:\\n bpm_mask = bpm_mask.astype('bool')\\n \\n if verbose: start = time_ini()\\n \\n if num_neig > 0:\\n neigh = True\\n else:\\n neigh = False\\n \\n nz = array.shape[0]\\n \\n if cxy is None:\\n cy, cx = frame_center(array[0])\\n elif isinstance(cxy, tuple):\\n cx, cy = cxy\\n elif isinstance(cxy, np.ndarray):\\n if cxy.shape[0] != nz or cxy.shape[1] != 2 or cxy.ndim != 2:\\n raise ValueError(\\\"cxy does not have right shape\\\")\\n elif not frame_by_frame:\\n msg = \\\"cxy must be a tuple or None if not in frame_by_frame mode\\\"\\n raise ValueError(msg)\\n else:\\n cx = cxy[:,0]\\n cy = cxy[:,1]\\n\\n \\n array_out = array.copy()\\n final_bpm = np.zeros_like(array_out, dtype=bool)\\n n_frames = array.shape[0]\\n count_bp = 0\\n if frame_by_frame:\\n if np.isscalar(cx):\\n cx = [cx]*nz\\n cy = [cy]*nz\\n if bpm_mask is not None:\\n if bpm_mask.ndim == 2:\\n bpm_mask = [bpm_mask]*n_frames\\n bpm_mask = np.array(bpm_mask)\\n for i in Progressbar(range(n_frames), desc=\\\"processing frames\\\"):\\n if bpm_mask is not None:\\n bpm_mask_tmp = bpm_mask[i]\\n else:\\n bpm_mask_tmp = None\\n res = frame_fix_badpix_isolated(array[i], bpm_mask=bpm_mask_tmp, \\n sigma_clip=sigma_clip,\\n num_neig=num_neig, size=size, \\n protect_mask=protect_mask, \\n verbose=False, cxy=(cx[i],cy[i]), \\n ignore_nan=ignore_nan,\\n full_output=True)\\n array_out[i] = res[0]\\n final_bpm[i] = res[1] \\n count_bp = np.sum(final_bpm) \\n else: \\n if bpm_mask is None:\\n ori_nan_mask = np.where(np.isnan(np.nanmean(array, axis=0)))\\n ind = clip_array(np.nanmean(array, axis=0), sigma_clip, sigma_clip,\\n neighbor=neigh, num_neighbor=num_neig, mad=mad)\\n final_bpm = np.zeros_like(array[0], dtype=bool)\\n final_bpm[ind] = 1\\n if ignore_nan:\\n final_bpm[ori_nan_mask] = 0\\n if protect_mask:\\n cir = disk((cy, cx), protect_mask, shape=final_bpm.shape)\\n final_bpm[cir] = 0\\n final_bpm = final_bpm.astype('bool')\\n else:\\n if bpm_mask.ndim == 3:\\n final_bpm = np.median(bpm_mask, axis=0)\\n else:\\n final_bpm = bpm_mask.copy()\\n \\n for i in Progressbar(range(n_frames), desc=\\\"processing frames\\\"):\\n frame = array_out[i]\\n smoothed = median_filter(frame, size, mode='mirror')\\n frame[np.where(final_bpm)] = smoothed[np.where(final_bpm)]\\n if verbose: \\n count_bp += np.sum(final_bpm)\\n \\n if verbose: \\n msg = \\\"Done replacing {:.0f} bad pixels using the median of neighbors\\\"\\n print(msg.format(count_bp))\\n if not frame_by_frame:\\n msg = \\\"(i.e. {:.0f} static bad pixels per channel))\\\"\\n print(msg.format(count_bp/n_frames)) \\n timing(start)\\n \\n if full_output:\\n return array_out, final_bpm\\n else:\\n return array_out\",\n \"def bbox_3D(img):\\n\\tr = np.any(img, axis=(1, 2))\\n\\tc = np.any(img, axis=(0, 2))\\n\\tz = np.any(img, axis=(0, 1))\\n\\n\\trmin, rmax = np.where(r)[0][[0, -1]]\\n\\tcmin, cmax = np.where(c)[0][[0, -1]]\\n\\tzmin, zmax = np.where(z)[0][[0, -1]]\\n\\n\\treturn rmin, rmax, cmin, cmax, zmin, zmax\",\n \"def test_make_mask(self):\\n output_mask = footprint_mask(os.path.join(data_dir, 'sample.csv'),\\n geom_col=\\\"PolygonWKT_Pix\\\")\\n truth_mask = skimage.io.imread(os.path.join(data_dir,\\n 'sample_fp_mask.tif'))\\n\\n assert np.array_equal(output_mask, truth_mask)\",\n \"def setMask(self, mask):\\n try:\\n self.mask = mask\\n self.inds = na.nonzero(self.mask.flat)[0]\\n #print \\\"length of self.inds\\\",len(self.inds)\\n #print self.inds\\n self.dim = self.mask.shape[::-1]\\n #print self.mask.shape\\n return True\\n except Exception as error:\\n print(\\\"failed in setMask\\\", error)\",\n \"def get_hitmask(image_alpha):\\n mask = []\\n for x in range(image_alpha.get_width()):\\n mask.append([])\\n for y in range(image_alpha.get_height()):\\n mask[x].append(bool(image_alpha.get_at((x, y))[3]))\\n return mask\",\n \"def apply_mask(im, mask, color=(1, 0, 0)):\\n masked = np.zeros(im.shape)\\n for x, y in mask: masked[x][y] = color\\n return masked\",\n \"def load_mask_pre(self, image_id, mask_path):\\n img = Image.open(mask_path)\\n colors = img.getcolors()\\n n_dim = np.shape(colors)\\n num_obj = n_dim[0]-1 #not include the background\\n\\n mask = np.zeros([np.shape(img)[0], np.shape(img)[1], num_obj], dtype=np.uint8)\\n mask = self.draw_mask(num_obj, mask, img, colors)\\n\\n # Map class names to class IDs.\\n class_ids = []\\n for i in range(num_obj):\\n class_ids.append(colors[i+1][1])\\n\\n return mask.astype(np.bool), np.array(class_ids, dtype=np.int32) #mask.astype(np.bool)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.688976","0.68292147","0.68080103","0.67995906","0.6752144","0.6688653","0.66669863","0.661741","0.6568836","0.6568836","0.6568836","0.6547132","0.65295583","0.6466821","0.6449835","0.64433336","0.6434398","0.64335746","0.6432887","0.6421492","0.64210224","0.6379486","0.6358635","0.6334822","0.6307855","0.6269048","0.624991","0.62394947","0.6211145","0.6210357","0.6198721","0.6183484","0.6179662","0.61678606","0.6159925","0.6142654","0.6135054","0.61348736","0.61339533","0.6107811","0.6106382","0.60995895","0.6097661","0.6096655","0.60939646","0.6091388","0.60896295","0.60888505","0.6058994","0.6057309","0.605522","0.60488904","0.60443693","0.60443693","0.6031757","0.60316133","0.6020922","0.6016547","0.60108554","0.60003036","0.5998581","0.5998417","0.59968114","0.5995923","0.5994806","0.59908146","0.5988641","0.59877473","0.59857225","0.5979947","0.5974052","0.5967834","0.5967834","0.5967834","0.5967834","0.59560823","0.59555656","0.595058","0.5949414","0.5942707","0.5940783","0.59352165","0.59348303","0.5933326","0.59179807","0.5912469","0.5911105","0.5908734","0.5898878","0.58861774","0.5885482","0.5883431","0.58829874","0.5873807","0.58724","0.58710575","0.5870483","0.58686197","0.58669746","0.5865045"],"string":"[\n \"0.688976\",\n \"0.68292147\",\n \"0.68080103\",\n \"0.67995906\",\n \"0.6752144\",\n \"0.6688653\",\n \"0.66669863\",\n \"0.661741\",\n \"0.6568836\",\n \"0.6568836\",\n \"0.6568836\",\n \"0.6547132\",\n \"0.65295583\",\n \"0.6466821\",\n \"0.6449835\",\n \"0.64433336\",\n \"0.6434398\",\n \"0.64335746\",\n \"0.6432887\",\n \"0.6421492\",\n \"0.64210224\",\n \"0.6379486\",\n \"0.6358635\",\n \"0.6334822\",\n \"0.6307855\",\n \"0.6269048\",\n \"0.624991\",\n \"0.62394947\",\n \"0.6211145\",\n \"0.6210357\",\n \"0.6198721\",\n \"0.6183484\",\n \"0.6179662\",\n \"0.61678606\",\n \"0.6159925\",\n \"0.6142654\",\n \"0.6135054\",\n \"0.61348736\",\n \"0.61339533\",\n \"0.6107811\",\n \"0.6106382\",\n \"0.60995895\",\n \"0.6097661\",\n \"0.6096655\",\n \"0.60939646\",\n \"0.6091388\",\n \"0.60896295\",\n \"0.60888505\",\n \"0.6058994\",\n \"0.6057309\",\n \"0.605522\",\n \"0.60488904\",\n \"0.60443693\",\n \"0.60443693\",\n \"0.6031757\",\n \"0.60316133\",\n \"0.6020922\",\n \"0.6016547\",\n \"0.60108554\",\n \"0.60003036\",\n \"0.5998581\",\n \"0.5998417\",\n \"0.59968114\",\n \"0.5995923\",\n \"0.5994806\",\n \"0.59908146\",\n \"0.5988641\",\n \"0.59877473\",\n \"0.59857225\",\n \"0.5979947\",\n \"0.5974052\",\n \"0.5967834\",\n \"0.5967834\",\n \"0.5967834\",\n \"0.5967834\",\n \"0.59560823\",\n \"0.59555656\",\n \"0.595058\",\n \"0.5949414\",\n \"0.5942707\",\n \"0.5940783\",\n \"0.59352165\",\n \"0.59348303\",\n \"0.5933326\",\n \"0.59179807\",\n \"0.5912469\",\n \"0.5911105\",\n \"0.5908734\",\n \"0.5898878\",\n \"0.58861774\",\n \"0.5885482\",\n \"0.5883431\",\n \"0.58829874\",\n \"0.5873807\",\n \"0.58724\",\n \"0.58710575\",\n \"0.5870483\",\n \"0.58686197\",\n \"0.58669746\",\n \"0.5865045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8106994"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84664,"cells":{"query":{"kind":"string","value":"test that an 'is_disconnect' condition will invalidate the connection, and additionally dispose the previous connection pool and recreate."},"document":{"kind":"string","value":"def test_reconnect(self):\n\n # make a connection\n\n conn = self.db.connect()\n\n # connection works\n\n conn.execute(select(1))\n\n # create a second connection within the pool, which we'll ensure\n # also goes away\n\n conn2 = self.db.connect()\n conn2.close()\n\n # two connections opened total now\n\n assert len(self.dbapi.connections) == 2\n\n # set it to fail\n\n self.dbapi.shutdown()\n\n # force windows monotonic timer to definitely increment\n time.sleep(0.5)\n\n # close on DBAPI connection occurs here, as it is detected\n # as invalid.\n assert_raises(tsa.exc.DBAPIError, conn.execute, select(1))\n\n # assert was invalidated\n\n assert not conn.closed\n assert conn.invalidated\n\n # close shouldn't break\n\n conn.close()\n\n # ensure one connection closed...\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], []],\n )\n\n conn = self.db.connect()\n\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], [call()], []],\n )\n\n conn.execute(select(1))\n conn.close()\n\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], [call()], []],\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 test_already_disconnected(connection, events, schedule, flush):\n schedule(connection.connect(),\n connection.disconnect(),\n connection.disconnect())\n flush()\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_disconnect_before_connect(connection, events, schedule, flush):\n schedule(connection.disconnect())\n flush()\n assert not connection.connected\n assert not events.triggered(\"CLIENT_CONNECT\")\n assert not events.triggered(\"CLIENT_DISCONNECT\")","def test_disconnect(writer, patch_connection, events, connection,\n schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n assert not connection.connected\n assert writer.closed\n assert connection.writer is None\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_disconnect_closed(self):\n self.sock.close()\n self.inverter.sock.close()\n self.inverter.sock_file.close()\n self.inverter.disconnect() # Should not raise exception","async def test_disconnect(self):\n await self.webhook_connection.connect()\n assert self.webhook_connection.is_connected is True\n\n await self.webhook_connection.disconnect()\n assert self.webhook_connection.is_connected is False","def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()","def test_disconnect_with_rollback(self):\n\n mock_connector = MagicMock()\n database = Database()\n database.connect(connector_impl=mock_connector)\n\n # rollback\n database.disconnect(False)\n\n connection = mock_connector.connect()\n self.assertFalse(connection.commit.called)\n self.assertTrue(connection.close.called)","def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_disconnect_multiple(self):\n self.inverter.disconnect()\n self.inverter.disconnect() # Should not raise exception","def test_disconnect(self):\n self.inverter.disconnect()\n sleep(0.02)","def DisconnectReuseSocket(self) -> bool:","def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\n\n engine = ping_fixture_all_errs_disconnect\n\n conn = engine.connect()\n conn.close()","def test_disconnect(self):\n self.client.ensure_path(\"/services/db/1.1.1.1\")\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"1\"}))\n z = ZkFarmExporter(self.client, \"/services/db\", self.conf)\n z.loop(2, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"1\"}})\n self.conf.reset_mock()\n self.expire_session()\n z.loop(10, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"1\"}})","def test_disconnect_and_still_works(self):\n self.client.ensure_path(\"/services/db/1.1.1.1\")\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"1\"}))\n z = ZkFarmExporter(self.client, \"/services/db\", self.conf)\n z.loop(2, timeout=self.TIMEOUT)\n self.expire_session()\n z.loop(10, timeout=self.TIMEOUT)\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"2\"}))\n z.loop(2, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"2\"}})","def test_disconnect_with_commit(self):\n\n mock_connector = MagicMock()\n database = Database()\n database.connect(connector_impl=mock_connector)\n\n # commit\n database.disconnect(True)\n\n connection = mock_connector.connect()\n self.assertTrue(connection.commit.called)\n self.assertTrue(connection.close.called)","async def test_libp2pclientconnection_connect_disconnect(self):\n assert self.connection.is_connected is False\n try:\n await self.connection_node.connect()\n await self.connection.connect()\n assert self.connection.is_connected is True\n\n await self.connection.disconnect()\n assert self.connection.is_connected is False\n except Exception:\n raise\n finally:\n await self.connection_node.disconnect()","def connection_closed(self) -> bool:","def test_disconnect(self):\n\n\t\twith EchoServer(bind_addr = ('', 12122)):\n\t\t\tyield reactor.schedule()\n\t\t\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\n\t\t\tyield client.connect()\n\n\t\t\tclient.close()","async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\n leak_tracker.set_initial_object_list()\n\n await client.connect()\n assert client.connected\n dropper.reject_outgoing()\n\n while client.connected:\n await asyncio.sleep(1)\n\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\n dropper.restore_all()\n while not client.connected:\n await asyncio.sleep(1)\n\n leak_tracker.check_for_leaks()","def test_idleClientDoesDisconnect(self):\n c = Clock()\n # Hook up our server protocol\n transport = StringTransportWithDisconnection()\n transport.protocol = self.server\n self.server.callLater = c.callLater\n self.server.makeConnection(transport)\n\n # Make sure we can notice when the connection goes away\n lost = []\n connLost = self.server.connectionLost\n self.server.connectionLost = lambda reason: (lost.append(None), connLost(reason))[1]\n\n # 2/3rds of the idle timeout elapses...\n c.pump([0.0] + [self.server.timeOut / 3.0] * 2)\n self.assertFalse(lost, lost)\n\n # Now some more\n c.pump([0.0, self.server.timeOut / 2.0])\n self.assertTrue(lost)","def should_reconnect(self):\n if not self.by_remote:\n if self.code == 1006:\n if self.reason == 'Abnormal closure':\n return True\n \n return False","async def test_connect_and_disconnect(database_url):\n database = Database(database_url)\n\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected","def the_user_disconnect_the_device_and_reconnect_again_to_the_same_device():\n assert web_app.disconnect_from_device()\n assert web_app.connect_to_device1()","def onDisconnect(self, connection:MQTTConnection) -> bool:\n\t\treturn True","def _disconnect(self):\n self._factory.stopTrying()\n self._connection.disconnect()","def disconnect(self):\n return True","def test_disconnect_loop_invalid_grant(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","def _close(self): # used by model_tests\n Connection.__pool__.pop(self.id)\n self.connected = False","def disconnect(conn):\n conn.close()","def test_disconnect_loop_auth_issue(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","def connection_remote_closed(self, connection, pn_condition):\n assert len(self.receivers) == 0\n self.connection.close()","def test_close(self):\n db = database.Database()\n db.close()\n self.assertTrue(self.mocked_connection.close.call_count is 1)","def inner_test(param: enums.DisconnectReason):\n pass","def test_parse_message_failure_disconnect(self, mock_disconnect):\n for test_case in self.failure_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertNotEqual(expected, mock_disconnect)","def disconnect(self):\n _error = None\n try:\n self.connection.shutdown()\n except Exception as e:\n log.error(e, exc_info=True)\n _error = 'disconnect error: %s' % e\n finally:\n if _error is not None and config.DEBUG_TO_CONSOLE:\n print (_error)\n self.is_connected = False\n self.connection = None","async def _disconnect(self) -> None:\n\n if self._ws is not None:\n logger.debug(\"Closing ws connection\")\n await self._ws.close()\n\n # Checking self._ws again since during the above await, another\n # disconnect call could have finished cleaning up.\n if self._ws is None:\n # This indicates that _ws, _awaiting_replies and _ping_check are\n # cleaned up\n logger.debug(\"Ws connection already cleaned up\")\n return\n\n logger.debug(\"Cancelling futures waiting for replies\")\n for future in self._awaiting_replies.values():\n future.set_exception(ConnectionClosedException())\n\n logger.debug(\"Cancelling ping check task\")\n self._ping_check.cancel()\n\n logger.debug(\"Cleaning up variables\")\n self._ws = None\n self._awaiting_replies = None\n self._ping_check = None","def testReconnectionOnConnectionLost(self):\n d = self.testConnectionLost()\n d.addCallback(lambda _: self.factory.resume())\n d.addCallback(lambda _: self.client.connection.deferred)\n self._addRequest(d)\n return d","def _close_connection(self):\n if self.connection:\n self.connection.destroy()\n self.connection = None","def test_rollback_and_close_on_failure(self):\n\n mock_connector = MagicMock()\n\n try:\n with Database.connect(mysql_connector_impl=mock_connector) as database:\n connection = database.connection\n raise Exception('intentional test of exception handling')\n except Exception:\n pass\n\n mock_connector.connect.assert_called_once()\n connection.commit.assert_not_called()\n connection.close.assert_called_once()","def test_already_connected(connection, events, writer, schedule, flush):\n schedule(connection.connect(), connection.connect())\n flush()\n assert not writer.closed\n assert events.triggered(\"CLIENT_CONNECT\")","def _fixture(\n self,\n dialect_name,\n exception,\n db_stays_down,\n is_disconnect=True,\n ):\n connect_args = {}\n patchers = []\n db_disconnected = False\n\n class DisconnectCursorMixin:\n def execute(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return super().execute(*arg, **kw)\n\n if dialect_name == \"postgresql\":\n import psycopg2.extensions\n\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\n pass\n\n connect_args = {\"cursor_factory\": Curs}\n\n elif dialect_name == \"mysql\":\n import pymysql\n\n def fake_ping(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return True\n\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\n pass\n\n connect_args = {\"cursorclass\": Curs}\n\n patchers.append(\n mock.patch.object(\n pymysql.Connection, \"ping\", fake_ping\n )\n )\n else:\n raise NotImplementedError()\n\n with mock.patch.object(\n compat,\n \"native_pre_ping_event_support\",\n self.native_pre_ping,\n ):\n engine = engines.create_engine(\n self.engine.url, max_retries=0)\n\n # 1. override how we connect. if we want the DB to be down\n # for the moment, but recover, reset db_disconnected after\n # connect is called. If we want the DB to stay down, then\n # make sure connect raises the error also.\n @event.listens_for(engine, \"do_connect\")\n def _connect(dialect, connrec, cargs, cparams):\n nonlocal db_disconnected\n\n # while we're here, add our cursor classes to the DBAPI\n # connect args\n cparams.update(connect_args)\n\n if db_disconnected:\n if db_stays_down:\n raise exception\n else:\n db_disconnected = False\n\n # 2. initialize the dialect with a first connect\n conn = engine.connect()\n conn.close()\n\n # 3. add additional patchers\n patchers.extend([\n mock.patch.object(\n engine.dialect.dbapi,\n \"Error\",\n self.Error,\n ),\n mock.patch.object(\n engine.dialect,\n \"is_disconnect\",\n mock.Mock(return_value=is_disconnect),\n ),\n ])\n\n with test_utils.nested(*patchers):\n # \"disconnect\" the DB\n db_disconnected = True\n yield engine","def db_disconnect(self):\n \n if(self.connection):\n self.connection.close()\n return","async def test_context_manager_disconnect_handling(preset_server, event_loop):\n preset_client = SMTP(\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\n )\n\n async with preset_client:\n assert preset_client.is_connected\n\n preset_server.responses.append(b\"250 noop\")\n preset_server.drop_connection_event.set()\n\n try:\n await preset_client.noop()\n except SMTPServerDisconnected:\n pass\n\n assert not preset_client.is_connected","def dropConnection(): #@NoSelf","def disconnect_from_db(conn):\n if conn:\n try:\n conn.close()\n except Exception as e:\n print(str(e))\n raise e","def disconnect():\n\n if not session.disconnect():\n\n # If the client is not connected send an error.\n return dict(ok=False, error=\"Client not connected\")\n\n return dict(ok=True)","def test__purge_redis_not_connected(self):\n persistence_helper = PersistenceHelper()\n manager = FakeRedisManagerForCleanup('prefix1')\n manager.close_manager()\n self.assertEqual(manager.purged, False)\n success_result_of(persistence_helper._purge_redis(manager))\n self.assertEqual(manager.purged, False)","def reconnecting(self) -> bool:","async def do_disconnect(self):\n # We shouldn't be asked to disconnect if it wasn't us who connected\n # originally\n if not self.connect_requested:\n log.info(\n \"%s disconnecting, although we didn't connect originally\", self.name\n )\n self.connect_requested = False\n # Actually do it\n await self.disconnect()","def disconnect(self) -> None:\n ...","async def disconnect(self) -> bool:\n return await self._backend.disconnect()","async def test_disconnect_on_drop_outgoing(self, client, dropper, leak_tracker):\n leak_tracker.set_initial_object_list()\n\n await client.connect()\n assert client.connected\n dropper.drop_outgoing()\n\n while client.connected:\n await asyncio.sleep(1)\n\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\n dropper.restore_all()\n while not client.connected:\n await asyncio.sleep(1)\n\n leak_tracker.check_for_leaks()","def test_send_disconnected(connection, writer, schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n connection.send(\"test\")\n assert not writer.used","def on_disconnect(unused_client, unused_userdata, rc):\n\tprint('on_disconnect', error_str(rc))\n\n\t# Since a disconnect occurred, the next loop iteration will wait with\n\t# exponential backoff.\n\tglobal should_backoff\n\tshould_backoff = True","async def test_close_old_keeped_conn(app, aiohttp_server):\n server1 = await aiohttp_server(app)\n server2 = await aiohttp_server(app)\n url1 = \"http://localhost:%d\" % server1.port\n url2 = \"http://localhost:%d\" % server2.port\n connector = TCPConnector(pool_size=1, connection_cls=MyConnection)\n async with aiosonic.HTTPClient(connector) as client:\n await client.get(url1)\n # get used writer\n async with await connector.pool.acquire() as connection:\n writer = connection.writer\n\n await client.get(url2)\n # python 3.6 doesn't have writer.is_closing\n is_closing = getattr(writer, \"is_closing\", writer._transport.is_closing)\n\n # check that old writer is closed\n assert is_closing()\n await server1.close()\n await server2.close()","def connection_closed(self):\n self.atv = None\n self._start_connect_loop()\n self._update_state(disconnected=True)","def test_disconnect():\n PV_name = \"TEST:TEST.VAL\"\n casput(PV_name, 1)\n assert casget(PV_name) == 1\n assert caget(PV_name) == 1\n casdel(PV_name)\n assert casget(PV_name) is None\n from time import sleep\n sleep(1)\n assert caget(PV_name) is None","def test_invalid_disconnect(self):\n mediator = Mediator()\n try:\n mediator.disconnect(\"foo\", self.dog.set_sound)\n mediator.disconnect(\"bar\", self.cat.set_sound)\n except:\n raise AssertionError()","def test_control(self, ping_fixture):\n engine = ping_fixture\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def connection_lost(self, exc):\n if not self._closing:\n self._closing = True\n self.log.info('{about}{reason}'.format(\n about=self.__str__(),\n reason=': {}'.format(exc) if exc is not None else ''))\n self.waiter_connected.cancel()\n self.waiter_closed.set_result(self)","def __del__(self):\n if self.connection is not None:\n self.connection.close()\n print(\"Connection closed\")\n return 0","def test_is_connected__not_connection(self):\n self.switch.connection = None\n self.switch.is_active = MagicMock()\n self.switch.is_active.return_value = True\n\n self.assertFalse(self.switch.is_connected())","def disconnect():\r\n try:\r\n global connection\r\n global cursor\r\n\r\n connection.close()\r\n logger.info(\"The SQLite connection is closed\")\r\n\r\n except sqlite3.Error as error:\r\n logger.error(f\"Error while connecting to sqlite: {error}\")","def ensure_node_disconnected(node):\n for inplug, outplug in node.listConnections(plugs=True, connections=True):\n try:\n outplug.disconnect(inplug)\n # That the lazy way, if disconnection fail, that because inplug and outplug\n # are reversed ...\n except RuntimeError:\n inplug.disconnect(outplug)","async def disconnect(self):\n self.logger.info(f'disconnecting from {self.dsn}')\n await self.dbase.disconnect()","async def on_disconnect(self, reconnecting):\n pass","def the_current_device_is_disconnected():\n assert web_app.disconnect_from_device()","def user_is_disconnected_from_all_devices():\n assert web_app.disconnect_from_device()","def test_reconnect_another(self):\n line, head = self._get_line()\n self.tool.connect(line, head, (120, 50))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n item = cinfo.connected\n port = cinfo.port\n constraint = cinfo.constraint\n\n assert item == self.box1\n assert port == self.box1.ports()[0]\n assert item != self.box2\n\n # connect to box2, handle's connected item and connection data\n # should differ\n self.tool.connect(line, head, (120, 150))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n self.assertEqual(self.box2, cinfo.connected)\n self.assertEqual(self.box2.ports()[0], cinfo.port)\n\n # old connection does not exist\n self.assertNotEqual(item, cinfo.connected)\n self.assertNotEqual(constraint, cinfo.constraint)","def __exit__(self, exc_type, exc_val, exc_tb):\n self.conn.close()\n if exc_val:\n raise","def test_unregisterProducerAfterDisconnect(self):\n reactor = self.buildReactor()\n self.listen(reactor, ServerFactory.forProtocol(ClosingProtocol))\n\n finished = Deferred()\n finished.addErrback(log.err)\n finished.addCallback(lambda ign: reactor.stop())\n\n writing = []\n\n class ClientProtocol(Protocol):\n \"\"\"\n Protocol to connect, register a producer, try to lose the\n connection, wait for the server to disconnect from us, and then\n unregister the producer.\n \"\"\"\n\n def connectionMade(self):\n log.msg(\"ClientProtocol.connectionMade\")\n self.transport.registerProducer(\n _SimplePullProducer(self.transport), False\n )\n self.transport.loseConnection()\n\n def connectionLost(self, reason):\n log.msg(\"ClientProtocol.connectionLost\")\n self.unregister()\n writing.append(self.transport in _getWriters(reactor))\n finished.callback(None)\n\n def unregister(self):\n log.msg(\"ClientProtocol unregister\")\n self.transport.unregisterProducer()\n\n clientFactory = ClientFactory()\n clientFactory.protocol = ClientProtocol\n self.connect(reactor, clientFactory)\n self.runReactor(reactor)\n self.assertFalse(writing[0], \"Transport was writing after unregisterProducer.\")","def close_connection_if_open():\n\ttry:\n\t\tconn = flask.g._database_connection\n\texcept AttributeError:\n\t\tpass\n\telse:\n\t\tconn.close()\n\t\tdel flask.g._database_connection","def testConnectionMade(self):\n d = self._getClientConnection()\n d.addCallback(lambda _: self.client.disconnect())\n return d","def pool(self):\n connection_ok = False\n sanity_check = 0\n sanity_threshold = 10\n\n while connection_ok == False:\n conn = self._get_pool().acquire()\n\n try:\n conn.ping()\n connection_ok = True\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 sanity_check += 1\n if sanity_check > sanity_threshold:\n raise self.Database_Error, ('Session droped from the pool... %s More details http://ora-%s.ora-code.com/') %(error.message, error.code)\n\n logger.warning(\"Found a dead connection. Dropping from pool.\")\n pool.drop(conn)\n\n conn.autocommit = 1 # This read-write attribute determines whether autocommit mode is on or off.\n\n return conn","def test_close_cnxn():\n\n cnxn = connect()\n cursor = cnxn.cursor()\n\n cursor.execute(\"drop table if exists t1\")\n cursor.execute(\"create table t1(id integer, s varchar(20))\")\n cursor.execute(\"insert into t1 values (?,?)\", 1, 'test')\n cursor.execute(\"select * from t1\")\n\n cnxn.close()\n\n # Now that the connection is closed, we expect an exception. (If the code attempts to use\n # the HSTMT, we'll get an access violation instead.)\n with pytest.raises(pyodbc.ProgrammingError):\n cursor.execute(\"select * from t1\")","def disconnect_once(self):\n\t\tif not self.isdisconnected:\n\t\t\tself.disconnect()\n\t\t\tself.isdisconnected = True","def disconnect(self):\n _abstract()","def disconnect(self):\n _abstract()","async def __aexit__(self, exc_type, exc_value, traceback):\n\n # Close the connection\n await self.disconnect()","async def disconnect(self) -> None:\n\n # Possible states left: _NOT_RUNNING, _CONNECTING, _RUNNING,\n # _RECONNECTING, _DISCONNECTING\n\n # Waiting until the current connection attempt is finished. Using a\n # while loop since the event loop might have started to reconnect again\n # while the await is still waiting.\n while self._state in [self._CONNECTING, self._RECONNECTING]:\n # After _CONNECTING, the state can either be _NOT_RUNNING or\n # _RUNNING. After _RECONNECTING, the state must be _RUNNING.\n async with self._connected_condition:\n await self._connected_condition.wait()\n\n # Possible states left: _NOT_RUNNING, _RUNNING, _DISCONNECTING\n\n if self._state == self._NOT_RUNNING:\n # No need to do anything since we're already disconnected\n logger.debug(\"Already disconnected\")\n return\n\n # Possible states left: _RUNNING, _DISCONNECTING\n\n if self._state == self._DISCONNECTING:\n # Wait until the disconnecting currently going on is complete. This\n # is to prevent the disconnect() function from ever returning\n # without the disconnecting process being finished.\n logger.debug(\"Already disconnecting, waiting for it to finish...\")\n async with self._disconnected_condition:\n await self._disconnected_condition.wait()\n\n logger.debug(\"Disconnected, finished waiting\")\n return\n\n # Possible states left: _RUNNING\n\n # By principle of exclusion, the only state left is _RUNNING. Doing an\n # explicit check though, just to make sure.\n if self._state != self._RUNNING:\n raise IncorrectStateException(\"This should never happen.\")\n\n\n logger.debug(\"Disconnecting...\")\n self._events.fire(\"disconnecting\")\n\n # Now we're sure we're in the _RUNNING state, we can set our state.\n # Important: No await-ing has occurred between checking the state and\n # setting it.\n self._state = self._DISCONNECTING\n\n await self._disconnect()\n\n # We know that _event_loop is not None, but this is to keep mypy happy.\n logger.debug(\"Waiting for event loop\")\n if self._event_loop is not None:\n await self._event_loop\n self._event_loop = None\n\n self._state = self._NOT_RUNNING\n\n # Notify all other disconnect()s waiting\n logger.debug(\"Sending disconnected notification\")\n async with self._disconnected_condition:\n self._disconnected_condition.notify_all()\n\n logger.debug(\"Disconnected\")","def disconnect():\n return c.close()","def disconnect(self):\n\n if self.connect:\n Disconnect(self.connect)","def __exit__(self, exc_type, exc_value, tb):\n if exc_type is not None:\n traceback.print_exception(exc_type, exc_value, tb)\n # return False # uncomment to pass exception through\n\n return True \n\n self.db = None\n self.client.close()\n\n return True","def disconnect(self):\n logger.debug(\"disconnecting\")\n if self.connected and self.conn:\n self.can_listen = False\n self.conn.close()\n self.connected = False","def test_is_connected__not_alive(self):\n connection = MagicMock()\n connection.is_alive.return_value = True\n connection.is_established.return_value = True\n self.switch.connection = connection\n self.switch.is_active = MagicMock()\n self.switch.is_active.return_value = False\n\n self.assertFalse(self.switch.is_connected())","def testConnectionLost(self):\n d = self.testSimpleRequest()\n d.addCallback(lambda _: self.factory.crash())\n d.addCallback(lambda _: self.client.check_rate_limit())\n d.addTimeout(0.01, reactor)\n self.assertFailure(d, ConnectionClosed)\n return d","def disconnect_db(self) -> None:","def DBDisconnect(self):\n if self._dbh:\n self._dbh.close()\n self._dbh = None","def __del__(self):\n if self.connection_obj:\n self.logger.info('Disconnecting from host {0}:{1}'.format(self.host, self.port))\n Disconnect(self.connection_obj)","async def disconnect(self):\r\n from asyncio import shield\r\n if self._session is not None:\r\n await shield(self._session.connector.close())\r\n await shield(self._session.close())\r\n self._session = None","def test_dead_node(self):\r\n self.pool._hosts.append(self.host)\r\n\r\n # cursor mock needed so set_cql_version doesn't crap out\r\n ok_cur = MagicMock()\r\n\r\n ok_conn = MagicMock()\r\n ok_conn.return_value = ok_cur\r\n\r\n\r\n returns = [CQLEngineException(), ok_conn]\r\n\r\n def side_effect(*args, **kwargs):\r\n result = returns.pop(0)\r\n if isinstance(result, Exception):\r\n raise result\r\n return result\r\n\r\n with patch('cqlengine.connection.cql.connect') as mock:\r\n mock.side_effect = side_effect\r\n conn = self.pool._create_connection()","def disconnect(self):\n print(\"<== Conexión cerrada ==>\")\n self.is_alive = False\n self._socket.close()","def test_reconnect_same(self):\n line, head = self._get_line()\n self.tool.connect(line, head, (120, 50))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n item = cinfo.connected\n port = cinfo.port\n constraint = cinfo.constraint\n\n assert item == self.box1\n assert item != self.box2\n\n # connect to box1 again, handle's connected item and port should be\n # the same but connection constraint will differ\n connected = self.tool.connect(line, head, (120, 50))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n self.assertEqual(self.box1, cinfo.connected)\n self.assertEqual(self.box1.ports()[0], cinfo.port)\n self.assertNotEqual(constraint, cinfo.constraint)","def _check_closed(self):\n if self.closed:\n raise Error(\"cursor is closed\")\n if self.session.closed:\n raise Error(\"connection is closed\")","def disconnect():\n logging.info('Client disconnected')","def connection_lost(self, exc):\n if self._closing:\n return\n self._closing = True\n\n # inform yielding readers about closed connection\n if exc is None:\n logger.info(\"Connection closed for %s\", self)\n self.reader.feed_eof()\n else:\n logger.info(\"Connection lost for %s: %s\", self, exc)\n self.reader.set_exception(exc)\n\n # cancel protocol tasks, namely on-connect negotiations\n for task in self._tasks:\n task.cancel()\n\n # close transport (may already be closed), set _waiter_closed and\n # cancel Future _waiter_connected.\n self._transport.close()\n self._waiter_connected.cancel()\n if self.shell is None and self._waiter_closed is not None:\n # raise deprecation warning, _waiter_closed should not be used!\n self._waiter_closed.set_result(weakref.proxy(self))\n\n # break circular references.\n self._transport = None","def test_connection_is_established(self):\n for conn in self.connections:\n assert conn.is_connected is True","def connection_teardown():\n test_str = make_random(100)\n server = start_server()\n client = start_client()\n\n # First write some data at both ends.\n write_to(client, test_str)\n write_to(server, test_str)\n time.sleep(TEST_TIMEOUT)\n\n # Write EOFs on both sides.\n write_to(client, '\\x1a')\n write_to(server, '\\x1a')\n client.stdin.close()\n server.stdin.close()\n time.sleep(TEST_TIMEOUT)\n\n return (\n DEBUG_TEARDOWN in read_debug_messages_from(client) and\n DEBUG_TEARDOWN in read_debug_messages_from(server)\n )"],"string":"[\n \"def test_already_disconnected(connection, events, schedule, flush):\\n schedule(connection.connect(),\\n connection.disconnect(),\\n connection.disconnect())\\n flush()\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_disconnect_before_connect(connection, events, schedule, flush):\\n schedule(connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert not events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert not events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_disconnect(writer, patch_connection, events, connection,\\n schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert writer.closed\\n assert connection.writer is None\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_disconnect_closed(self):\\n self.sock.close()\\n self.inverter.sock.close()\\n self.inverter.sock_file.close()\\n self.inverter.disconnect() # Should not raise exception\",\n \"async def test_disconnect(self):\\n await self.webhook_connection.connect()\\n assert self.webhook_connection.is_connected is True\\n\\n await self.webhook_connection.disconnect()\\n assert self.webhook_connection.is_connected is False\",\n \"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\\n\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n ctx.is_disconnect = True\\n\\n conn = engine.connect()\\n # no error\\n conn.close()\",\n \"def test_disconnect_with_rollback(self):\\n\\n mock_connector = MagicMock()\\n database = Database()\\n database.connect(connector_impl=mock_connector)\\n\\n # rollback\\n database.disconnect(False)\\n\\n connection = mock_connector.connect()\\n self.assertFalse(connection.commit.called)\\n self.assertTrue(connection.close.called)\",\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_event_handler_can_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_disconnect\\n if ctx.is_pre_ping:\\n ctx.is_disconnect = False\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_disconnect_multiple(self):\\n self.inverter.disconnect()\\n self.inverter.disconnect() # Should not raise exception\",\n \"def test_disconnect(self):\\n self.inverter.disconnect()\\n sleep(0.02)\",\n \"def DisconnectReuseSocket(self) -> bool:\",\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_disconnect(self):\\n self.client.ensure_path(\\\"/services/db/1.1.1.1\\\")\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"1\\\"}))\\n z = ZkFarmExporter(self.client, \\\"/services/db\\\", self.conf)\\n z.loop(2, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"1\\\"}})\\n self.conf.reset_mock()\\n self.expire_session()\\n z.loop(10, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"1\\\"}})\",\n \"def test_disconnect_and_still_works(self):\\n self.client.ensure_path(\\\"/services/db/1.1.1.1\\\")\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"1\\\"}))\\n z = ZkFarmExporter(self.client, \\\"/services/db\\\", self.conf)\\n z.loop(2, timeout=self.TIMEOUT)\\n self.expire_session()\\n z.loop(10, timeout=self.TIMEOUT)\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"2\\\"}))\\n z.loop(2, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"2\\\"}})\",\n \"def test_disconnect_with_commit(self):\\n\\n mock_connector = MagicMock()\\n database = Database()\\n database.connect(connector_impl=mock_connector)\\n\\n # commit\\n database.disconnect(True)\\n\\n connection = mock_connector.connect()\\n self.assertTrue(connection.commit.called)\\n self.assertTrue(connection.close.called)\",\n \"async def test_libp2pclientconnection_connect_disconnect(self):\\n assert self.connection.is_connected is False\\n try:\\n await self.connection_node.connect()\\n await self.connection.connect()\\n assert self.connection.is_connected is True\\n\\n await self.connection.disconnect()\\n assert self.connection.is_connected is False\\n except Exception:\\n raise\\n finally:\\n await self.connection_node.disconnect()\",\n \"def connection_closed(self) -> bool:\",\n \"def test_disconnect(self):\\n\\n\\t\\twith EchoServer(bind_addr = ('', 12122)):\\n\\t\\t\\tyield reactor.schedule()\\n\\t\\t\\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\\n\\t\\t\\tyield client.connect()\\n\\n\\t\\t\\tclient.close()\",\n \"async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\\n leak_tracker.set_initial_object_list()\\n\\n await client.connect()\\n assert client.connected\\n dropper.reject_outgoing()\\n\\n while client.connected:\\n await asyncio.sleep(1)\\n\\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\\n dropper.restore_all()\\n while not client.connected:\\n await asyncio.sleep(1)\\n\\n leak_tracker.check_for_leaks()\",\n \"def test_idleClientDoesDisconnect(self):\\n c = Clock()\\n # Hook up our server protocol\\n transport = StringTransportWithDisconnection()\\n transport.protocol = self.server\\n self.server.callLater = c.callLater\\n self.server.makeConnection(transport)\\n\\n # Make sure we can notice when the connection goes away\\n lost = []\\n connLost = self.server.connectionLost\\n self.server.connectionLost = lambda reason: (lost.append(None), connLost(reason))[1]\\n\\n # 2/3rds of the idle timeout elapses...\\n c.pump([0.0] + [self.server.timeOut / 3.0] * 2)\\n self.assertFalse(lost, lost)\\n\\n # Now some more\\n c.pump([0.0, self.server.timeOut / 2.0])\\n self.assertTrue(lost)\",\n \"def should_reconnect(self):\\n if not self.by_remote:\\n if self.code == 1006:\\n if self.reason == 'Abnormal closure':\\n return True\\n \\n return False\",\n \"async def test_connect_and_disconnect(database_url):\\n database = Database(database_url)\\n\\n assert not database.is_connected\\n await database.connect()\\n assert database.is_connected\\n await database.disconnect()\\n assert not database.is_connected\",\n \"def the_user_disconnect_the_device_and_reconnect_again_to_the_same_device():\\n assert web_app.disconnect_from_device()\\n assert web_app.connect_to_device1()\",\n \"def onDisconnect(self, connection:MQTTConnection) -> bool:\\n\\t\\treturn True\",\n \"def _disconnect(self):\\n self._factory.stopTrying()\\n self._connection.disconnect()\",\n \"def disconnect(self):\\n return True\",\n \"def test_disconnect_loop_invalid_grant(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"def _close(self): # used by model_tests\\n Connection.__pool__.pop(self.id)\\n self.connected = False\",\n \"def disconnect(conn):\\n conn.close()\",\n \"def test_disconnect_loop_auth_issue(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"def connection_remote_closed(self, connection, pn_condition):\\n assert len(self.receivers) == 0\\n self.connection.close()\",\n \"def test_close(self):\\n db = database.Database()\\n db.close()\\n self.assertTrue(self.mocked_connection.close.call_count is 1)\",\n \"def inner_test(param: enums.DisconnectReason):\\n pass\",\n \"def test_parse_message_failure_disconnect(self, mock_disconnect):\\n for test_case in self.failure_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertNotEqual(expected, mock_disconnect)\",\n \"def disconnect(self):\\n _error = None\\n try:\\n self.connection.shutdown()\\n except Exception as e:\\n log.error(e, exc_info=True)\\n _error = 'disconnect error: %s' % e\\n finally:\\n if _error is not None and config.DEBUG_TO_CONSOLE:\\n print (_error)\\n self.is_connected = False\\n self.connection = None\",\n \"async def _disconnect(self) -> None:\\n\\n if self._ws is not None:\\n logger.debug(\\\"Closing ws connection\\\")\\n await self._ws.close()\\n\\n # Checking self._ws again since during the above await, another\\n # disconnect call could have finished cleaning up.\\n if self._ws is None:\\n # This indicates that _ws, _awaiting_replies and _ping_check are\\n # cleaned up\\n logger.debug(\\\"Ws connection already cleaned up\\\")\\n return\\n\\n logger.debug(\\\"Cancelling futures waiting for replies\\\")\\n for future in self._awaiting_replies.values():\\n future.set_exception(ConnectionClosedException())\\n\\n logger.debug(\\\"Cancelling ping check task\\\")\\n self._ping_check.cancel()\\n\\n logger.debug(\\\"Cleaning up variables\\\")\\n self._ws = None\\n self._awaiting_replies = None\\n self._ping_check = None\",\n \"def testReconnectionOnConnectionLost(self):\\n d = self.testConnectionLost()\\n d.addCallback(lambda _: self.factory.resume())\\n d.addCallback(lambda _: self.client.connection.deferred)\\n self._addRequest(d)\\n return d\",\n \"def _close_connection(self):\\n if self.connection:\\n self.connection.destroy()\\n self.connection = None\",\n \"def test_rollback_and_close_on_failure(self):\\n\\n mock_connector = MagicMock()\\n\\n try:\\n with Database.connect(mysql_connector_impl=mock_connector) as database:\\n connection = database.connection\\n raise Exception('intentional test of exception handling')\\n except Exception:\\n pass\\n\\n mock_connector.connect.assert_called_once()\\n connection.commit.assert_not_called()\\n connection.close.assert_called_once()\",\n \"def test_already_connected(connection, events, writer, schedule, flush):\\n schedule(connection.connect(), connection.connect())\\n flush()\\n assert not writer.closed\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\",\n \"def _fixture(\\n self,\\n dialect_name,\\n exception,\\n db_stays_down,\\n is_disconnect=True,\\n ):\\n connect_args = {}\\n patchers = []\\n db_disconnected = False\\n\\n class DisconnectCursorMixin:\\n def execute(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return super().execute(*arg, **kw)\\n\\n if dialect_name == \\\"postgresql\\\":\\n import psycopg2.extensions\\n\\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\\n pass\\n\\n connect_args = {\\\"cursor_factory\\\": Curs}\\n\\n elif dialect_name == \\\"mysql\\\":\\n import pymysql\\n\\n def fake_ping(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return True\\n\\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\\n pass\\n\\n connect_args = {\\\"cursorclass\\\": Curs}\\n\\n patchers.append(\\n mock.patch.object(\\n pymysql.Connection, \\\"ping\\\", fake_ping\\n )\\n )\\n else:\\n raise NotImplementedError()\\n\\n with mock.patch.object(\\n compat,\\n \\\"native_pre_ping_event_support\\\",\\n self.native_pre_ping,\\n ):\\n engine = engines.create_engine(\\n self.engine.url, max_retries=0)\\n\\n # 1. override how we connect. if we want the DB to be down\\n # for the moment, but recover, reset db_disconnected after\\n # connect is called. If we want the DB to stay down, then\\n # make sure connect raises the error also.\\n @event.listens_for(engine, \\\"do_connect\\\")\\n def _connect(dialect, connrec, cargs, cparams):\\n nonlocal db_disconnected\\n\\n # while we're here, add our cursor classes to the DBAPI\\n # connect args\\n cparams.update(connect_args)\\n\\n if db_disconnected:\\n if db_stays_down:\\n raise exception\\n else:\\n db_disconnected = False\\n\\n # 2. initialize the dialect with a first connect\\n conn = engine.connect()\\n conn.close()\\n\\n # 3. add additional patchers\\n patchers.extend([\\n mock.patch.object(\\n engine.dialect.dbapi,\\n \\\"Error\\\",\\n self.Error,\\n ),\\n mock.patch.object(\\n engine.dialect,\\n \\\"is_disconnect\\\",\\n mock.Mock(return_value=is_disconnect),\\n ),\\n ])\\n\\n with test_utils.nested(*patchers):\\n # \\\"disconnect\\\" the DB\\n db_disconnected = True\\n yield engine\",\n \"def db_disconnect(self):\\n \\n if(self.connection):\\n self.connection.close()\\n return\",\n \"async def test_context_manager_disconnect_handling(preset_server, event_loop):\\n preset_client = SMTP(\\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\\n )\\n\\n async with preset_client:\\n assert preset_client.is_connected\\n\\n preset_server.responses.append(b\\\"250 noop\\\")\\n preset_server.drop_connection_event.set()\\n\\n try:\\n await preset_client.noop()\\n except SMTPServerDisconnected:\\n pass\\n\\n assert not preset_client.is_connected\",\n \"def dropConnection(): #@NoSelf\",\n \"def disconnect_from_db(conn):\\n if conn:\\n try:\\n conn.close()\\n except Exception as e:\\n print(str(e))\\n raise e\",\n \"def disconnect():\\n\\n if not session.disconnect():\\n\\n # If the client is not connected send an error.\\n return dict(ok=False, error=\\\"Client not connected\\\")\\n\\n return dict(ok=True)\",\n \"def test__purge_redis_not_connected(self):\\n persistence_helper = PersistenceHelper()\\n manager = FakeRedisManagerForCleanup('prefix1')\\n manager.close_manager()\\n self.assertEqual(manager.purged, False)\\n success_result_of(persistence_helper._purge_redis(manager))\\n self.assertEqual(manager.purged, False)\",\n \"def reconnecting(self) -> bool:\",\n \"async def do_disconnect(self):\\n # We shouldn't be asked to disconnect if it wasn't us who connected\\n # originally\\n if not self.connect_requested:\\n log.info(\\n \\\"%s disconnecting, although we didn't connect originally\\\", self.name\\n )\\n self.connect_requested = False\\n # Actually do it\\n await self.disconnect()\",\n \"def disconnect(self) -> None:\\n ...\",\n \"async def disconnect(self) -> bool:\\n return await self._backend.disconnect()\",\n \"async def test_disconnect_on_drop_outgoing(self, client, dropper, leak_tracker):\\n leak_tracker.set_initial_object_list()\\n\\n await client.connect()\\n assert client.connected\\n dropper.drop_outgoing()\\n\\n while client.connected:\\n await asyncio.sleep(1)\\n\\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\\n dropper.restore_all()\\n while not client.connected:\\n await asyncio.sleep(1)\\n\\n leak_tracker.check_for_leaks()\",\n \"def test_send_disconnected(connection, writer, schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n connection.send(\\\"test\\\")\\n assert not writer.used\",\n \"def on_disconnect(unused_client, unused_userdata, rc):\\n\\tprint('on_disconnect', error_str(rc))\\n\\n\\t# Since a disconnect occurred, the next loop iteration will wait with\\n\\t# exponential backoff.\\n\\tglobal should_backoff\\n\\tshould_backoff = True\",\n \"async def test_close_old_keeped_conn(app, aiohttp_server):\\n server1 = await aiohttp_server(app)\\n server2 = await aiohttp_server(app)\\n url1 = \\\"http://localhost:%d\\\" % server1.port\\n url2 = \\\"http://localhost:%d\\\" % server2.port\\n connector = TCPConnector(pool_size=1, connection_cls=MyConnection)\\n async with aiosonic.HTTPClient(connector) as client:\\n await client.get(url1)\\n # get used writer\\n async with await connector.pool.acquire() as connection:\\n writer = connection.writer\\n\\n await client.get(url2)\\n # python 3.6 doesn't have writer.is_closing\\n is_closing = getattr(writer, \\\"is_closing\\\", writer._transport.is_closing)\\n\\n # check that old writer is closed\\n assert is_closing()\\n await server1.close()\\n await server2.close()\",\n \"def connection_closed(self):\\n self.atv = None\\n self._start_connect_loop()\\n self._update_state(disconnected=True)\",\n \"def test_disconnect():\\n PV_name = \\\"TEST:TEST.VAL\\\"\\n casput(PV_name, 1)\\n assert casget(PV_name) == 1\\n assert caget(PV_name) == 1\\n casdel(PV_name)\\n assert casget(PV_name) is None\\n from time import sleep\\n sleep(1)\\n assert caget(PV_name) is None\",\n \"def test_invalid_disconnect(self):\\n mediator = Mediator()\\n try:\\n mediator.disconnect(\\\"foo\\\", self.dog.set_sound)\\n mediator.disconnect(\\\"bar\\\", self.cat.set_sound)\\n except:\\n raise AssertionError()\",\n \"def test_control(self, ping_fixture):\\n engine = ping_fixture\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def connection_lost(self, exc):\\n if not self._closing:\\n self._closing = True\\n self.log.info('{about}{reason}'.format(\\n about=self.__str__(),\\n reason=': {}'.format(exc) if exc is not None else ''))\\n self.waiter_connected.cancel()\\n self.waiter_closed.set_result(self)\",\n \"def __del__(self):\\n if self.connection is not None:\\n self.connection.close()\\n print(\\\"Connection closed\\\")\\n return 0\",\n \"def test_is_connected__not_connection(self):\\n self.switch.connection = None\\n self.switch.is_active = MagicMock()\\n self.switch.is_active.return_value = True\\n\\n self.assertFalse(self.switch.is_connected())\",\n \"def disconnect():\\r\\n try:\\r\\n global connection\\r\\n global cursor\\r\\n\\r\\n connection.close()\\r\\n logger.info(\\\"The SQLite connection is closed\\\")\\r\\n\\r\\n except sqlite3.Error as error:\\r\\n logger.error(f\\\"Error while connecting to sqlite: {error}\\\")\",\n \"def ensure_node_disconnected(node):\\n for inplug, outplug in node.listConnections(plugs=True, connections=True):\\n try:\\n outplug.disconnect(inplug)\\n # That the lazy way, if disconnection fail, that because inplug and outplug\\n # are reversed ...\\n except RuntimeError:\\n inplug.disconnect(outplug)\",\n \"async def disconnect(self):\\n self.logger.info(f'disconnecting from {self.dsn}')\\n await self.dbase.disconnect()\",\n \"async def on_disconnect(self, reconnecting):\\n pass\",\n \"def the_current_device_is_disconnected():\\n assert web_app.disconnect_from_device()\",\n \"def user_is_disconnected_from_all_devices():\\n assert web_app.disconnect_from_device()\",\n \"def test_reconnect_another(self):\\n line, head = self._get_line()\\n self.tool.connect(line, head, (120, 50))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n item = cinfo.connected\\n port = cinfo.port\\n constraint = cinfo.constraint\\n\\n assert item == self.box1\\n assert port == self.box1.ports()[0]\\n assert item != self.box2\\n\\n # connect to box2, handle's connected item and connection data\\n # should differ\\n self.tool.connect(line, head, (120, 150))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n self.assertEqual(self.box2, cinfo.connected)\\n self.assertEqual(self.box2.ports()[0], cinfo.port)\\n\\n # old connection does not exist\\n self.assertNotEqual(item, cinfo.connected)\\n self.assertNotEqual(constraint, cinfo.constraint)\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.conn.close()\\n if exc_val:\\n raise\",\n \"def test_unregisterProducerAfterDisconnect(self):\\n reactor = self.buildReactor()\\n self.listen(reactor, ServerFactory.forProtocol(ClosingProtocol))\\n\\n finished = Deferred()\\n finished.addErrback(log.err)\\n finished.addCallback(lambda ign: reactor.stop())\\n\\n writing = []\\n\\n class ClientProtocol(Protocol):\\n \\\"\\\"\\\"\\n Protocol to connect, register a producer, try to lose the\\n connection, wait for the server to disconnect from us, and then\\n unregister the producer.\\n \\\"\\\"\\\"\\n\\n def connectionMade(self):\\n log.msg(\\\"ClientProtocol.connectionMade\\\")\\n self.transport.registerProducer(\\n _SimplePullProducer(self.transport), False\\n )\\n self.transport.loseConnection()\\n\\n def connectionLost(self, reason):\\n log.msg(\\\"ClientProtocol.connectionLost\\\")\\n self.unregister()\\n writing.append(self.transport in _getWriters(reactor))\\n finished.callback(None)\\n\\n def unregister(self):\\n log.msg(\\\"ClientProtocol unregister\\\")\\n self.transport.unregisterProducer()\\n\\n clientFactory = ClientFactory()\\n clientFactory.protocol = ClientProtocol\\n self.connect(reactor, clientFactory)\\n self.runReactor(reactor)\\n self.assertFalse(writing[0], \\\"Transport was writing after unregisterProducer.\\\")\",\n \"def close_connection_if_open():\\n\\ttry:\\n\\t\\tconn = flask.g._database_connection\\n\\texcept AttributeError:\\n\\t\\tpass\\n\\telse:\\n\\t\\tconn.close()\\n\\t\\tdel flask.g._database_connection\",\n \"def testConnectionMade(self):\\n d = self._getClientConnection()\\n d.addCallback(lambda _: self.client.disconnect())\\n return d\",\n \"def pool(self):\\n connection_ok = False\\n sanity_check = 0\\n sanity_threshold = 10\\n\\n while connection_ok == False:\\n conn = self._get_pool().acquire()\\n\\n try:\\n conn.ping()\\n connection_ok = True\\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 sanity_check += 1\\n if sanity_check > sanity_threshold:\\n raise self.Database_Error, ('Session droped from the pool... %s More details http://ora-%s.ora-code.com/') %(error.message, error.code)\\n\\n logger.warning(\\\"Found a dead connection. Dropping from pool.\\\")\\n pool.drop(conn)\\n\\n conn.autocommit = 1 # This read-write attribute determines whether autocommit mode is on or off.\\n\\n return conn\",\n \"def test_close_cnxn():\\n\\n cnxn = connect()\\n cursor = cnxn.cursor()\\n\\n cursor.execute(\\\"drop table if exists t1\\\")\\n cursor.execute(\\\"create table t1(id integer, s varchar(20))\\\")\\n cursor.execute(\\\"insert into t1 values (?,?)\\\", 1, 'test')\\n cursor.execute(\\\"select * from t1\\\")\\n\\n cnxn.close()\\n\\n # Now that the connection is closed, we expect an exception. (If the code attempts to use\\n # the HSTMT, we'll get an access violation instead.)\\n with pytest.raises(pyodbc.ProgrammingError):\\n cursor.execute(\\\"select * from t1\\\")\",\n \"def disconnect_once(self):\\n\\t\\tif not self.isdisconnected:\\n\\t\\t\\tself.disconnect()\\n\\t\\t\\tself.isdisconnected = True\",\n \"def disconnect(self):\\n _abstract()\",\n \"def disconnect(self):\\n _abstract()\",\n \"async def __aexit__(self, exc_type, exc_value, traceback):\\n\\n # Close the connection\\n await self.disconnect()\",\n \"async def disconnect(self) -> None:\\n\\n # Possible states left: _NOT_RUNNING, _CONNECTING, _RUNNING,\\n # _RECONNECTING, _DISCONNECTING\\n\\n # Waiting until the current connection attempt is finished. Using a\\n # while loop since the event loop might have started to reconnect again\\n # while the await is still waiting.\\n while self._state in [self._CONNECTING, self._RECONNECTING]:\\n # After _CONNECTING, the state can either be _NOT_RUNNING or\\n # _RUNNING. After _RECONNECTING, the state must be _RUNNING.\\n async with self._connected_condition:\\n await self._connected_condition.wait()\\n\\n # Possible states left: _NOT_RUNNING, _RUNNING, _DISCONNECTING\\n\\n if self._state == self._NOT_RUNNING:\\n # No need to do anything since we're already disconnected\\n logger.debug(\\\"Already disconnected\\\")\\n return\\n\\n # Possible states left: _RUNNING, _DISCONNECTING\\n\\n if self._state == self._DISCONNECTING:\\n # Wait until the disconnecting currently going on is complete. This\\n # is to prevent the disconnect() function from ever returning\\n # without the disconnecting process being finished.\\n logger.debug(\\\"Already disconnecting, waiting for it to finish...\\\")\\n async with self._disconnected_condition:\\n await self._disconnected_condition.wait()\\n\\n logger.debug(\\\"Disconnected, finished waiting\\\")\\n return\\n\\n # Possible states left: _RUNNING\\n\\n # By principle of exclusion, the only state left is _RUNNING. Doing an\\n # explicit check though, just to make sure.\\n if self._state != self._RUNNING:\\n raise IncorrectStateException(\\\"This should never happen.\\\")\\n\\n\\n logger.debug(\\\"Disconnecting...\\\")\\n self._events.fire(\\\"disconnecting\\\")\\n\\n # Now we're sure we're in the _RUNNING state, we can set our state.\\n # Important: No await-ing has occurred between checking the state and\\n # setting it.\\n self._state = self._DISCONNECTING\\n\\n await self._disconnect()\\n\\n # We know that _event_loop is not None, but this is to keep mypy happy.\\n logger.debug(\\\"Waiting for event loop\\\")\\n if self._event_loop is not None:\\n await self._event_loop\\n self._event_loop = None\\n\\n self._state = self._NOT_RUNNING\\n\\n # Notify all other disconnect()s waiting\\n logger.debug(\\\"Sending disconnected notification\\\")\\n async with self._disconnected_condition:\\n self._disconnected_condition.notify_all()\\n\\n logger.debug(\\\"Disconnected\\\")\",\n \"def disconnect():\\n return c.close()\",\n \"def disconnect(self):\\n\\n if self.connect:\\n Disconnect(self.connect)\",\n \"def __exit__(self, exc_type, exc_value, tb):\\n if exc_type is not None:\\n traceback.print_exception(exc_type, exc_value, tb)\\n # return False # uncomment to pass exception through\\n\\n return True \\n\\n self.db = None\\n self.client.close()\\n\\n return True\",\n \"def disconnect(self):\\n logger.debug(\\\"disconnecting\\\")\\n if self.connected and self.conn:\\n self.can_listen = False\\n self.conn.close()\\n self.connected = False\",\n \"def test_is_connected__not_alive(self):\\n connection = MagicMock()\\n connection.is_alive.return_value = True\\n connection.is_established.return_value = True\\n self.switch.connection = connection\\n self.switch.is_active = MagicMock()\\n self.switch.is_active.return_value = False\\n\\n self.assertFalse(self.switch.is_connected())\",\n \"def testConnectionLost(self):\\n d = self.testSimpleRequest()\\n d.addCallback(lambda _: self.factory.crash())\\n d.addCallback(lambda _: self.client.check_rate_limit())\\n d.addTimeout(0.01, reactor)\\n self.assertFailure(d, ConnectionClosed)\\n return d\",\n \"def disconnect_db(self) -> None:\",\n \"def DBDisconnect(self):\\n if self._dbh:\\n self._dbh.close()\\n self._dbh = None\",\n \"def __del__(self):\\n if self.connection_obj:\\n self.logger.info('Disconnecting from host {0}:{1}'.format(self.host, self.port))\\n Disconnect(self.connection_obj)\",\n \"async def disconnect(self):\\r\\n from asyncio import shield\\r\\n if self._session is not None:\\r\\n await shield(self._session.connector.close())\\r\\n await shield(self._session.close())\\r\\n self._session = None\",\n \"def test_dead_node(self):\\r\\n self.pool._hosts.append(self.host)\\r\\n\\r\\n # cursor mock needed so set_cql_version doesn't crap out\\r\\n ok_cur = MagicMock()\\r\\n\\r\\n ok_conn = MagicMock()\\r\\n ok_conn.return_value = ok_cur\\r\\n\\r\\n\\r\\n returns = [CQLEngineException(), ok_conn]\\r\\n\\r\\n def side_effect(*args, **kwargs):\\r\\n result = returns.pop(0)\\r\\n if isinstance(result, Exception):\\r\\n raise result\\r\\n return result\\r\\n\\r\\n with patch('cqlengine.connection.cql.connect') as mock:\\r\\n mock.side_effect = side_effect\\r\\n conn = self.pool._create_connection()\",\n \"def disconnect(self):\\n print(\\\"<== Conexión cerrada ==>\\\")\\n self.is_alive = False\\n self._socket.close()\",\n \"def test_reconnect_same(self):\\n line, head = self._get_line()\\n self.tool.connect(line, head, (120, 50))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n item = cinfo.connected\\n port = cinfo.port\\n constraint = cinfo.constraint\\n\\n assert item == self.box1\\n assert item != self.box2\\n\\n # connect to box1 again, handle's connected item and port should be\\n # the same but connection constraint will differ\\n connected = self.tool.connect(line, head, (120, 50))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n self.assertEqual(self.box1, cinfo.connected)\\n self.assertEqual(self.box1.ports()[0], cinfo.port)\\n self.assertNotEqual(constraint, cinfo.constraint)\",\n \"def _check_closed(self):\\n if self.closed:\\n raise Error(\\\"cursor is closed\\\")\\n if self.session.closed:\\n raise Error(\\\"connection is closed\\\")\",\n \"def disconnect():\\n logging.info('Client disconnected')\",\n \"def connection_lost(self, exc):\\n if self._closing:\\n return\\n self._closing = True\\n\\n # inform yielding readers about closed connection\\n if exc is None:\\n logger.info(\\\"Connection closed for %s\\\", self)\\n self.reader.feed_eof()\\n else:\\n logger.info(\\\"Connection lost for %s: %s\\\", self, exc)\\n self.reader.set_exception(exc)\\n\\n # cancel protocol tasks, namely on-connect negotiations\\n for task in self._tasks:\\n task.cancel()\\n\\n # close transport (may already be closed), set _waiter_closed and\\n # cancel Future _waiter_connected.\\n self._transport.close()\\n self._waiter_connected.cancel()\\n if self.shell is None and self._waiter_closed is not None:\\n # raise deprecation warning, _waiter_closed should not be used!\\n self._waiter_closed.set_result(weakref.proxy(self))\\n\\n # break circular references.\\n self._transport = None\",\n \"def test_connection_is_established(self):\\n for conn in self.connections:\\n assert conn.is_connected is True\",\n \"def connection_teardown():\\n test_str = make_random(100)\\n server = start_server()\\n client = start_client()\\n\\n # First write some data at both ends.\\n write_to(client, test_str)\\n write_to(server, test_str)\\n time.sleep(TEST_TIMEOUT)\\n\\n # Write EOFs on both sides.\\n write_to(client, '\\\\x1a')\\n write_to(server, '\\\\x1a')\\n client.stdin.close()\\n server.stdin.close()\\n time.sleep(TEST_TIMEOUT)\\n\\n return (\\n DEBUG_TEARDOWN in read_debug_messages_from(client) and\\n DEBUG_TEARDOWN in read_debug_messages_from(server)\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71215147","0.7030726","0.70195895","0.6962915","0.6929336","0.68194956","0.6759856","0.6750204","0.6691207","0.6621002","0.6536765","0.64876175","0.64719003","0.6469791","0.6457137","0.6449306","0.640901","0.63973737","0.6388318","0.6374561","0.6314033","0.629048","0.6260235","0.6244741","0.62283593","0.61635995","0.61530447","0.61423993","0.6120438","0.60970175","0.60969055","0.6093179","0.6065188","0.60468173","0.60230106","0.5991233","0.5961435","0.59353125","0.5905923","0.5904955","0.5899475","0.5897212","0.5882771","0.5872096","0.58657956","0.5858483","0.5857206","0.5852091","0.5846886","0.5832087","0.58186704","0.5817377","0.5803522","0.58013743","0.5796023","0.57925767","0.57906395","0.57896614","0.5774978","0.57749736","0.57719433","0.5769012","0.57598084","0.57551885","0.5751024","0.5749269","0.57258606","0.5723364","0.5721955","0.5721337","0.5717092","0.5698255","0.56926286","0.56905","0.5688913","0.5686956","0.5682092","0.5681212","0.5676428","0.5676428","0.5669384","0.56662863","0.5655679","0.5654959","0.56525713","0.5650239","0.56500465","0.56479543","0.5645964","0.5633289","0.5627986","0.5625658","0.5617007","0.5612005","0.561074","0.561027","0.5608892","0.56086516","0.56070596","0.56064093"],"string":"[\n \"0.71215147\",\n \"0.7030726\",\n \"0.70195895\",\n \"0.6962915\",\n \"0.6929336\",\n \"0.68194956\",\n \"0.6759856\",\n \"0.6750204\",\n \"0.6691207\",\n \"0.6621002\",\n \"0.6536765\",\n \"0.64876175\",\n \"0.64719003\",\n \"0.6469791\",\n \"0.6457137\",\n \"0.6449306\",\n \"0.640901\",\n \"0.63973737\",\n \"0.6388318\",\n \"0.6374561\",\n \"0.6314033\",\n \"0.629048\",\n \"0.6260235\",\n \"0.6244741\",\n \"0.62283593\",\n \"0.61635995\",\n \"0.61530447\",\n \"0.61423993\",\n \"0.6120438\",\n \"0.60970175\",\n \"0.60969055\",\n \"0.6093179\",\n \"0.6065188\",\n \"0.60468173\",\n \"0.60230106\",\n \"0.5991233\",\n \"0.5961435\",\n \"0.59353125\",\n \"0.5905923\",\n \"0.5904955\",\n \"0.5899475\",\n \"0.5897212\",\n \"0.5882771\",\n \"0.5872096\",\n \"0.58657956\",\n \"0.5858483\",\n \"0.5857206\",\n \"0.5852091\",\n \"0.5846886\",\n \"0.5832087\",\n \"0.58186704\",\n \"0.5817377\",\n \"0.5803522\",\n \"0.58013743\",\n \"0.5796023\",\n \"0.57925767\",\n \"0.57906395\",\n \"0.57896614\",\n \"0.5774978\",\n \"0.57749736\",\n \"0.57719433\",\n \"0.5769012\",\n \"0.57598084\",\n \"0.57551885\",\n \"0.5751024\",\n \"0.5749269\",\n \"0.57258606\",\n \"0.5723364\",\n \"0.5721955\",\n \"0.5721337\",\n \"0.5717092\",\n \"0.5698255\",\n \"0.56926286\",\n \"0.56905\",\n \"0.5688913\",\n \"0.5686956\",\n \"0.5682092\",\n \"0.5681212\",\n \"0.5676428\",\n \"0.5676428\",\n \"0.5669384\",\n \"0.56662863\",\n \"0.5655679\",\n \"0.5654959\",\n \"0.56525713\",\n \"0.5650239\",\n \"0.56500465\",\n \"0.56479543\",\n \"0.5645964\",\n \"0.5633289\",\n \"0.5627986\",\n \"0.5625658\",\n \"0.5617007\",\n \"0.5612005\",\n \"0.561074\",\n \"0.561027\",\n \"0.5608892\",\n \"0.56086516\",\n \"0.56070596\",\n \"0.56064093\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7141908"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84665,"cells":{"query":{"kind":"string","value":"test the fixture raises on connect"},"document":{"kind":"string","value":"def test_control(self, ping_fixture):\n engine = ping_fixture\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()"},"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 test_connection_fail(context_fixture):\n with pytest.raises(SystemExit):\n context_fixture('RequestException')","def test_passing_bad_connection(self):\n self.assertRaises(\n ConnectionError, Pet.init_db, Redis(host=\"127.0.0.1\", port=6300)\n )\n self.assertIsNone(Pet.redis)\n # Reestablish good connection\n Pet.init_db()","def test_exceptions_in_server_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n raise SentinelException()\n\n def client_callback(*args): # pragma: nocover\n pytest.fail(\"Should not be called\")\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_connect_fail(self, req):\n req.side_effect = ks_exc.ConnectFailure()\n self.client._get_resource_provider(self.context, \"fake\")\n\n # reset the call count to demonstrate that future calls do\n # work\n req.reset_mock()\n self.client._get_resource_provider(self.context, \"fake\")\n self.assertTrue(req.called)","def test_exceptions_in_client_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n return self.sample_ocsp_data\n\n def client_callback(*args):\n raise SentinelException()\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_connect_fail(self):\n with pytest.raises(InstrumentGatewayError):\n with InstrumentGateway(addr='an invalid ip!'):\n pass","def test_connectFailure(self):\n db = Database.TestDB(self.mktemp())\n # Make _db_init fail\n db._db_init = lambda: 1 / 0\n self.assertFalse(db.initialized)\n try:\n yield db.open()\n except:\n pass\n self.assertFalse(db.initialized)\n self.assertEquals(db.pool, None)","def test_connect_error():\n queue = RedisQueue('localhost')\n assert not queue.is_connected\n with pytest.raises(ConnectionError):\n queue.put('test')\n with pytest.raises(ConnectionError):\n queue.get()","def test_connect(server):\n assert server","def test_vogeler_client_failure(self):\n with self.assertRaises(Exception):\n VogelerClient(callback_function=self.echo, role='client', dsn=self.bad_amqp_dsn)","def setUp(self):\n\t\tself.conn = Client([\"127.0.0.1:11211\"], debug = 1)","def test_manage():\n assert isinstance(hug_peewee.connection.manage(api), SqliteDatabase)\n assert isinstance(hug_peewee.connection.manage(api, location='connection_testing.db'), SqliteDatabase)\n assert hug.test.get(api, 'fake_endpoint').data == True\n\n with pytest.raises(ValueError):\n hug_peewee.connection.manage(api, engine=\"Reese's Petabyte Cup\") # I also wish this existed!","async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\n config_entry = MockConfigEntry(\n domain=DOMAIN,\n unique_id=MAC,\n data={CONF_HOST: HOST, KEY_MAC: MAC},\n )\n config_entry.add_to_hass(hass)\n\n mock_daikin.factory.side_effect = ClientConnectionError\n await hass.config_entries.async_setup(config_entry.entry_id)\n await hass.async_block_till_done()\n\n assert config_entry.state == ConfigEntryState.SETUP_RETRY","def test_004_connect(self):\n HEADING()\n self.db.connect()\n\n result = True\n assert result","def test_connection_failure(aggregator, check, bad_instance):\n instance_tags = [\"supervisord_server:travis\"]\n with pytest.raises(Exception):\n check.check(bad_instance)\n aggregator.assert_service_check(\"supervisord.can_connect\", status=check.CRITICAL, tags=instance_tags, count=1)","def test_connect_not_called():\n config = {\"listeners\": \"localhost:8080\"}\n registry = Registry()\n registry.new(name=\"test\", backend=\"dummy\", **config)\n\n dummy = registry[\"test\"]\n dummy.publish(topic=\"mytopic\", message=\"howl1\")\n dummy.publish(topic=\"mytopic\", message=\"howl2\")\n dummy.publish(topic=\"mytopic\", message=\"howl3\")\n dummy._connect.assert_called_once()","def test_connection():\r\n try:\r\n connect()\r\n except:\r\n pass\r\n print ('Unable to connect.')\r\n else:\r\n main()","def test_connect_invalid_string(self):\n with pytest.raises(ValueError):\n DatabaseDriver.connect('not a valid connect string')","def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_database_connection(self):\n\t\t\n\t\tself.assertTrue(database.connect())","def test_exception_with_callback(self):\n test_utils.generate_test_config_file()\n\n exception_callback = mock.Mock()\n\n client = PowerTrackClient(_dummy_callback, exception_callback,\n config_file_path=config_file)\n client.connect()\n client.disconnect()\n self.assertTrue(exception_callback.called)\n actual_exinfo = exception_callback.call_args[0][0]\n actual_ex = actual_exinfo[1]\n self.assertIsInstance(actual_ex, Exception)\n self.assertEqual(actual_ex.message, \"This is a test exception\")","def test_connection_error(self, bad_mock):\n bad_mock.side_effect = ConnectionError()\n self.assertRaises(DatabaseConnectionError, Promotion.init_db, 'test')","def test_parse_message_failure_connect(self):\n for test_case in self.failure_test_params_wrong_connect:\n expected = test_case[KEY_EXPECTED]\n mock_connect = app.on_connect()\n\n self.assertNotEqual(expected, mock_connect)","def setUp(self):\n self.c = Client(host=\"localhost\")","def test_connection_duplication():","def test_check_connection(self):\n self.assertIsNotNone(app.check_connection())","def test_handle_calls(tchannel_pair):\n class _MyException(Exception):\n pass\n\n def my_handler(context, connection):\n raise _MyException()\n\n server, client = tchannel_pair\n client.ping()\n with pytest.raises(_MyException):\n server.handle_calls(my_handler)","def test_init_server_make_connection_fail(self, mock_make_conn_func,\n mock_stop_func):\n mock_make_conn_func.side_effect = Exception('ha')\n\n with self.assertRaisesRegex(Exception, 'ha'):\n self.client.initialize()\n mock_stop_func.assert_called()","def test_redis_connection_error(self):\n with patch(\"redis.Redis.ping\") as ping_error_mock:\n ping_error_mock.side_effect = ConnectionError()\n self.assertRaises(ConnectionError, Pet.init_db)\n self.assertIsNone(Pet.redis)\n Pet.init_db()","def test_connect(self):\n db = Database.TestDB(self.mktemp())\n self.assertFalse(db.initialized)\n yield db.open()\n self.assertTrue(db.initialized)\n db.close()","def test_connect(rgd):\n assert rgd.connected is True","def test_connect_db_to_query(db):\n assert 1","def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()","def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_xfail_fixture(broken_fixture):\n pass","def test_verify_connection_to_a_device():","def test_connect(connection, events, writer, schedule, flush):\n schedule(connection.connect())\n flush()\n assert connection.connected\n assert not writer.closed\n assert events.triggered(\"CLIENT_CONNECT\")","def setUpFixture(self):\n pass","def test_passing_connection(self):\n Pet.init_db(Redis(host=REDIS_HOST, port=REDIS_PORT))\n self.assertIsNotNone(Pet.redis)","def test_setup(self):\n with pytest.raises(NotImplementedError):\n self.handler.setup()","def setUp(self):\n self.a = backend.dbconnection.DBConnect()","def test_create_unexpected_error(self, data, requests_mock, capsys):\n requests_mock.post(base_url, exc=ConnectionError)\n with pytest.raises(ConnectionError):\n r = operations.create(base_url, data=data)\n assert 'Unexpected error when connecting to' in capsys.readouterr().out","def test_hubs_fail(self):\n with self.assertRaises(AssertionError):\n self.resource.hubs(-1)","def test_connection(self):\n r = main.List.connection()\n self.assertTrue(r.ping(), \"Connection failed.\")","def test_connection(self):\n self._bind_to_service()","def test_connection_is_established(self):\n assert self.connection_client_1.is_connected is True\n assert self.connection_client_2.is_connected is True","def test_connect_called_once():\n config = {\"listeners\": \"localhost:8080\"}\n registry = Registry()\n registry.new(name=\"test\", backend=\"dummy\", **config)\n\n dummy = registry[\"test\"]\n dummy._connect.assert_called_once()","def test_for_client():","def testConnectionMade(self):\n d = self._getClientConnection()\n d.addCallback(lambda _: self.client.disconnect())\n return d","async def test_connect_error_with_no_server(event_loop):\n client = SMTP(hostname=\"127.0.0.1\", port=65534, loop=event_loop)\n\n with pytest.raises(SMTPConnectError):\n await client.connect(timeout=0.1)","def test_connection_raises_error(self, mock_execute, mock_parse):\n mock_parse.return_value = ARGS_INPUT\n result = CONNECTION2\n mock_execute.return_value = result\n with self.assertRaises(MyError):\n connection_to_client()","def setUp(self):\r\n\r\n \r\n self.client = app.test_client()\r\n # Show Flask errors that happen during tests\r\n app.config['TESTING'] = True\r\n \r\n connect_to_db(server.app)\r\n db.create_all()\r\n test_seed.create_test_data()","async def test_setup_failed_connect(\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\n) -> None:\n respx.get(\"http://localhost\").mock(\n side_effect=httpx.RequestError(\"server offline\", request=MagicMock())\n )\n assert await async_setup_component(\n hass,\n SENSOR_DOMAIN,\n {\n SENSOR_DOMAIN: {\n \"platform\": DOMAIN,\n \"resource\": \"http://localhost\",\n \"method\": \"GET\",\n }\n },\n )\n await hass.async_block_till_done()\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\n assert \"server offline\" in caplog.text","def test_mysql_connect_fail(self):\n if _is_backend_avail('mysql', user=\"openstack_cifail\"):\n self.fail(\"Shouldn't have connected\")","def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_wrong_args(self, bad_context):\n with pytest.raises(TypeError):\n Connection(bad_context)","def _fixture(\n self,\n dialect_name,\n exception,\n db_stays_down,\n is_disconnect=True,\n ):\n connect_args = {}\n patchers = []\n db_disconnected = False\n\n class DisconnectCursorMixin:\n def execute(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return super().execute(*arg, **kw)\n\n if dialect_name == \"postgresql\":\n import psycopg2.extensions\n\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\n pass\n\n connect_args = {\"cursor_factory\": Curs}\n\n elif dialect_name == \"mysql\":\n import pymysql\n\n def fake_ping(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return True\n\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\n pass\n\n connect_args = {\"cursorclass\": Curs}\n\n patchers.append(\n mock.patch.object(\n pymysql.Connection, \"ping\", fake_ping\n )\n )\n else:\n raise NotImplementedError()\n\n with mock.patch.object(\n compat,\n \"native_pre_ping_event_support\",\n self.native_pre_ping,\n ):\n engine = engines.create_engine(\n self.engine.url, max_retries=0)\n\n # 1. override how we connect. if we want the DB to be down\n # for the moment, but recover, reset db_disconnected after\n # connect is called. If we want the DB to stay down, then\n # make sure connect raises the error also.\n @event.listens_for(engine, \"do_connect\")\n def _connect(dialect, connrec, cargs, cparams):\n nonlocal db_disconnected\n\n # while we're here, add our cursor classes to the DBAPI\n # connect args\n cparams.update(connect_args)\n\n if db_disconnected:\n if db_stays_down:\n raise exception\n else:\n db_disconnected = False\n\n # 2. initialize the dialect with a first connect\n conn = engine.connect()\n conn.close()\n\n # 3. add additional patchers\n patchers.extend([\n mock.patch.object(\n engine.dialect.dbapi,\n \"Error\",\n self.Error,\n ),\n mock.patch.object(\n engine.dialect,\n \"is_disconnect\",\n mock.Mock(return_value=is_disconnect),\n ),\n ])\n\n with test_utils.nested(*patchers):\n # \"disconnect\" the DB\n db_disconnected = True\n yield engine","def test_connection_raises_message_error(self, mock_execute, mock_parse):\n mock_parse.return_value = ARGS_INPUT\n result = CONNECTION4\n mock_execute.return_value = result\n with self.assertRaises(MyError):\n connection_to_client()","def setUp(self):\n self.conn = seed.connect_to_db(\"testing\")\n self.cur = self.conn.cursor()\n\n # setting cur and conn in seed to test cur and conn (if we don't do this we get a 'cur is undefined' error)\n seed.cur = self.conn.cursor()\n seed.conn = self.conn","def test_start_tasks_db_raises():\n with pytest.raises(ValueError) as excinfo:\n tasks.start_tasks_db('some/great/path', 'mysql')\n exception_msg = excinfo.value.args[0]\n assert exception_msg == \"db_type must be a 'tiny' or 'mongo'\"","def setUp(self):\n self.client = DummyClient()","def test_database_can_connect():\n\n assert \"sqlite\" in settings.database_uri","def test_connect_traced():\n with override_config(\"psycopg\", {\"trace_connect\": True}):\n conn = psycopg.connect(**POSTGRES_CONFIG)\n assert conn","def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\n\n engine = ping_fixture_all_errs_disconnect\n\n conn = engine.connect()\n conn.close()","def test_connection_is_established(self):\n assert self.connection_node_1.is_connected is True\n assert self.connection_node_2.is_connected is True\n assert self.connection_client_1.is_connected is True\n assert self.connection_client_2.is_connected is True","def test_connection_is_established(self):\n for conn in self.connections:\n assert conn.is_connected is True","def test_connect_traced():\n with override_config(\"psycopg\", {\"trace_connect\": True}):\n conn = psycopg2.connect(**POSTGRES_CONFIG)\n assert conn","def test_connect_refused(self):\n client = socket_any_family()\n context = Context(SSLv23_METHOD)\n clientSSL = Connection(context, client)\n # pytest.raises here doesn't work because of a bug in py.test on Python\n # 2.6: https://github.com/pytest-dev/pytest/issues/988\n try:\n clientSSL.connect((loopback_address(client), 1))\n except error as e:\n exc = e\n assert exc.args[0] == ECONNREFUSED","def test_client_create(self):\n pass","def test_connectEvent(self):\n reactor = self.buildReactor()\n\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\n connected = []\n\n class CheckConnection(Protocol):\n def connectionMade(self):\n connected.append(self)\n reactor.stop()\n\n clientFactory = Stop(reactor)\n clientFactory.protocol = CheckConnection\n\n needsRunningReactor(reactor, lambda: self.connect(reactor, clientFactory))\n\n reactor.run()\n\n self.assertTrue(connected)","def test_connection_raises_error(self, mock_execute, mock_parse):\n mock_parse.return_value = ARGS_INPUT\n result = CONNECTION2\n mock_execute.return_value = result\n with self.assertRaises(MyError):\n connection_to_server()","def test_connection_raises_message_error(self, mock_execute, mock_parse):\n mock_parse.return_value = ARGS_INPUT\n result = CONNECTION4\n mock_execute.return_value = result\n with self.assertRaises(MyError):\n connection_to_server()","def test_connection(self) -> None:\n test_connection_fn = get_test_connection_fn(self.service_connection)\n test_connection_fn(self.engine)","async def test_datasets_access_call_exception(self):\n pool = asynctest.CoroutineMock()\n pool.acquire().__aenter__.return_value = ConnectionException()\n with self.assertRaises(aiohttp.web_exceptions.HTTPInternalServerError):\n await fetch_datasets_access(pool, None)","def test_db_connection_bad_host():\n\n with pytest.raises(AddressError, match=r\"Cannot resolve address .*\"):\n\n from cwf2neo.neo4j import Neo4j\n\n db = Neo4j(host=\"invalidneo4jhostname\")\n\n db.graph.database.name","def test_listen_server(self):\n self.assertRaises(vk.listen_stream(self._stream))","def test_create_client(self):\n pass","def test_connect_success():\n\n t = Thread(target=setup_socket)\n t.start()\n\n data_sender = DataSender('127.0.0.1', 12345)\n server_response = data_sender.notify('test')\n\n assert server_response == 'ok'\n\n data_sender.close()\n t.join()","def test_dead_node(self):\r\n self.pool._hosts.append(self.host)\r\n\r\n # cursor mock needed so set_cql_version doesn't crap out\r\n ok_cur = MagicMock()\r\n\r\n ok_conn = MagicMock()\r\n ok_conn.return_value = ok_cur\r\n\r\n\r\n returns = [CQLEngineException(), ok_conn]\r\n\r\n def side_effect(*args, **kwargs):\r\n result = returns.pop(0)\r\n if isinstance(result, Exception):\r\n raise result\r\n return result\r\n\r\n with patch('cqlengine.connection.cql.connect') as mock:\r\n mock.side_effect = side_effect\r\n conn = self.pool._create_connection()","def test_loginException(self):\n\n class UnexpectedException(Exception):\n \"\"\"\n An unexpected exception.\n \"\"\"\n\n def raisesUnexpectedException(user, passwd):\n raise UnexpectedException(\"Whoops\")\n\n self.server.authenticateLogin = raisesUnexpectedException\n\n def login():\n return self.client.login(b'testuser', b'password-test')\n\n d1 = self.connected.addCallback(strip(login))\n\n d1.addErrback(self.assertClientFailureMessage, b\"Server error: Whoops\")\n\n @d1.addCallback\n def assertErrorLogged(_):\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\n\n d1.addErrback(self._ebGeneral)\n d1.addBoth(self._cbStopClient)\n\n d2 = self.loopback()\n d = defer.gatherResults([d1, d2])\n return d.addCallback(self._cbTestFailedLogin)","def test_missing(server):\n\n assert \"non_existing_database\" not in server\n with pytest.raises(excepts.DBNotExists):\n server[\"non_existing_database\"]","async def test_bus_fixture(bus: lightbus.BusNode):\n\n pool_rpc = await bus.bus_client.rpc_transport.get_redis_pool()\n pool_result = await bus.bus_client.result_transport.get_redis_pool()\n pool_event = await bus.bus_client.event_transport.get_redis_pool()\n\n with await pool_rpc as redis_rpc, await pool_result as redis_result, await pool_event as redis_event:\n # Each transport should have its own connection\n assert redis_rpc is not redis_result\n assert redis_result is not redis_event\n assert redis_rpc is not redis_event\n\n # Check they are all looking at the same redis instance\n await redis_rpc.set('X', 1)\n assert await redis_result.get('X')\n assert await redis_rpc.get('X')\n\n info = await redis_rpc.info()\n assert int(info['clients']['connected_clients']) == 3","async def test_connection(self):\n await self.webhook_connection.connect()\n assert self.webhook_connection.is_connected is True","def test_check_health_fail(self):\n dbmock = self.db.db = MagicMock()\n\n def throw(*_, **__):\n \"\"\"Throw an exception\"\"\"\n raise redis.RedisError(\"DB exception\")\n\n dbmock.ping.side_effect = throw\n ok, msg = self.db.check_health()\n self.assertFalse(ok)","def test_error(self, mock_validate_session):\n mock_validate_session.return_value = False\n with pytest.raises(SystemExit) as ctx:\n celery_command.worker(Namespace(queues=1, concurrency=1))\n assert str(ctx.value) == \"Worker exiting, database connection precheck failed.\"","def setUp(self):\n self.store = yield buildStore(self, None)\n\n def doit(txn):\n return txn.execSQL(schemaText)\n\n yield inTransaction(\n lambda: self.store.newTransaction(\"bonus schema\"), doit\n )\n\n def indirectedTransactionFactory(*a):\n \"\"\"\n Allow tests to replace \"self.store.newTransaction\" to provide\n fixtures with extra methods on a test-by-test basis.\n \"\"\"\n return self.store.newTransaction(*a)\n\n def deschema():\n @inlineCallbacks\n def deletestuff(txn):\n for stmt in dropSQL:\n yield txn.execSQL(stmt)\n return inTransaction(\n lambda *a: self.store.newTransaction(*a), deletestuff\n )\n self.addCleanup(deschema)\n\n from twisted.internet import reactor\n self.node1 = PeerConnectionPool(\n reactor, indirectedTransactionFactory, 0, schema)\n self.node2 = PeerConnectionPool(\n reactor, indirectedTransactionFactory, 0, schema)\n\n class FireMeService(Service, object):\n def __init__(self, d):\n super(FireMeService, self).__init__()\n self.d = d\n\n def startService(self):\n self.d.callback(None)\n\n d1 = Deferred()\n d2 = Deferred()\n FireMeService(d1).setServiceParent(self.node1)\n FireMeService(d2).setServiceParent(self.node2)\n ms = MultiService()\n self.node1.setServiceParent(ms)\n self.node2.setServiceParent(ms)\n ms.startService()\n self.addCleanup(ms.stopService)\n yield gatherResults([d1, d2])\n self.store.queuer = self.node1","def test_close_after_handshake(self) -> None:\n self.start_dummy_server()\n\n sock = socket.create_connection((self.host, self.port))\n with SSLTransport(\n sock, self.client_context, server_hostname=\"localhost\"\n ) as ssock:\n ssock.close()\n with pytest.raises(OSError):\n ssock.send(b\"blaaargh\")","def test_already_connected(connection, events, writer, schedule, flush):\n schedule(connection.connect(), connection.connect())\n flush()\n assert not writer.closed\n assert events.triggered(\"CLIENT_CONNECT\")","def test_auth_fail(context_fixture):\n with pytest.raises(SystemExit):\n context_fixture('AuthFailed')","async def test_bus_fixture(bus: lightbus.BusNode):\n rpc_transport = bus.bus_client.transport_registry.get_rpc_transport('default')\n result_transport = bus.bus_client.transport_registry.get_result_transport('default')\n event_transport = bus.bus_client.transport_registry.get_event_transport('default')\n\n connection_manager_rpc = await rpc_transport.connection_manager()\n connection_manager_result = await result_transport.connection_manager()\n connection_manager_event = await event_transport.connection_manager()\n\n with await connection_manager_rpc as redis_rpc, \\\n await connection_manager_result as redis_result, \\\n await connection_manager_event as redis_event:\n\n # Each transport should have its own connection\n assert redis_rpc is not redis_result\n assert redis_result is not redis_event\n assert redis_rpc is not redis_event\n\n # Check they are all looking at the same redis instance\n await redis_rpc.set('X', 1)\n assert await redis_result.get('X')\n assert await redis_rpc.get('X')\n\n info = await redis_rpc.info()\n # transports: rpc, result, event, schema\n assert int(info['clients']['connected_clients']) == 4","def test_check_health_fail(self):\n dbmock = self.db.engine = MagicMock()\n\n def throw(*_, **__):\n \"\"\"Throw an exception\"\"\"\n raise Exception(\"DB exception\")\n\n dbmock.scan.side_effect = throw\n ok, msg = self.db.check_health()\n self.assertFalse(ok)","def test_setup(self):\n with pytest.raises(NotImplementedError):\n self.behaviour.setup()","def test_configuration1(self):\n with self.assertRaises((TypeError, AttributeError)):\n queue = RabbitQueue()\n queue.connect()","def test_read_unexpected_error(self, data, requests_mock, capsys):\n requests_mock.get(data_url, exc=ConnectionError)\n with pytest.raises(ConnectionError):\n r = operations.read(data_url)\n assert 'Unexpected error when connecting to' in capsys.readouterr().out","async def test_disconnected_server_raises_on_data_write(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESS\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def test_fail_must_login(self):\n guest_obj = self._check_init()\n msg = 'You need to login first'\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.hotplug(vols=[dict()])\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.install_packages([])\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.push_file('source_url', 'target_path')\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)","def setUp(self):\n\n # Get the Flask test client.\n self.client = app.test_client()\n app.config[\"TESTING\"] = True\n app.config[\"SECRET_KEY\"] = \"key\"\n app.config[\"SQLALCHEMY_TRACK_MODIFICATIONS\"] = False\n\n with self.client as c:\n with c.session_transaction() as sess:\n sess[\"dietitian_id\"] = 1\n\n # Connect to the test database.\n connect_to_db(app, db_uri=\"postgresql:///testnourish\") \n\n # Create the tables and add the sample data.\n db.create_all()\n load_test_data()","def test_startup_defensive(self) -> None:\n self.assertFalse(self.client.triggers, 'predefined triggers')\n self.assertIsNone(self.client.websocket, 'websocket without triggers')","def test_send_event_raises():\n send_event('pytest-reportportal', '5.0.5')","def test_exception_raise2(self):\n with self.assertRaises(Exception):\n IperfClientCommandBuilder()\\\n .set_server_ip(SERVER_IP)\\\n .set_server_hostname(SERVER_HOST)\\\n .build_client_command()"],"string":"[\n \"def test_connection_fail(context_fixture):\\n with pytest.raises(SystemExit):\\n context_fixture('RequestException')\",\n \"def test_passing_bad_connection(self):\\n self.assertRaises(\\n ConnectionError, Pet.init_db, Redis(host=\\\"127.0.0.1\\\", port=6300)\\n )\\n self.assertIsNone(Pet.redis)\\n # Reestablish good connection\\n Pet.init_db()\",\n \"def test_exceptions_in_server_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n raise SentinelException()\\n\\n def client_callback(*args): # pragma: nocover\\n pytest.fail(\\\"Should not be called\\\")\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_connect_fail(self, req):\\n req.side_effect = ks_exc.ConnectFailure()\\n self.client._get_resource_provider(self.context, \\\"fake\\\")\\n\\n # reset the call count to demonstrate that future calls do\\n # work\\n req.reset_mock()\\n self.client._get_resource_provider(self.context, \\\"fake\\\")\\n self.assertTrue(req.called)\",\n \"def test_exceptions_in_client_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n return self.sample_ocsp_data\\n\\n def client_callback(*args):\\n raise SentinelException()\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_connect_fail(self):\\n with pytest.raises(InstrumentGatewayError):\\n with InstrumentGateway(addr='an invalid ip!'):\\n pass\",\n \"def test_connectFailure(self):\\n db = Database.TestDB(self.mktemp())\\n # Make _db_init fail\\n db._db_init = lambda: 1 / 0\\n self.assertFalse(db.initialized)\\n try:\\n yield db.open()\\n except:\\n pass\\n self.assertFalse(db.initialized)\\n self.assertEquals(db.pool, None)\",\n \"def test_connect_error():\\n queue = RedisQueue('localhost')\\n assert not queue.is_connected\\n with pytest.raises(ConnectionError):\\n queue.put('test')\\n with pytest.raises(ConnectionError):\\n queue.get()\",\n \"def test_connect(server):\\n assert server\",\n \"def test_vogeler_client_failure(self):\\n with self.assertRaises(Exception):\\n VogelerClient(callback_function=self.echo, role='client', dsn=self.bad_amqp_dsn)\",\n \"def setUp(self):\\n\\t\\tself.conn = Client([\\\"127.0.0.1:11211\\\"], debug = 1)\",\n \"def test_manage():\\n assert isinstance(hug_peewee.connection.manage(api), SqliteDatabase)\\n assert isinstance(hug_peewee.connection.manage(api, location='connection_testing.db'), SqliteDatabase)\\n assert hug.test.get(api, 'fake_endpoint').data == True\\n\\n with pytest.raises(ValueError):\\n hug_peewee.connection.manage(api, engine=\\\"Reese's Petabyte Cup\\\") # I also wish this existed!\",\n \"async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\\n config_entry = MockConfigEntry(\\n domain=DOMAIN,\\n unique_id=MAC,\\n data={CONF_HOST: HOST, KEY_MAC: MAC},\\n )\\n config_entry.add_to_hass(hass)\\n\\n mock_daikin.factory.side_effect = ClientConnectionError\\n await hass.config_entries.async_setup(config_entry.entry_id)\\n await hass.async_block_till_done()\\n\\n assert config_entry.state == ConfigEntryState.SETUP_RETRY\",\n \"def test_004_connect(self):\\n HEADING()\\n self.db.connect()\\n\\n result = True\\n assert result\",\n \"def test_connection_failure(aggregator, check, bad_instance):\\n instance_tags = [\\\"supervisord_server:travis\\\"]\\n with pytest.raises(Exception):\\n check.check(bad_instance)\\n aggregator.assert_service_check(\\\"supervisord.can_connect\\\", status=check.CRITICAL, tags=instance_tags, count=1)\",\n \"def test_connect_not_called():\\n config = {\\\"listeners\\\": \\\"localhost:8080\\\"}\\n registry = Registry()\\n registry.new(name=\\\"test\\\", backend=\\\"dummy\\\", **config)\\n\\n dummy = registry[\\\"test\\\"]\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl1\\\")\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl2\\\")\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl3\\\")\\n dummy._connect.assert_called_once()\",\n \"def test_connection():\\r\\n try:\\r\\n connect()\\r\\n except:\\r\\n pass\\r\\n print ('Unable to connect.')\\r\\n else:\\r\\n main()\",\n \"def test_connect_invalid_string(self):\\n with pytest.raises(ValueError):\\n DatabaseDriver.connect('not a valid connect string')\",\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_database_connection(self):\\n\\t\\t\\n\\t\\tself.assertTrue(database.connect())\",\n \"def test_exception_with_callback(self):\\n test_utils.generate_test_config_file()\\n\\n exception_callback = mock.Mock()\\n\\n client = PowerTrackClient(_dummy_callback, exception_callback,\\n config_file_path=config_file)\\n client.connect()\\n client.disconnect()\\n self.assertTrue(exception_callback.called)\\n actual_exinfo = exception_callback.call_args[0][0]\\n actual_ex = actual_exinfo[1]\\n self.assertIsInstance(actual_ex, Exception)\\n self.assertEqual(actual_ex.message, \\\"This is a test exception\\\")\",\n \"def test_connection_error(self, bad_mock):\\n bad_mock.side_effect = ConnectionError()\\n self.assertRaises(DatabaseConnectionError, Promotion.init_db, 'test')\",\n \"def test_parse_message_failure_connect(self):\\n for test_case in self.failure_test_params_wrong_connect:\\n expected = test_case[KEY_EXPECTED]\\n mock_connect = app.on_connect()\\n\\n self.assertNotEqual(expected, mock_connect)\",\n \"def setUp(self):\\n self.c = Client(host=\\\"localhost\\\")\",\n \"def test_connection_duplication():\",\n \"def test_check_connection(self):\\n self.assertIsNotNone(app.check_connection())\",\n \"def test_handle_calls(tchannel_pair):\\n class _MyException(Exception):\\n pass\\n\\n def my_handler(context, connection):\\n raise _MyException()\\n\\n server, client = tchannel_pair\\n client.ping()\\n with pytest.raises(_MyException):\\n server.handle_calls(my_handler)\",\n \"def test_init_server_make_connection_fail(self, mock_make_conn_func,\\n mock_stop_func):\\n mock_make_conn_func.side_effect = Exception('ha')\\n\\n with self.assertRaisesRegex(Exception, 'ha'):\\n self.client.initialize()\\n mock_stop_func.assert_called()\",\n \"def test_redis_connection_error(self):\\n with patch(\\\"redis.Redis.ping\\\") as ping_error_mock:\\n ping_error_mock.side_effect = ConnectionError()\\n self.assertRaises(ConnectionError, Pet.init_db)\\n self.assertIsNone(Pet.redis)\\n Pet.init_db()\",\n \"def test_connect(self):\\n db = Database.TestDB(self.mktemp())\\n self.assertFalse(db.initialized)\\n yield db.open()\\n self.assertTrue(db.initialized)\\n db.close()\",\n \"def test_connect(rgd):\\n assert rgd.connected is True\",\n \"def test_connect_db_to_query(db):\\n assert 1\",\n \"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\\n\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n ctx.is_disconnect = True\\n\\n conn = engine.connect()\\n # no error\\n conn.close()\",\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_xfail_fixture(broken_fixture):\\n pass\",\n \"def test_verify_connection_to_a_device():\",\n \"def test_connect(connection, events, writer, schedule, flush):\\n schedule(connection.connect())\\n flush()\\n assert connection.connected\\n assert not writer.closed\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\",\n \"def setUpFixture(self):\\n pass\",\n \"def test_passing_connection(self):\\n Pet.init_db(Redis(host=REDIS_HOST, port=REDIS_PORT))\\n self.assertIsNotNone(Pet.redis)\",\n \"def test_setup(self):\\n with pytest.raises(NotImplementedError):\\n self.handler.setup()\",\n \"def setUp(self):\\n self.a = backend.dbconnection.DBConnect()\",\n \"def test_create_unexpected_error(self, data, requests_mock, capsys):\\n requests_mock.post(base_url, exc=ConnectionError)\\n with pytest.raises(ConnectionError):\\n r = operations.create(base_url, data=data)\\n assert 'Unexpected error when connecting to' in capsys.readouterr().out\",\n \"def test_hubs_fail(self):\\n with self.assertRaises(AssertionError):\\n self.resource.hubs(-1)\",\n \"def test_connection(self):\\n r = main.List.connection()\\n self.assertTrue(r.ping(), \\\"Connection failed.\\\")\",\n \"def test_connection(self):\\n self._bind_to_service()\",\n \"def test_connection_is_established(self):\\n assert self.connection_client_1.is_connected is True\\n assert self.connection_client_2.is_connected is True\",\n \"def test_connect_called_once():\\n config = {\\\"listeners\\\": \\\"localhost:8080\\\"}\\n registry = Registry()\\n registry.new(name=\\\"test\\\", backend=\\\"dummy\\\", **config)\\n\\n dummy = registry[\\\"test\\\"]\\n dummy._connect.assert_called_once()\",\n \"def test_for_client():\",\n \"def testConnectionMade(self):\\n d = self._getClientConnection()\\n d.addCallback(lambda _: self.client.disconnect())\\n return d\",\n \"async def test_connect_error_with_no_server(event_loop):\\n client = SMTP(hostname=\\\"127.0.0.1\\\", port=65534, loop=event_loop)\\n\\n with pytest.raises(SMTPConnectError):\\n await client.connect(timeout=0.1)\",\n \"def test_connection_raises_error(self, mock_execute, mock_parse):\\n mock_parse.return_value = ARGS_INPUT\\n result = CONNECTION2\\n mock_execute.return_value = result\\n with self.assertRaises(MyError):\\n connection_to_client()\",\n \"def setUp(self):\\r\\n\\r\\n \\r\\n self.client = app.test_client()\\r\\n # Show Flask errors that happen during tests\\r\\n app.config['TESTING'] = True\\r\\n \\r\\n connect_to_db(server.app)\\r\\n db.create_all()\\r\\n test_seed.create_test_data()\",\n \"async def test_setup_failed_connect(\\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\\n) -> None:\\n respx.get(\\\"http://localhost\\\").mock(\\n side_effect=httpx.RequestError(\\\"server offline\\\", request=MagicMock())\\n )\\n assert await async_setup_component(\\n hass,\\n SENSOR_DOMAIN,\\n {\\n SENSOR_DOMAIN: {\\n \\\"platform\\\": DOMAIN,\\n \\\"resource\\\": \\\"http://localhost\\\",\\n \\\"method\\\": \\\"GET\\\",\\n }\\n },\\n )\\n await hass.async_block_till_done()\\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\\n assert \\\"server offline\\\" in caplog.text\",\n \"def test_mysql_connect_fail(self):\\n if _is_backend_avail('mysql', user=\\\"openstack_cifail\\\"):\\n self.fail(\\\"Shouldn't have connected\\\")\",\n \"def test_event_handler_can_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_disconnect\\n if ctx.is_pre_ping:\\n ctx.is_disconnect = False\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_wrong_args(self, bad_context):\\n with pytest.raises(TypeError):\\n Connection(bad_context)\",\n \"def _fixture(\\n self,\\n dialect_name,\\n exception,\\n db_stays_down,\\n is_disconnect=True,\\n ):\\n connect_args = {}\\n patchers = []\\n db_disconnected = False\\n\\n class DisconnectCursorMixin:\\n def execute(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return super().execute(*arg, **kw)\\n\\n if dialect_name == \\\"postgresql\\\":\\n import psycopg2.extensions\\n\\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\\n pass\\n\\n connect_args = {\\\"cursor_factory\\\": Curs}\\n\\n elif dialect_name == \\\"mysql\\\":\\n import pymysql\\n\\n def fake_ping(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return True\\n\\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\\n pass\\n\\n connect_args = {\\\"cursorclass\\\": Curs}\\n\\n patchers.append(\\n mock.patch.object(\\n pymysql.Connection, \\\"ping\\\", fake_ping\\n )\\n )\\n else:\\n raise NotImplementedError()\\n\\n with mock.patch.object(\\n compat,\\n \\\"native_pre_ping_event_support\\\",\\n self.native_pre_ping,\\n ):\\n engine = engines.create_engine(\\n self.engine.url, max_retries=0)\\n\\n # 1. override how we connect. if we want the DB to be down\\n # for the moment, but recover, reset db_disconnected after\\n # connect is called. If we want the DB to stay down, then\\n # make sure connect raises the error also.\\n @event.listens_for(engine, \\\"do_connect\\\")\\n def _connect(dialect, connrec, cargs, cparams):\\n nonlocal db_disconnected\\n\\n # while we're here, add our cursor classes to the DBAPI\\n # connect args\\n cparams.update(connect_args)\\n\\n if db_disconnected:\\n if db_stays_down:\\n raise exception\\n else:\\n db_disconnected = False\\n\\n # 2. initialize the dialect with a first connect\\n conn = engine.connect()\\n conn.close()\\n\\n # 3. add additional patchers\\n patchers.extend([\\n mock.patch.object(\\n engine.dialect.dbapi,\\n \\\"Error\\\",\\n self.Error,\\n ),\\n mock.patch.object(\\n engine.dialect,\\n \\\"is_disconnect\\\",\\n mock.Mock(return_value=is_disconnect),\\n ),\\n ])\\n\\n with test_utils.nested(*patchers):\\n # \\\"disconnect\\\" the DB\\n db_disconnected = True\\n yield engine\",\n \"def test_connection_raises_message_error(self, mock_execute, mock_parse):\\n mock_parse.return_value = ARGS_INPUT\\n result = CONNECTION4\\n mock_execute.return_value = result\\n with self.assertRaises(MyError):\\n connection_to_client()\",\n \"def setUp(self):\\n self.conn = seed.connect_to_db(\\\"testing\\\")\\n self.cur = self.conn.cursor()\\n\\n # setting cur and conn in seed to test cur and conn (if we don't do this we get a 'cur is undefined' error)\\n seed.cur = self.conn.cursor()\\n seed.conn = self.conn\",\n \"def test_start_tasks_db_raises():\\n with pytest.raises(ValueError) as excinfo:\\n tasks.start_tasks_db('some/great/path', 'mysql')\\n exception_msg = excinfo.value.args[0]\\n assert exception_msg == \\\"db_type must be a 'tiny' or 'mongo'\\\"\",\n \"def setUp(self):\\n self.client = DummyClient()\",\n \"def test_database_can_connect():\\n\\n assert \\\"sqlite\\\" in settings.database_uri\",\n \"def test_connect_traced():\\n with override_config(\\\"psycopg\\\", {\\\"trace_connect\\\": True}):\\n conn = psycopg.connect(**POSTGRES_CONFIG)\\n assert conn\",\n \"def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_connection_is_established(self):\\n assert self.connection_node_1.is_connected is True\\n assert self.connection_node_2.is_connected is True\\n assert self.connection_client_1.is_connected is True\\n assert self.connection_client_2.is_connected is True\",\n \"def test_connection_is_established(self):\\n for conn in self.connections:\\n assert conn.is_connected is True\",\n \"def test_connect_traced():\\n with override_config(\\\"psycopg\\\", {\\\"trace_connect\\\": True}):\\n conn = psycopg2.connect(**POSTGRES_CONFIG)\\n assert conn\",\n \"def test_connect_refused(self):\\n client = socket_any_family()\\n context = Context(SSLv23_METHOD)\\n clientSSL = Connection(context, client)\\n # pytest.raises here doesn't work because of a bug in py.test on Python\\n # 2.6: https://github.com/pytest-dev/pytest/issues/988\\n try:\\n clientSSL.connect((loopback_address(client), 1))\\n except error as e:\\n exc = e\\n assert exc.args[0] == ECONNREFUSED\",\n \"def test_client_create(self):\\n pass\",\n \"def test_connectEvent(self):\\n reactor = self.buildReactor()\\n\\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\\n connected = []\\n\\n class CheckConnection(Protocol):\\n def connectionMade(self):\\n connected.append(self)\\n reactor.stop()\\n\\n clientFactory = Stop(reactor)\\n clientFactory.protocol = CheckConnection\\n\\n needsRunningReactor(reactor, lambda: self.connect(reactor, clientFactory))\\n\\n reactor.run()\\n\\n self.assertTrue(connected)\",\n \"def test_connection_raises_error(self, mock_execute, mock_parse):\\n mock_parse.return_value = ARGS_INPUT\\n result = CONNECTION2\\n mock_execute.return_value = result\\n with self.assertRaises(MyError):\\n connection_to_server()\",\n \"def test_connection_raises_message_error(self, mock_execute, mock_parse):\\n mock_parse.return_value = ARGS_INPUT\\n result = CONNECTION4\\n mock_execute.return_value = result\\n with self.assertRaises(MyError):\\n connection_to_server()\",\n \"def test_connection(self) -> None:\\n test_connection_fn = get_test_connection_fn(self.service_connection)\\n test_connection_fn(self.engine)\",\n \"async def test_datasets_access_call_exception(self):\\n pool = asynctest.CoroutineMock()\\n pool.acquire().__aenter__.return_value = ConnectionException()\\n with self.assertRaises(aiohttp.web_exceptions.HTTPInternalServerError):\\n await fetch_datasets_access(pool, None)\",\n \"def test_db_connection_bad_host():\\n\\n with pytest.raises(AddressError, match=r\\\"Cannot resolve address .*\\\"):\\n\\n from cwf2neo.neo4j import Neo4j\\n\\n db = Neo4j(host=\\\"invalidneo4jhostname\\\")\\n\\n db.graph.database.name\",\n \"def test_listen_server(self):\\n self.assertRaises(vk.listen_stream(self._stream))\",\n \"def test_create_client(self):\\n pass\",\n \"def test_connect_success():\\n\\n t = Thread(target=setup_socket)\\n t.start()\\n\\n data_sender = DataSender('127.0.0.1', 12345)\\n server_response = data_sender.notify('test')\\n\\n assert server_response == 'ok'\\n\\n data_sender.close()\\n t.join()\",\n \"def test_dead_node(self):\\r\\n self.pool._hosts.append(self.host)\\r\\n\\r\\n # cursor mock needed so set_cql_version doesn't crap out\\r\\n ok_cur = MagicMock()\\r\\n\\r\\n ok_conn = MagicMock()\\r\\n ok_conn.return_value = ok_cur\\r\\n\\r\\n\\r\\n returns = [CQLEngineException(), ok_conn]\\r\\n\\r\\n def side_effect(*args, **kwargs):\\r\\n result = returns.pop(0)\\r\\n if isinstance(result, Exception):\\r\\n raise result\\r\\n return result\\r\\n\\r\\n with patch('cqlengine.connection.cql.connect') as mock:\\r\\n mock.side_effect = side_effect\\r\\n conn = self.pool._create_connection()\",\n \"def test_loginException(self):\\n\\n class UnexpectedException(Exception):\\n \\\"\\\"\\\"\\n An unexpected exception.\\n \\\"\\\"\\\"\\n\\n def raisesUnexpectedException(user, passwd):\\n raise UnexpectedException(\\\"Whoops\\\")\\n\\n self.server.authenticateLogin = raisesUnexpectedException\\n\\n def login():\\n return self.client.login(b'testuser', b'password-test')\\n\\n d1 = self.connected.addCallback(strip(login))\\n\\n d1.addErrback(self.assertClientFailureMessage, b\\\"Server error: Whoops\\\")\\n\\n @d1.addCallback\\n def assertErrorLogged(_):\\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\\n\\n d1.addErrback(self._ebGeneral)\\n d1.addBoth(self._cbStopClient)\\n\\n d2 = self.loopback()\\n d = defer.gatherResults([d1, d2])\\n return d.addCallback(self._cbTestFailedLogin)\",\n \"def test_missing(server):\\n\\n assert \\\"non_existing_database\\\" not in server\\n with pytest.raises(excepts.DBNotExists):\\n server[\\\"non_existing_database\\\"]\",\n \"async def test_bus_fixture(bus: lightbus.BusNode):\\n\\n pool_rpc = await bus.bus_client.rpc_transport.get_redis_pool()\\n pool_result = await bus.bus_client.result_transport.get_redis_pool()\\n pool_event = await bus.bus_client.event_transport.get_redis_pool()\\n\\n with await pool_rpc as redis_rpc, await pool_result as redis_result, await pool_event as redis_event:\\n # Each transport should have its own connection\\n assert redis_rpc is not redis_result\\n assert redis_result is not redis_event\\n assert redis_rpc is not redis_event\\n\\n # Check they are all looking at the same redis instance\\n await redis_rpc.set('X', 1)\\n assert await redis_result.get('X')\\n assert await redis_rpc.get('X')\\n\\n info = await redis_rpc.info()\\n assert int(info['clients']['connected_clients']) == 3\",\n \"async def test_connection(self):\\n await self.webhook_connection.connect()\\n assert self.webhook_connection.is_connected is True\",\n \"def test_check_health_fail(self):\\n dbmock = self.db.db = MagicMock()\\n\\n def throw(*_, **__):\\n \\\"\\\"\\\"Throw an exception\\\"\\\"\\\"\\n raise redis.RedisError(\\\"DB exception\\\")\\n\\n dbmock.ping.side_effect = throw\\n ok, msg = self.db.check_health()\\n self.assertFalse(ok)\",\n \"def test_error(self, mock_validate_session):\\n mock_validate_session.return_value = False\\n with pytest.raises(SystemExit) as ctx:\\n celery_command.worker(Namespace(queues=1, concurrency=1))\\n assert str(ctx.value) == \\\"Worker exiting, database connection precheck failed.\\\"\",\n \"def setUp(self):\\n self.store = yield buildStore(self, None)\\n\\n def doit(txn):\\n return txn.execSQL(schemaText)\\n\\n yield inTransaction(\\n lambda: self.store.newTransaction(\\\"bonus schema\\\"), doit\\n )\\n\\n def indirectedTransactionFactory(*a):\\n \\\"\\\"\\\"\\n Allow tests to replace \\\"self.store.newTransaction\\\" to provide\\n fixtures with extra methods on a test-by-test basis.\\n \\\"\\\"\\\"\\n return self.store.newTransaction(*a)\\n\\n def deschema():\\n @inlineCallbacks\\n def deletestuff(txn):\\n for stmt in dropSQL:\\n yield txn.execSQL(stmt)\\n return inTransaction(\\n lambda *a: self.store.newTransaction(*a), deletestuff\\n )\\n self.addCleanup(deschema)\\n\\n from twisted.internet import reactor\\n self.node1 = PeerConnectionPool(\\n reactor, indirectedTransactionFactory, 0, schema)\\n self.node2 = PeerConnectionPool(\\n reactor, indirectedTransactionFactory, 0, schema)\\n\\n class FireMeService(Service, object):\\n def __init__(self, d):\\n super(FireMeService, self).__init__()\\n self.d = d\\n\\n def startService(self):\\n self.d.callback(None)\\n\\n d1 = Deferred()\\n d2 = Deferred()\\n FireMeService(d1).setServiceParent(self.node1)\\n FireMeService(d2).setServiceParent(self.node2)\\n ms = MultiService()\\n self.node1.setServiceParent(ms)\\n self.node2.setServiceParent(ms)\\n ms.startService()\\n self.addCleanup(ms.stopService)\\n yield gatherResults([d1, d2])\\n self.store.queuer = self.node1\",\n \"def test_close_after_handshake(self) -> None:\\n self.start_dummy_server()\\n\\n sock = socket.create_connection((self.host, self.port))\\n with SSLTransport(\\n sock, self.client_context, server_hostname=\\\"localhost\\\"\\n ) as ssock:\\n ssock.close()\\n with pytest.raises(OSError):\\n ssock.send(b\\\"blaaargh\\\")\",\n \"def test_already_connected(connection, events, writer, schedule, flush):\\n schedule(connection.connect(), connection.connect())\\n flush()\\n assert not writer.closed\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\",\n \"def test_auth_fail(context_fixture):\\n with pytest.raises(SystemExit):\\n context_fixture('AuthFailed')\",\n \"async def test_bus_fixture(bus: lightbus.BusNode):\\n rpc_transport = bus.bus_client.transport_registry.get_rpc_transport('default')\\n result_transport = bus.bus_client.transport_registry.get_result_transport('default')\\n event_transport = bus.bus_client.transport_registry.get_event_transport('default')\\n\\n connection_manager_rpc = await rpc_transport.connection_manager()\\n connection_manager_result = await result_transport.connection_manager()\\n connection_manager_event = await event_transport.connection_manager()\\n\\n with await connection_manager_rpc as redis_rpc, \\\\\\n await connection_manager_result as redis_result, \\\\\\n await connection_manager_event as redis_event:\\n\\n # Each transport should have its own connection\\n assert redis_rpc is not redis_result\\n assert redis_result is not redis_event\\n assert redis_rpc is not redis_event\\n\\n # Check they are all looking at the same redis instance\\n await redis_rpc.set('X', 1)\\n assert await redis_result.get('X')\\n assert await redis_rpc.get('X')\\n\\n info = await redis_rpc.info()\\n # transports: rpc, result, event, schema\\n assert int(info['clients']['connected_clients']) == 4\",\n \"def test_check_health_fail(self):\\n dbmock = self.db.engine = MagicMock()\\n\\n def throw(*_, **__):\\n \\\"\\\"\\\"Throw an exception\\\"\\\"\\\"\\n raise Exception(\\\"DB exception\\\")\\n\\n dbmock.scan.side_effect = throw\\n ok, msg = self.db.check_health()\\n self.assertFalse(ok)\",\n \"def test_setup(self):\\n with pytest.raises(NotImplementedError):\\n self.behaviour.setup()\",\n \"def test_configuration1(self):\\n with self.assertRaises((TypeError, AttributeError)):\\n queue = RabbitQueue()\\n queue.connect()\",\n \"def test_read_unexpected_error(self, data, requests_mock, capsys):\\n requests_mock.get(data_url, exc=ConnectionError)\\n with pytest.raises(ConnectionError):\\n r = operations.read(data_url)\\n assert 'Unexpected error when connecting to' in capsys.readouterr().out\",\n \"async def test_disconnected_server_raises_on_data_write(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESS\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def test_fail_must_login(self):\\n guest_obj = self._check_init()\\n msg = 'You need to login first'\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.hotplug(vols=[dict()])\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.install_packages([])\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.push_file('source_url', 'target_path')\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)\",\n \"def setUp(self):\\n\\n # Get the Flask test client.\\n self.client = app.test_client()\\n app.config[\\\"TESTING\\\"] = True\\n app.config[\\\"SECRET_KEY\\\"] = \\\"key\\\"\\n app.config[\\\"SQLALCHEMY_TRACK_MODIFICATIONS\\\"] = False\\n\\n with self.client as c:\\n with c.session_transaction() as sess:\\n sess[\\\"dietitian_id\\\"] = 1\\n\\n # Connect to the test database.\\n connect_to_db(app, db_uri=\\\"postgresql:///testnourish\\\") \\n\\n # Create the tables and add the sample data.\\n db.create_all()\\n load_test_data()\",\n \"def test_startup_defensive(self) -> None:\\n self.assertFalse(self.client.triggers, 'predefined triggers')\\n self.assertIsNone(self.client.websocket, 'websocket without triggers')\",\n \"def test_send_event_raises():\\n send_event('pytest-reportportal', '5.0.5')\",\n \"def test_exception_raise2(self):\\n with self.assertRaises(Exception):\\n IperfClientCommandBuilder()\\\\\\n .set_server_ip(SERVER_IP)\\\\\\n .set_server_hostname(SERVER_HOST)\\\\\\n .build_client_command()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7074696","0.6893949","0.68652934","0.6857744","0.683198","0.6786823","0.6782504","0.6678462","0.6664294","0.66146845","0.64933455","0.648083","0.64726126","0.64562","0.6455107","0.64305156","0.6425814","0.6402725","0.6401104","0.6391827","0.63894486","0.6373783","0.63196856","0.6319229","0.6304424","0.6278299","0.6244068","0.62431115","0.62153256","0.6193508","0.6184095","0.6161427","0.6160626","0.6148522","0.6134193","0.6113874","0.6107559","0.6100189","0.60970795","0.60856885","0.6072595","0.606355","0.6057716","0.60509485","0.60431033","0.6038476","0.60345364","0.6028153","0.6006651","0.60062844","0.5986426","0.5986111","0.5976531","0.5967013","0.5966198","0.5966023","0.5961912","0.59579194","0.5951911","0.5949091","0.5946976","0.5941901","0.5940597","0.5938736","0.59364825","0.593377","0.5927527","0.59194356","0.5912845","0.5908539","0.58987236","0.5898628","0.5896325","0.5890226","0.5888884","0.58856994","0.5882011","0.5876451","0.5873773","0.58698165","0.58681524","0.5867445","0.58656293","0.5858568","0.58539164","0.5852834","0.58502066","0.5849997","0.58445567","0.5842536","0.583697","0.5828217","0.58230436","0.5816012","0.5813487","0.58109546","0.5807082","0.58050656","0.5797624","0.5790991"],"string":"[\n \"0.7074696\",\n \"0.6893949\",\n \"0.68652934\",\n \"0.6857744\",\n \"0.683198\",\n \"0.6786823\",\n \"0.6782504\",\n \"0.6678462\",\n \"0.6664294\",\n \"0.66146845\",\n \"0.64933455\",\n \"0.648083\",\n \"0.64726126\",\n \"0.64562\",\n \"0.6455107\",\n \"0.64305156\",\n \"0.6425814\",\n \"0.6402725\",\n \"0.6401104\",\n \"0.6391827\",\n \"0.63894486\",\n \"0.6373783\",\n \"0.63196856\",\n \"0.6319229\",\n \"0.6304424\",\n \"0.6278299\",\n \"0.6244068\",\n \"0.62431115\",\n \"0.62153256\",\n \"0.6193508\",\n \"0.6184095\",\n \"0.6161427\",\n \"0.6160626\",\n \"0.6148522\",\n \"0.6134193\",\n \"0.6113874\",\n \"0.6107559\",\n \"0.6100189\",\n \"0.60970795\",\n \"0.60856885\",\n \"0.6072595\",\n \"0.606355\",\n \"0.6057716\",\n \"0.60509485\",\n \"0.60431033\",\n \"0.6038476\",\n \"0.60345364\",\n \"0.6028153\",\n \"0.6006651\",\n \"0.60062844\",\n \"0.5986426\",\n \"0.5986111\",\n \"0.5976531\",\n \"0.5967013\",\n \"0.5966198\",\n \"0.5966023\",\n \"0.5961912\",\n \"0.59579194\",\n \"0.5951911\",\n \"0.5949091\",\n \"0.5946976\",\n \"0.5941901\",\n \"0.5940597\",\n \"0.5938736\",\n \"0.59364825\",\n \"0.593377\",\n \"0.5927527\",\n \"0.59194356\",\n \"0.5912845\",\n \"0.5908539\",\n \"0.58987236\",\n \"0.5898628\",\n \"0.5896325\",\n \"0.5890226\",\n \"0.5888884\",\n \"0.58856994\",\n \"0.5882011\",\n \"0.5876451\",\n \"0.5873773\",\n \"0.58698165\",\n \"0.58681524\",\n \"0.5867445\",\n \"0.58656293\",\n \"0.5858568\",\n \"0.58539164\",\n \"0.5852834\",\n \"0.58502066\",\n \"0.5849997\",\n \"0.58445567\",\n \"0.5842536\",\n \"0.583697\",\n \"0.5828217\",\n \"0.58230436\",\n \"0.5816012\",\n \"0.5813487\",\n \"0.58109546\",\n \"0.5807082\",\n \"0.58050656\",\n \"0.5797624\",\n \"0.5790991\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68847454"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":84666,"cells":{"query":{"kind":"string","value":"test the disconnect fixture doesn't raise, since it considers all errors to be disconnect errors."},"document":{"kind":"string","value":"def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\n\n engine = ping_fixture_all_errs_disconnect\n\n conn = engine.connect()\n conn.close()"},"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 test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_already_disconnected(connection, events, schedule, flush):\n schedule(connection.connect(),\n connection.disconnect(),\n connection.disconnect())\n flush()\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()","def test_disconnect_multiple(self):\n self.inverter.disconnect()\n self.inverter.disconnect() # Should not raise exception","def test_disconnect_before_connect(connection, events, schedule, flush):\n schedule(connection.disconnect())\n flush()\n assert not connection.connected\n assert not events.triggered(\"CLIENT_CONNECT\")\n assert not events.triggered(\"CLIENT_DISCONNECT\")","def test_parse_message_failure_disconnect(self, mock_disconnect):\n for test_case in self.failure_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertNotEqual(expected, mock_disconnect)","def test_invalid_disconnect(self):\n mediator = Mediator()\n try:\n mediator.disconnect(\"foo\", self.dog.set_sound)\n mediator.disconnect(\"bar\", self.cat.set_sound)\n except:\n raise AssertionError()","def test_disconnect(writer, patch_connection, events, connection,\n schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n assert not connection.connected\n assert writer.closed\n assert connection.writer is None\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_disconnect_closed(self):\n self.sock.close()\n self.inverter.sock.close()\n self.inverter.sock_file.close()\n self.inverter.disconnect() # Should not raise exception","async def test_disconnect(self):\n await self.webhook_connection.connect()\n assert self.webhook_connection.is_connected is True\n\n await self.webhook_connection.disconnect()\n assert self.webhook_connection.is_connected is False","async def test_timeout_disconnect():\n communicator = WebsocketCommunicator(ErrorWebsocketApp(), \"/testws/\")\n # Test connection\n connected, subprotocol = await communicator.connect()\n assert connected\n assert subprotocol is None\n # Test sending text (will error internally)\n await communicator.send_to(text_data=\"hello\")\n with pytest.raises(asyncio.TimeoutError):\n await communicator.receive_from()\n # Close out\n await communicator.disconnect()","async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\n leak_tracker.set_initial_object_list()\n\n await client.connect()\n assert client.connected\n dropper.reject_outgoing()\n\n while client.connected:\n await asyncio.sleep(1)\n\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\n dropper.restore_all()\n while not client.connected:\n await asyncio.sleep(1)\n\n leak_tracker.check_for_leaks()","def test_parse_message_success_disconnect(self):\n for test_case in self.success_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertEqual(expected, mock_disconnect)","def test_control(self, ping_fixture):\n engine = ping_fixture\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_protocolShutDownAfterFailure(self):\n class ExpectedException(Exception):\n pass\n\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return result\n\n resolver._connectedProtocol = FakeProtocol\n queryResult = resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[0].transport.disconnected)\n result.errback(failure.Failure(ExpectedException()))\n self.assertTrue(protocols[0].transport.disconnected)\n\n return self.assertFailure(queryResult, ExpectedException)","def test_disconnect(self):\n\n\t\twith EchoServer(bind_addr = ('', 12122)):\n\t\t\tyield reactor.schedule()\n\t\t\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\n\t\t\tyield client.connect()\n\n\t\t\tclient.close()","async def test_disconnect_on_drop_outgoing(self, client, dropper, leak_tracker):\n leak_tracker.set_initial_object_list()\n\n await client.connect()\n assert client.connected\n dropper.drop_outgoing()\n\n while client.connected:\n await asyncio.sleep(1)\n\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\n dropper.restore_all()\n while not client.connected:\n await asyncio.sleep(1)\n\n leak_tracker.check_for_leaks()","def inner_test(param: enums.DisconnectReason):\n pass","async def test_disconnected_server_raises_on_data_write(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESS\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def test_disconnect_with_rollback(self):\n\n mock_connector = MagicMock()\n database = Database()\n database.connect(connector_impl=mock_connector)\n\n # rollback\n database.disconnect(False)\n\n connection = mock_connector.connect()\n self.assertFalse(connection.commit.called)\n self.assertTrue(connection.close.called)","def test_disconnect(self):\n self.inverter.disconnect()\n sleep(0.02)","def test_reconnect(self):\n\n # make a connection\n\n conn = self.db.connect()\n\n # connection works\n\n conn.execute(select(1))\n\n # create a second connection within the pool, which we'll ensure\n # also goes away\n\n conn2 = self.db.connect()\n conn2.close()\n\n # two connections opened total now\n\n assert len(self.dbapi.connections) == 2\n\n # set it to fail\n\n self.dbapi.shutdown()\n\n # force windows monotonic timer to definitely increment\n time.sleep(0.5)\n\n # close on DBAPI connection occurs here, as it is detected\n # as invalid.\n assert_raises(tsa.exc.DBAPIError, conn.execute, select(1))\n\n # assert was invalidated\n\n assert not conn.closed\n assert conn.invalidated\n\n # close shouldn't break\n\n conn.close()\n\n # ensure one connection closed...\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], []],\n )\n\n conn = self.db.connect()\n\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], [call()], []],\n )\n\n conn.execute(select(1))\n conn.close()\n\n eq_(\n [c.close.mock_calls for c in self.dbapi.connections],\n [[call()], [call()], []],\n )","def test_parse_message_failure_connect(self):\n for test_case in self.failure_test_params_wrong_connect:\n expected = test_case[KEY_EXPECTED]\n mock_connect = app.on_connect()\n\n self.assertNotEqual(expected, mock_connect)","async def test_libp2pclientconnection_connect_disconnect(self):\n assert self.connection.is_connected is False\n try:\n await self.connection_node.connect()\n await self.connection.connect()\n assert self.connection.is_connected is True\n\n await self.connection.disconnect()\n assert self.connection.is_connected is False\n except Exception:\n raise\n finally:\n await self.connection_node.disconnect()","def testConnectionMade(self):\n d = self._getClientConnection()\n d.addCallback(lambda _: self.client.disconnect())\n return d","def test_verify_state_of_a_device_when_disconnected_from_the_device():","async def test_disconnected_server_raises_on_data_read(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESSAGE\\r\\n.\\r\\n\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def test_disconnect_from_client_side(\n start_result_q_publisher, start_result_q_subscriber\n):\n\n result_pub = start_result_q_publisher()\n f = result_pub.publish(b\"Hello test_disconnect_from_client_side 1\")\n assert f.result(timeout=1) is None\n\n result_pub.stop()\n\n try_assert(lambda: not result_pub.is_alive(), \"Verify test setup\")\n with pytest.raises(ValueError):\n result_pub.publish(b\"Hello test_disconnect_from_client_side 2\")","def test_disconnect(self):\n self.client.ensure_path(\"/services/db/1.1.1.1\")\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"1\"}))\n z = ZkFarmExporter(self.client, \"/services/db\", self.conf)\n z.loop(2, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"1\"}})\n self.conf.reset_mock()\n self.expire_session()\n z.loop(10, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"1\"}})","def test_clientConnectionFailedStopsReactor(self):\n reactor = self.buildReactor()\n needsRunningReactor(reactor, lambda: self.connect(reactor, Stop(reactor)))\n self.runReactor(reactor)","def test_delete_unexpected_error(self, requests_mock, capsys):\n requests_mock.delete(data_url, exc=ConnectionError)\n with pytest.raises(ConnectionError):\n r = operations.delete(data_url)\n assert 'Unexpected error when connecting to' in capsys.readouterr().out","def user_is_disconnected_from_all_devices():\n assert web_app.disconnect_from_device()","def test_protocolShutDown(self):\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return result\n\n resolver._connectedProtocol = FakeProtocol\n resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[0].transport.disconnected)\n result.callback(dns.Message())\n self.assertTrue(protocols[0].transport.disconnected)","def test_connect_error():\n queue = RedisQueue('localhost')\n assert not queue.is_connected\n with pytest.raises(ConnectionError):\n queue.put('test')\n with pytest.raises(ConnectionError):\n queue.get()","def the_user_disconnect_the_device_and_reconnect_again_to_the_same_device():\n assert web_app.disconnect_from_device()\n assert web_app.connect_to_device1()","def test_exceptions_in_server_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n raise SentinelException()\n\n def client_callback(*args): # pragma: nocover\n pytest.fail(\"Should not be called\")\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_connection_fail(context_fixture):\n with pytest.raises(SystemExit):\n context_fixture('RequestException')","async def test_connect_and_disconnect(database_url):\n database = Database(database_url)\n\n assert not database.is_connected\n await database.connect()\n assert database.is_connected\n await database.disconnect()\n assert not database.is_connected","def test_run_without_message(connection, events, loop):\n loop.run_until_complete(connection.run())\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_send_disconnected(connection, writer, schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n connection.send(\"test\")\n assert not writer.used","def test_closed_connection():\n cnt = 1000\n def bad_content(request):\n for n in xrange(cnt):\n # what json we pass doesn't matter. It's not verifying the\n # strcuture, only checking that it's parsable\n yield \"[1,2,3]\"\n\n def do_test(klass, *args):\n with test_server(handler=bad_content, methods=(\"post\", \"get\"),\n port=\"random\") as server:\n stream = klass(\"foo\", \"bar\", *args, url=server.baseurl)\n for tweet in stream:\n pass\n\n assert_raises(ConnectionError, do_test, TweetStream)\n assert_raises(ConnectionError, do_test, FollowStream, [1, 2, 3])\n assert_raises(ConnectionError, do_test, TrackStream, [\"opera\"])","def testConnectionLost(self):\n d = self.testSimpleRequest()\n d.addCallback(lambda _: self.factory.crash())\n d.addCallback(lambda _: self.client.check_rate_limit())\n d.addTimeout(0.01, reactor)\n self.assertFailure(d, ConnectionClosed)\n return d","def teardown(self):\n try:\n self.loop.run_until_complete(self.webhook_connection.disconnect())\n except Exception:\n print_exc()\n raise","def teardown(self, exception):","def test_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as err:\n server.sendall(b\"hello, world\")\n if platform == \"win32\":\n assert err.value.args[0] == ESHUTDOWN\n else:\n assert err.value.args[0] == EPIPE","def test_writeAfterDisconnect(self):\n reactor = self.buildReactor()\n\n finished = []\n\n serverConnectionLostDeferred = Deferred()\n protocol = lambda: ClosingLaterProtocol(serverConnectionLostDeferred)\n portDeferred = self.endpoints.server(reactor).listen(\n ServerFactory.forProtocol(protocol)\n )\n\n def listening(port):\n msg(\"Listening on {!r}\".format(port.getHost()))\n endpoint = self.endpoints.client(reactor, port.getHost())\n\n lostConnectionDeferred = Deferred()\n protocol = lambda: ClosingLaterProtocol(lostConnectionDeferred)\n client = endpoint.connect(ClientFactory.forProtocol(protocol))\n\n def write(proto):\n msg(\"About to write to {!r}\".format(proto))\n proto.transport.write(b\"x\")\n\n client.addCallbacks(write, lostConnectionDeferred.errback)\n\n def disconnected(proto):\n msg(\"{!r} disconnected\".format(proto))\n proto.transport.write(b\"some bytes to get lost\")\n proto.transport.writeSequence([b\"some\", b\"more\"])\n finished.append(True)\n\n lostConnectionDeferred.addCallback(disconnected)\n serverConnectionLostDeferred.addCallback(disconnected)\n return gatherResults([lostConnectionDeferred, serverConnectionLostDeferred])\n\n def onListen():\n portDeferred.addCallback(listening)\n portDeferred.addErrback(err)\n portDeferred.addCallback(lambda ignored: reactor.stop())\n\n needsRunningReactor(reactor, onListen)\n\n self.runReactor(reactor)\n self.assertEqual(finished, [True, True])","def tearDown(self) -> None:\n self.inverter.disconnect()\n self.sock.close()","def test_disconnect_loop_invalid_grant(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","async def test_context_manager_disconnect_handling(preset_server, event_loop):\n preset_client = SMTP(\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\n )\n\n async with preset_client:\n assert preset_client.is_connected\n\n preset_server.responses.append(b\"250 noop\")\n preset_server.drop_connection_event.set()\n\n try:\n await preset_client.noop()\n except SMTPServerDisconnected:\n pass\n\n assert not preset_client.is_connected","def testTerminateRace(self):\n yield self.connect(self.get_body_node(connect=True))\n\n def log_observer(event):\n self.failIf(event['isError'], event)\n\n log.addObserver(log_observer)\n\n # Simultaneously cause a stream error (server->client closed) and send a terminate\n # from the client to the server. Both sides are closing the connection at once.\n # Make sure the connection closes cleanly without logging any errors (\"Unhandled\n # Error\"), and the client receives a terminate in response.\n try:\n self.server_protocol.triggerStreamError()\n yield self.proxy.send(self.get_body_node(type='terminate'))\n except httpb_client.HTTPBNetworkTerminated as e:\n self.assertEqual(e.body_tag.getAttribute('condition', None), 'remote-stream-error')\n finally:\n log.removeObserver(log_observer)","def test_plugin_connected_hook(node_factory):\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\n l1.rpc.reject(l3.info['id'])\n\n l2.connect(l1)\n l1.daemon.wait_for_log(r\"{} is allowed\".format(l2.info['id']))\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\n\n l3.connect(l1)\n l1.daemon.wait_for_log(r\"{} is in reject list\".format(l3.info['id']))\n\n # FIXME: this error occurs *after* connection, so we connect then drop.\n l3.daemon.wait_for_log(r\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\"\n .format(l1.info['id']))\n l3.daemon.wait_for_log(r\"You are in reject list\")\n\n def check_disconnect():\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\n return peers == [] or not peers[0]['connected']\n\n wait_for(check_disconnect)","def test_deletion_fail(self):\n\n # Assert that a RelaxNoPipeError occurs when the data pipe does not exist.\n self.assertRaises(RelaxNoPipeError, pipes.delete, 'x')","def test_exceptions_in_client_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n return self.sample_ocsp_data\n\n def client_callback(*args):\n raise SentinelException()\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_connection_duplication():","def testReconnectionOnConnectionLost(self):\n d = self.testConnectionLost()\n d.addCallback(lambda _: self.factory.resume())\n d.addCallback(lambda _: self.client.connection.deferred)\n self._addRequest(d)\n return d","def test_passing_bad_connection(self):\n self.assertRaises(\n ConnectionError, Pet.init_db, Redis(host=\"127.0.0.1\", port=6300)\n )\n self.assertIsNone(Pet.redis)\n # Reestablish good connection\n Pet.init_db()","async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\n config_entry = MockConfigEntry(\n domain=DOMAIN,\n unique_id=MAC,\n data={CONF_HOST: HOST, KEY_MAC: MAC},\n )\n config_entry.add_to_hass(hass)\n\n mock_daikin.factory.side_effect = ClientConnectionError\n await hass.config_entries.async_setup(config_entry.entry_id)\n await hass.async_block_till_done()\n\n assert config_entry.state == ConfigEntryState.SETUP_RETRY","def test_graph_drop_bad(self):\n fuseki = GraphStore()\n with self.assertRaises(ConnectionError):\n fuseki._drop_graph(\"default\")","def test_network_drops(self):\n self.mocking = False\n try:\n if conf.block_storage_driver.swift.testing.is_mocking:\n self.mocking = True\n except:\n self.mocking = False\n\n if self.mocking:\n\n vault_id = 'notmatter'\n block_id = 'notmatter'\n\n driver = self.create_driver()\n assert isinstance(driver, SwiftStorageDriver)\n assert isinstance(driver, object)\n\n # simulate swiftclient tossing exceptions\n driver.Conn.mock_drop_connections(True)\n\n self.assertFalse(driver.create_vault(vault_id))\n\n self.assertFalse(driver.vault_exists(vault_id))\n\n self.assertFalse(driver.delete_vault(vault_id))\n\n self.assertFalse(driver.store_block(vault_id, block_id,\n str('').encode('utf-8')))\n\n self.assertFalse(driver.block_exists(vault_id, block_id))\n\n self.assertFalse(driver.delete_block(vault_id, block_id))\n\n self.assertIsNone(driver.get_block_obj(vault_id, block_id))\n\n # Stats should come back as zero even though the connection\n # \"dropped\"\n bad_vault_stats = driver.get_vault_statistics(vault_id)\n main_keys = ('total-size', 'block-count')\n for key in main_keys:\n assert key in bad_vault_stats.keys()\n assert bad_vault_stats[key] == 0\n\n # simulate swiftclient tossing exceptions\n driver.Conn.mock_drop_connections(False)","def TestClosedSocketAndConnection(self):\n self.connection.close()\n self.s.close()\n byte_array_msg_tx = bytes('\\x0C\\x0D\\x0E\\x0F\\x10\\x11', encoding=DATA_ENCODING)\n\n self.txrx.tx_msg(byte_array_msg_tx)\n with self.assertRaises(PercivalCommsError):\n reply = self.txrx.rx_msg()","def test_disconnect_and_still_works(self):\n self.client.ensure_path(\"/services/db/1.1.1.1\")\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"1\"}))\n z = ZkFarmExporter(self.client, \"/services/db\", self.conf)\n z.loop(2, timeout=self.TIMEOUT)\n self.expire_session()\n z.loop(10, timeout=self.TIMEOUT)\n self.client.set(\"/services/db/1.1.1.1\",\n json.dumps({\"enabled\": \"2\"}))\n z.loop(2, timeout=self.TIMEOUT)\n self.conf.write.assert_called_with({\"1.1.1.1\": {\"enabled\": \"2\"}})","def test_disconnect_with_commit(self):\n\n mock_connector = MagicMock()\n database = Database()\n database.connect(connector_impl=mock_connector)\n\n # commit\n database.disconnect(True)\n\n connection = mock_connector.connect()\n self.assertTrue(connection.commit.called)\n self.assertTrue(connection.close.called)","async def test_endpoint_delete_share_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await delete_share_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test_rollback_and_close_on_failure(self):\n\n mock_connector = MagicMock()\n\n try:\n with Database.connect(mysql_connector_impl=mock_connector) as database:\n connection = database.connection\n raise Exception('intentional test of exception handling')\n except Exception:\n pass\n\n mock_connector.connect.assert_called_once()\n connection.commit.assert_not_called()\n connection.close.assert_called_once()","def test_0005(self):\n vdc_name = config['vcloud']['vdc']\n vapp_name = config['vcloud']['vapp']\n the_vdc = self.vca.get_vdc(vdc_name)\n assert the_vdc\n assert the_vdc.get_name() == vdc_name\n the_vapp = self.vca.get_vapp(the_vdc, vapp_name)\n assert the_vapp\n assert the_vapp.name == vapp_name\n task = the_vapp.disconnect_from_networks()\n assert task\n result = self.vca.block_until_completed(task)\n assert result","def test_startconnector_with_noretry_on_con_failure(self):\n\n yield self.connect('127.0.0.1', self.pbPort)\n\n localConfig = copy.copy(self.defaultConfig)\n localConfig.reconnectOnConnectionFailure = False\n yield self.add(localConfig)\n yield self.start(localConfig.id)\n\n # It takes a moment to stop the service after a connection failure\n while True:\n ssRet = yield self.service_status(localConfig.id)\n if ssRet != 1:\n break;\n else:\n time.sleep(1)\n\n self.assertEqual(0, ssRet)\n\n yield self.stop(localConfig.id)","def test_connection_failure(aggregator, check, bad_instance):\n instance_tags = [\"supervisord_server:travis\"]\n with pytest.raises(Exception):\n check.check(bad_instance)\n aggregator.assert_service_check(\"supervisord.can_connect\", status=check.CRITICAL, tags=instance_tags, count=1)","def _fixture(\n self,\n dialect_name,\n exception,\n db_stays_down,\n is_disconnect=True,\n ):\n connect_args = {}\n patchers = []\n db_disconnected = False\n\n class DisconnectCursorMixin:\n def execute(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return super().execute(*arg, **kw)\n\n if dialect_name == \"postgresql\":\n import psycopg2.extensions\n\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\n pass\n\n connect_args = {\"cursor_factory\": Curs}\n\n elif dialect_name == \"mysql\":\n import pymysql\n\n def fake_ping(self, *arg, **kw):\n if db_disconnected:\n raise exception\n else:\n return True\n\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\n pass\n\n connect_args = {\"cursorclass\": Curs}\n\n patchers.append(\n mock.patch.object(\n pymysql.Connection, \"ping\", fake_ping\n )\n )\n else:\n raise NotImplementedError()\n\n with mock.patch.object(\n compat,\n \"native_pre_ping_event_support\",\n self.native_pre_ping,\n ):\n engine = engines.create_engine(\n self.engine.url, max_retries=0)\n\n # 1. override how we connect. if we want the DB to be down\n # for the moment, but recover, reset db_disconnected after\n # connect is called. If we want the DB to stay down, then\n # make sure connect raises the error also.\n @event.listens_for(engine, \"do_connect\")\n def _connect(dialect, connrec, cargs, cparams):\n nonlocal db_disconnected\n\n # while we're here, add our cursor classes to the DBAPI\n # connect args\n cparams.update(connect_args)\n\n if db_disconnected:\n if db_stays_down:\n raise exception\n else:\n db_disconnected = False\n\n # 2. initialize the dialect with a first connect\n conn = engine.connect()\n conn.close()\n\n # 3. add additional patchers\n patchers.extend([\n mock.patch.object(\n engine.dialect.dbapi,\n \"Error\",\n self.Error,\n ),\n mock.patch.object(\n engine.dialect,\n \"is_disconnect\",\n mock.Mock(return_value=is_disconnect),\n ),\n ])\n\n with test_utils.nested(*patchers):\n # \"disconnect\" the DB\n db_disconnected = True\n yield engine","def test_connection_failure(self, exc: Exception) -> None:\n self.sydent.run()\n with patch.object(\n self.sydent.sig_verifier, \"authenticate_request\", side_effect=exc\n ):\n request, channel = make_request(\n self.sydent.reactor,\n self.sydent.clientApiHttpServer.factory,\n \"POST\",\n \"/_matrix/identity/v2/3pid/unbind\",\n content={\n \"mxid\": \"@alice:wonderland\",\n \"threepid\": {\n \"address\": \"alice.cooper@wonderland.biz\",\n \"medium\": \"email\",\n },\n },\n )\n self.assertEqual(channel.code, HTTPStatus.INTERNAL_SERVER_ERROR)\n self.assertEqual(channel.json_body[\"errcode\"], \"M_UNKNOWN\")\n self.assertIn(\"contact\", channel.json_body[\"error\"])","def test_connect_fail(self):\n with pytest.raises(InstrumentGatewayError):\n with InstrumentGateway(addr='an invalid ip!'):\n pass","def dropConnection(): #@NoSelf","def test_connectFailure(self):\n db = Database.TestDB(self.mktemp())\n # Make _db_init fail\n db._db_init = lambda: 1 / 0\n self.assertFalse(db.initialized)\n try:\n yield db.open()\n except:\n pass\n self.assertFalse(db.initialized)\n self.assertEquals(db.pool, None)","def test_disconnect(self):\n mediator = Mediator()\n mediator.connect(\"set_dog_sound\", self.dog.set_sound)\n self.assertEquals([self.dog.set_sound], mediator.signals[\"set_dog_sound\"])\n\n mediator.disconnect(\"set_dog_sound\", self.dog.set_sound)\n self.assertEquals([], mediator.signals[\"set_dog_sound\"])","def test_dependency_disconnect(self):\n actor1 = self.create(ActorItem, UML.Actor)\n actor2 = self.create(ActorItem, UML.Actor)\n dep = self.create(DependencyItem)\n\n self.connect(dep, dep.head, actor1)\n self.connect(dep, dep.tail, actor2)\n\n dep_subj = dep.subject\n self.disconnect(dep, dep.tail)\n\n assert dep.subject is None\n assert self.get_connected(dep.tail) is None\n assert dep_subj not in self.element_factory.select()\n assert dep_subj not in actor1.subject.supplierDependency\n assert dep_subj not in actor2.subject.clientDependency","def test_validation(self):\n with self.assertRaises(DeletionError):\n Band.delete().run_sync()\n\n Band.delete(force=True).run_sync()","def handle_unexpected_disconnect(self,client_id, conn):\n try:\n if self.connections[client_id][\"host\"] == True: #if user is host, delete all connections\n session_location = self.connections[client_id][\"session_id\"]\n for key in self.sessions[session_location][\"USERS\"].keys():\n self.disconnect(self.connections[key][\"CONN\"],client_id,f\"[HOST <{client_id}>:<{self.connections[client_id]['display_name']}>] Unexpectedly Disconnected\") #close each connection\n self.delete_connection_entry(key) #delete the connection from the connections dictionary\n self.delete_session(session_location) # delete the session\n self.delete_connection_entry(client_id) # delete the original client entry from connections\n self.disconnect(conn,client_id,\"You Disconnected\")\n else:\n session_location = self.connections[client_id][\"session_id\"]\n self.delete_session_entry(session_location,client_id)\n self.broadcast_to_session(session_location, \"USER_DISCONNECT_UNEXPECTED\",f\"[USER <{client_id}>:<{self.connections[client_id]['display_name']}>] Unexpectedly Disconnected\", exclude=[client_id])\n self.delete_connection_entry(client_id)\n self.disconnect(conn,client_id,\"You Disconnected\")\n except:\n print(\"Something went wrong\")","def test_cannotDeleteOtherStuff(self):\n store = Store()\n factory = DummyFactory(store=store)\n tcp = TCPPort(\n store=store, factory=factory, interface=u\"foo\", portNumber=1234)\n self.assertFailStatus(\n 1,\n self._makeConfig(store),\n [\"delete\",\n \"--port-identifier\", str(tcp.storeID),\n \"--port-identifier\", str(factory.storeID)])\n self.assertEqual(\n \"%d does not identify a port.\\n\" % (factory.storeID,),\n sys.stdout.getvalue())\n self.assertEqual(list(store.query(DummyFactory)), [factory])\n self.assertEqual(list(store.query(TCPPort)), [tcp])","def test_connection_error(self, bad_mock):\n bad_mock.side_effect = ConnectionError()\n self.assertRaises(DatabaseConnectionError, Promotion.init_db, 'test')","def test_shutdown(self):\n server = self._server(None)\n server.bio_shutdown()\n with pytest.raises(Error) as err:\n server.recv(1024)\n # We don't want WantReadError or ZeroReturnError or anything - it's a\n # handshake failure.\n assert type(err.value) in [Error, SysCallError]","def test_teardown(self):\n with pytest.raises(NotImplementedError):\n self.behaviour.teardown()","def test_already_connected(connection, events, writer, schedule, flush):\n schedule(connection.connect(), connection.connect())\n flush()\n assert not writer.closed\n assert events.triggered(\"CLIENT_CONNECT\")","def test_disconnect(self):\n asc = self.create(AssociationItem)\n c1 = self.create(ClassItem, UML.Class)\n c2 = self.create(ClassItem, UML.Class)\n\n self.connect(asc, asc.head, c1)\n assert asc.subject is None # no UML metaclass yet\n\n self.connect(asc, asc.tail, c2)\n assert asc.subject is not None\n\n self.disconnect(asc, asc.head)\n\n # after disconnection: one diagram and two classes\n self.assertEqual(3, len(list(self.element_factory.select())))","def test_shutdown_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as exc:\n server.shutdown()\n if platform == \"win32\":\n assert exc.value.args[0] == ESHUTDOWN\n else:\n assert exc.value.args[0] == EPIPE","def stopConnecting(self):\n self.failIfNotConnected(error.UserError())","def test_connect_disconnect(self):\n ms_srv = common.MatchMakingServer(2222)\n ms_srv.start()\n time.sleep(2)\n\n clients = common.start_multiple_clients(ms_srv.port, 1)\n\n # Disconnect the client by killing it.\n # The sleeps here ensure the MS server and client are given enough time\n # to interact for log entries to be written.\n time.sleep(5)\n clients[0].kill()\n time.sleep(5)\n\n starting_game_found = False\n player_count_found = False\n with open(ms_srv.local_log_path) as log_file:\n for line in log_file:\n if \"Starting Game\" in line:\n starting_game_found = True\n continue\n elif \"1 players\" in line:\n player_count_found = True\n continue\n\n self.assertTrue(player_count_found,\n \"MS server should have been connected to\")\n self.assertFalse(starting_game_found, \"Game should not have started\")","def test_verify_connection_to_a_device():","async def test_listener_del(endpoint_error_handling):\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\n pytest.skip(\"Endpoint error handling is only supported for UCX >= 1.10\")\n\n async def server_node(ep):\n await ep.send(np.arange(100, dtype=np.int64))\n await ep.send(np.arange(100, dtype=np.int64))\n\n listener = ucp.create_listener(\n server_node, endpoint_error_handling=endpoint_error_handling\n )\n ep = await ucp.create_endpoint(\n ucp.get_address(),\n listener.port,\n endpoint_error_handling=endpoint_error_handling,\n )\n msg = np.empty(100, dtype=np.int64)\n await ep.recv(msg)\n assert listener.closed() is False\n del listener\n await ep.recv(msg)","def tearDown(self):\n self.conn.close()","def test_disconnectWhileProducing(self):\n reactor = self.buildReactor()\n\n # For some reason, pyobject/pygtk will not deliver the close\n # notification that should happen after the unregisterProducer call in\n # this test. The selectable is in the write notification set, but no\n # notification ever arrives. Probably for the same reason #5233 led\n # win32eventreactor to be broken.\n skippedReactors = [\"Glib2Reactor\", \"Gtk2Reactor\"]\n reactorClassName = reactor.__class__.__name__\n if reactorClassName in skippedReactors and platform.isWindows():\n raise SkipTest(\n \"A pygobject/pygtk bug disables this functionality \" \"on Windows.\"\n )\n\n class Producer:\n def resumeProducing(self):\n log.msg(\"Producer.resumeProducing\")\n\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\n\n finished = Deferred()\n finished.addErrback(log.err)\n finished.addCallback(lambda ign: reactor.stop())\n\n class ClientProtocol(Protocol):\n \"\"\"\n Protocol to connect, register a producer, try to lose the\n connection, unregister the producer, and wait for the connection to\n actually be lost.\n \"\"\"\n\n def connectionMade(self):\n log.msg(\"ClientProtocol.connectionMade\")\n self.transport.registerProducer(Producer(), False)\n self.transport.loseConnection()\n # Let the reactor tick over, in case synchronously calling\n # loseConnection and then unregisterProducer is the same as\n # synchronously calling unregisterProducer and then\n # loseConnection (as it is in several reactors).\n reactor.callLater(0, reactor.callLater, 0, self.unregister)\n\n def unregister(self):\n log.msg(\"ClientProtocol unregister\")\n self.transport.unregisterProducer()\n # This should all be pretty quick. Fail the test\n # if we don't get a connectionLost event really\n # soon.\n reactor.callLater(\n 1.0, finished.errback, Failure(Exception(\"Connection was not lost\"))\n )\n\n def connectionLost(self, reason):\n log.msg(\"ClientProtocol.connectionLost\")\n finished.callback(None)\n\n clientFactory = ClientFactory()\n clientFactory.protocol = ClientProtocol\n self.connect(reactor, clientFactory)\n self.runReactor(reactor)\n # If the test failed, we logged an error already and trial\n # will catch it.","def test_error(self, mock_validate_session):\n mock_validate_session.return_value = False\n with pytest.raises(SystemExit) as ctx:\n celery_command.worker(Namespace(queues=1, concurrency=1))\n assert str(ctx.value) == \"Worker exiting, database connection precheck failed.\"","def connection_teardown():\n test_str = make_random(100)\n server = start_server()\n client = start_client()\n\n # First write some data at both ends.\n write_to(client, test_str)\n write_to(server, test_str)\n time.sleep(TEST_TIMEOUT)\n\n # Write EOFs on both sides.\n write_to(client, '\\x1a')\n write_to(server, '\\x1a')\n client.stdin.close()\n server.stdin.close()\n time.sleep(TEST_TIMEOUT)\n\n return (\n DEBUG_TEARDOWN in read_debug_messages_from(client) and\n DEBUG_TEARDOWN in read_debug_messages_from(server)\n )","def test_disconnect_loop_auth_issue(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","def test_dead_node(self):\r\n self.pool._hosts.append(self.host)\r\n\r\n # cursor mock needed so set_cql_version doesn't crap out\r\n ok_cur = MagicMock()\r\n\r\n ok_conn = MagicMock()\r\n ok_conn.return_value = ok_cur\r\n\r\n\r\n returns = [CQLEngineException(), ok_conn]\r\n\r\n def side_effect(*args, **kwargs):\r\n result = returns.pop(0)\r\n if isinstance(result, Exception):\r\n raise result\r\n return result\r\n\r\n with patch('cqlengine.connection.cql.connect') as mock:\r\n mock.side_effect = side_effect\r\n conn = self.pool._create_connection()","def test_shutdown(self):\n server, client = loopback()\n assert not server.shutdown()\n assert server.get_shutdown() == SENT_SHUTDOWN\n with pytest.raises(ZeroReturnError):\n client.recv(1024)\n assert client.get_shutdown() == RECEIVED_SHUTDOWN\n client.shutdown()\n assert client.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\n with pytest.raises(ZeroReturnError):\n server.recv(1024)\n assert server.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)","async def test_endpoint_delete_container_shares_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await delete_container_shares_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test_reconnect_another(self):\n line, head = self._get_line()\n self.tool.connect(line, head, (120, 50))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n item = cinfo.connected\n port = cinfo.port\n constraint = cinfo.constraint\n\n assert item == self.box1\n assert port == self.box1.ports()[0]\n assert item != self.box2\n\n # connect to box2, handle's connected item and connection data\n # should differ\n self.tool.connect(line, head, (120, 150))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n self.assertEqual(self.box2, cinfo.connected)\n self.assertEqual(self.box2.ports()[0], cinfo.port)\n\n # old connection does not exist\n self.assertNotEqual(item, cinfo.connected)\n self.assertNotEqual(constraint, cinfo.constraint)","def test_unexpected_EOF(self):\n server_conn, client_conn = loopback()\n client_conn.sock_shutdown(SHUT_RDWR)\n with pytest.raises(SysCallError) as err:\n server_conn.recv(1024)\n if platform == \"win32\":\n assert err.value.args == (10054, \"WSAECONNRESET\")\n else:\n assert err.value.args == (-1, \"Unexpected EOF\")","async def test_connect_ConnectorLoopError() -> None:\n current_loop = asyncio.get_running_loop()\n connector = Connector(loop=current_loop)\n # try to connect using current thread's loop, should raise error\n pytest.raises(\n ConnectorLoopError,\n connector.connect,\n \"my-project:my-region:my-instance\",\n \"pg8000\",\n )"],"string":"[\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_event_handler_can_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_disconnect\\n if ctx.is_pre_ping:\\n ctx.is_disconnect = False\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_already_disconnected(connection, events, schedule, flush):\\n schedule(connection.connect(),\\n connection.disconnect(),\\n connection.disconnect())\\n flush()\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\\n\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n ctx.is_disconnect = True\\n\\n conn = engine.connect()\\n # no error\\n conn.close()\",\n \"def test_disconnect_multiple(self):\\n self.inverter.disconnect()\\n self.inverter.disconnect() # Should not raise exception\",\n \"def test_disconnect_before_connect(connection, events, schedule, flush):\\n schedule(connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert not events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert not events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_parse_message_failure_disconnect(self, mock_disconnect):\\n for test_case in self.failure_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertNotEqual(expected, mock_disconnect)\",\n \"def test_invalid_disconnect(self):\\n mediator = Mediator()\\n try:\\n mediator.disconnect(\\\"foo\\\", self.dog.set_sound)\\n mediator.disconnect(\\\"bar\\\", self.cat.set_sound)\\n except:\\n raise AssertionError()\",\n \"def test_disconnect(writer, patch_connection, events, connection,\\n schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert writer.closed\\n assert connection.writer is None\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_disconnect_closed(self):\\n self.sock.close()\\n self.inverter.sock.close()\\n self.inverter.sock_file.close()\\n self.inverter.disconnect() # Should not raise exception\",\n \"async def test_disconnect(self):\\n await self.webhook_connection.connect()\\n assert self.webhook_connection.is_connected is True\\n\\n await self.webhook_connection.disconnect()\\n assert self.webhook_connection.is_connected is False\",\n \"async def test_timeout_disconnect():\\n communicator = WebsocketCommunicator(ErrorWebsocketApp(), \\\"/testws/\\\")\\n # Test connection\\n connected, subprotocol = await communicator.connect()\\n assert connected\\n assert subprotocol is None\\n # Test sending text (will error internally)\\n await communicator.send_to(text_data=\\\"hello\\\")\\n with pytest.raises(asyncio.TimeoutError):\\n await communicator.receive_from()\\n # Close out\\n await communicator.disconnect()\",\n \"async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\\n leak_tracker.set_initial_object_list()\\n\\n await client.connect()\\n assert client.connected\\n dropper.reject_outgoing()\\n\\n while client.connected:\\n await asyncio.sleep(1)\\n\\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\\n dropper.restore_all()\\n while not client.connected:\\n await asyncio.sleep(1)\\n\\n leak_tracker.check_for_leaks()\",\n \"def test_parse_message_success_disconnect(self):\\n for test_case in self.success_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertEqual(expected, mock_disconnect)\",\n \"def test_control(self, ping_fixture):\\n engine = ping_fixture\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_protocolShutDownAfterFailure(self):\\n class ExpectedException(Exception):\\n pass\\n\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return result\\n\\n resolver._connectedProtocol = FakeProtocol\\n queryResult = resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[0].transport.disconnected)\\n result.errback(failure.Failure(ExpectedException()))\\n self.assertTrue(protocols[0].transport.disconnected)\\n\\n return self.assertFailure(queryResult, ExpectedException)\",\n \"def test_disconnect(self):\\n\\n\\t\\twith EchoServer(bind_addr = ('', 12122)):\\n\\t\\t\\tyield reactor.schedule()\\n\\t\\t\\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\\n\\t\\t\\tyield client.connect()\\n\\n\\t\\t\\tclient.close()\",\n \"async def test_disconnect_on_drop_outgoing(self, client, dropper, leak_tracker):\\n leak_tracker.set_initial_object_list()\\n\\n await client.connect()\\n assert client.connected\\n dropper.drop_outgoing()\\n\\n while client.connected:\\n await asyncio.sleep(1)\\n\\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\\n dropper.restore_all()\\n while not client.connected:\\n await asyncio.sleep(1)\\n\\n leak_tracker.check_for_leaks()\",\n \"def inner_test(param: enums.DisconnectReason):\\n pass\",\n \"async def test_disconnected_server_raises_on_data_write(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESS\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def test_disconnect_with_rollback(self):\\n\\n mock_connector = MagicMock()\\n database = Database()\\n database.connect(connector_impl=mock_connector)\\n\\n # rollback\\n database.disconnect(False)\\n\\n connection = mock_connector.connect()\\n self.assertFalse(connection.commit.called)\\n self.assertTrue(connection.close.called)\",\n \"def test_disconnect(self):\\n self.inverter.disconnect()\\n sleep(0.02)\",\n \"def test_reconnect(self):\\n\\n # make a connection\\n\\n conn = self.db.connect()\\n\\n # connection works\\n\\n conn.execute(select(1))\\n\\n # create a second connection within the pool, which we'll ensure\\n # also goes away\\n\\n conn2 = self.db.connect()\\n conn2.close()\\n\\n # two connections opened total now\\n\\n assert len(self.dbapi.connections) == 2\\n\\n # set it to fail\\n\\n self.dbapi.shutdown()\\n\\n # force windows monotonic timer to definitely increment\\n time.sleep(0.5)\\n\\n # close on DBAPI connection occurs here, as it is detected\\n # as invalid.\\n assert_raises(tsa.exc.DBAPIError, conn.execute, select(1))\\n\\n # assert was invalidated\\n\\n assert not conn.closed\\n assert conn.invalidated\\n\\n # close shouldn't break\\n\\n conn.close()\\n\\n # ensure one connection closed...\\n eq_(\\n [c.close.mock_calls for c in self.dbapi.connections],\\n [[call()], []],\\n )\\n\\n conn = self.db.connect()\\n\\n eq_(\\n [c.close.mock_calls for c in self.dbapi.connections],\\n [[call()], [call()], []],\\n )\\n\\n conn.execute(select(1))\\n conn.close()\\n\\n eq_(\\n [c.close.mock_calls for c in self.dbapi.connections],\\n [[call()], [call()], []],\\n )\",\n \"def test_parse_message_failure_connect(self):\\n for test_case in self.failure_test_params_wrong_connect:\\n expected = test_case[KEY_EXPECTED]\\n mock_connect = app.on_connect()\\n\\n self.assertNotEqual(expected, mock_connect)\",\n \"async def test_libp2pclientconnection_connect_disconnect(self):\\n assert self.connection.is_connected is False\\n try:\\n await self.connection_node.connect()\\n await self.connection.connect()\\n assert self.connection.is_connected is True\\n\\n await self.connection.disconnect()\\n assert self.connection.is_connected is False\\n except Exception:\\n raise\\n finally:\\n await self.connection_node.disconnect()\",\n \"def testConnectionMade(self):\\n d = self._getClientConnection()\\n d.addCallback(lambda _: self.client.disconnect())\\n return d\",\n \"def test_verify_state_of_a_device_when_disconnected_from_the_device():\",\n \"async def test_disconnected_server_raises_on_data_read(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESSAGE\\\\r\\\\n.\\\\r\\\\n\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def test_disconnect_from_client_side(\\n start_result_q_publisher, start_result_q_subscriber\\n):\\n\\n result_pub = start_result_q_publisher()\\n f = result_pub.publish(b\\\"Hello test_disconnect_from_client_side 1\\\")\\n assert f.result(timeout=1) is None\\n\\n result_pub.stop()\\n\\n try_assert(lambda: not result_pub.is_alive(), \\\"Verify test setup\\\")\\n with pytest.raises(ValueError):\\n result_pub.publish(b\\\"Hello test_disconnect_from_client_side 2\\\")\",\n \"def test_disconnect(self):\\n self.client.ensure_path(\\\"/services/db/1.1.1.1\\\")\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"1\\\"}))\\n z = ZkFarmExporter(self.client, \\\"/services/db\\\", self.conf)\\n z.loop(2, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"1\\\"}})\\n self.conf.reset_mock()\\n self.expire_session()\\n z.loop(10, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"1\\\"}})\",\n \"def test_clientConnectionFailedStopsReactor(self):\\n reactor = self.buildReactor()\\n needsRunningReactor(reactor, lambda: self.connect(reactor, Stop(reactor)))\\n self.runReactor(reactor)\",\n \"def test_delete_unexpected_error(self, requests_mock, capsys):\\n requests_mock.delete(data_url, exc=ConnectionError)\\n with pytest.raises(ConnectionError):\\n r = operations.delete(data_url)\\n assert 'Unexpected error when connecting to' in capsys.readouterr().out\",\n \"def user_is_disconnected_from_all_devices():\\n assert web_app.disconnect_from_device()\",\n \"def test_protocolShutDown(self):\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return result\\n\\n resolver._connectedProtocol = FakeProtocol\\n resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[0].transport.disconnected)\\n result.callback(dns.Message())\\n self.assertTrue(protocols[0].transport.disconnected)\",\n \"def test_connect_error():\\n queue = RedisQueue('localhost')\\n assert not queue.is_connected\\n with pytest.raises(ConnectionError):\\n queue.put('test')\\n with pytest.raises(ConnectionError):\\n queue.get()\",\n \"def the_user_disconnect_the_device_and_reconnect_again_to_the_same_device():\\n assert web_app.disconnect_from_device()\\n assert web_app.connect_to_device1()\",\n \"def test_exceptions_in_server_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n raise SentinelException()\\n\\n def client_callback(*args): # pragma: nocover\\n pytest.fail(\\\"Should not be called\\\")\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_connection_fail(context_fixture):\\n with pytest.raises(SystemExit):\\n context_fixture('RequestException')\",\n \"async def test_connect_and_disconnect(database_url):\\n database = Database(database_url)\\n\\n assert not database.is_connected\\n await database.connect()\\n assert database.is_connected\\n await database.disconnect()\\n assert not database.is_connected\",\n \"def test_run_without_message(connection, events, loop):\\n loop.run_until_complete(connection.run())\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_send_disconnected(connection, writer, schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n connection.send(\\\"test\\\")\\n assert not writer.used\",\n \"def test_closed_connection():\\n cnt = 1000\\n def bad_content(request):\\n for n in xrange(cnt):\\n # what json we pass doesn't matter. It's not verifying the\\n # strcuture, only checking that it's parsable\\n yield \\\"[1,2,3]\\\"\\n\\n def do_test(klass, *args):\\n with test_server(handler=bad_content, methods=(\\\"post\\\", \\\"get\\\"),\\n port=\\\"random\\\") as server:\\n stream = klass(\\\"foo\\\", \\\"bar\\\", *args, url=server.baseurl)\\n for tweet in stream:\\n pass\\n\\n assert_raises(ConnectionError, do_test, TweetStream)\\n assert_raises(ConnectionError, do_test, FollowStream, [1, 2, 3])\\n assert_raises(ConnectionError, do_test, TrackStream, [\\\"opera\\\"])\",\n \"def testConnectionLost(self):\\n d = self.testSimpleRequest()\\n d.addCallback(lambda _: self.factory.crash())\\n d.addCallback(lambda _: self.client.check_rate_limit())\\n d.addTimeout(0.01, reactor)\\n self.assertFailure(d, ConnectionClosed)\\n return d\",\n \"def teardown(self):\\n try:\\n self.loop.run_until_complete(self.webhook_connection.disconnect())\\n except Exception:\\n print_exc()\\n raise\",\n \"def teardown(self, exception):\",\n \"def test_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as err:\\n server.sendall(b\\\"hello, world\\\")\\n if platform == \\\"win32\\\":\\n assert err.value.args[0] == ESHUTDOWN\\n else:\\n assert err.value.args[0] == EPIPE\",\n \"def test_writeAfterDisconnect(self):\\n reactor = self.buildReactor()\\n\\n finished = []\\n\\n serverConnectionLostDeferred = Deferred()\\n protocol = lambda: ClosingLaterProtocol(serverConnectionLostDeferred)\\n portDeferred = self.endpoints.server(reactor).listen(\\n ServerFactory.forProtocol(protocol)\\n )\\n\\n def listening(port):\\n msg(\\\"Listening on {!r}\\\".format(port.getHost()))\\n endpoint = self.endpoints.client(reactor, port.getHost())\\n\\n lostConnectionDeferred = Deferred()\\n protocol = lambda: ClosingLaterProtocol(lostConnectionDeferred)\\n client = endpoint.connect(ClientFactory.forProtocol(protocol))\\n\\n def write(proto):\\n msg(\\\"About to write to {!r}\\\".format(proto))\\n proto.transport.write(b\\\"x\\\")\\n\\n client.addCallbacks(write, lostConnectionDeferred.errback)\\n\\n def disconnected(proto):\\n msg(\\\"{!r} disconnected\\\".format(proto))\\n proto.transport.write(b\\\"some bytes to get lost\\\")\\n proto.transport.writeSequence([b\\\"some\\\", b\\\"more\\\"])\\n finished.append(True)\\n\\n lostConnectionDeferred.addCallback(disconnected)\\n serverConnectionLostDeferred.addCallback(disconnected)\\n return gatherResults([lostConnectionDeferred, serverConnectionLostDeferred])\\n\\n def onListen():\\n portDeferred.addCallback(listening)\\n portDeferred.addErrback(err)\\n portDeferred.addCallback(lambda ignored: reactor.stop())\\n\\n needsRunningReactor(reactor, onListen)\\n\\n self.runReactor(reactor)\\n self.assertEqual(finished, [True, True])\",\n \"def tearDown(self) -> None:\\n self.inverter.disconnect()\\n self.sock.close()\",\n \"def test_disconnect_loop_invalid_grant(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"async def test_context_manager_disconnect_handling(preset_server, event_loop):\\n preset_client = SMTP(\\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\\n )\\n\\n async with preset_client:\\n assert preset_client.is_connected\\n\\n preset_server.responses.append(b\\\"250 noop\\\")\\n preset_server.drop_connection_event.set()\\n\\n try:\\n await preset_client.noop()\\n except SMTPServerDisconnected:\\n pass\\n\\n assert not preset_client.is_connected\",\n \"def testTerminateRace(self):\\n yield self.connect(self.get_body_node(connect=True))\\n\\n def log_observer(event):\\n self.failIf(event['isError'], event)\\n\\n log.addObserver(log_observer)\\n\\n # Simultaneously cause a stream error (server->client closed) and send a terminate\\n # from the client to the server. Both sides are closing the connection at once.\\n # Make sure the connection closes cleanly without logging any errors (\\\"Unhandled\\n # Error\\\"), and the client receives a terminate in response.\\n try:\\n self.server_protocol.triggerStreamError()\\n yield self.proxy.send(self.get_body_node(type='terminate'))\\n except httpb_client.HTTPBNetworkTerminated as e:\\n self.assertEqual(e.body_tag.getAttribute('condition', None), 'remote-stream-error')\\n finally:\\n log.removeObserver(log_observer)\",\n \"def test_plugin_connected_hook(node_factory):\\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\\n l1.rpc.reject(l3.info['id'])\\n\\n l2.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is allowed\\\".format(l2.info['id']))\\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\\n\\n l3.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is in reject list\\\".format(l3.info['id']))\\n\\n # FIXME: this error occurs *after* connection, so we connect then drop.\\n l3.daemon.wait_for_log(r\\\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\\\"\\n .format(l1.info['id']))\\n l3.daemon.wait_for_log(r\\\"You are in reject list\\\")\\n\\n def check_disconnect():\\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\\n return peers == [] or not peers[0]['connected']\\n\\n wait_for(check_disconnect)\",\n \"def test_deletion_fail(self):\\n\\n # Assert that a RelaxNoPipeError occurs when the data pipe does not exist.\\n self.assertRaises(RelaxNoPipeError, pipes.delete, 'x')\",\n \"def test_exceptions_in_client_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n return self.sample_ocsp_data\\n\\n def client_callback(*args):\\n raise SentinelException()\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_connection_duplication():\",\n \"def testReconnectionOnConnectionLost(self):\\n d = self.testConnectionLost()\\n d.addCallback(lambda _: self.factory.resume())\\n d.addCallback(lambda _: self.client.connection.deferred)\\n self._addRequest(d)\\n return d\",\n \"def test_passing_bad_connection(self):\\n self.assertRaises(\\n ConnectionError, Pet.init_db, Redis(host=\\\"127.0.0.1\\\", port=6300)\\n )\\n self.assertIsNone(Pet.redis)\\n # Reestablish good connection\\n Pet.init_db()\",\n \"async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\\n config_entry = MockConfigEntry(\\n domain=DOMAIN,\\n unique_id=MAC,\\n data={CONF_HOST: HOST, KEY_MAC: MAC},\\n )\\n config_entry.add_to_hass(hass)\\n\\n mock_daikin.factory.side_effect = ClientConnectionError\\n await hass.config_entries.async_setup(config_entry.entry_id)\\n await hass.async_block_till_done()\\n\\n assert config_entry.state == ConfigEntryState.SETUP_RETRY\",\n \"def test_graph_drop_bad(self):\\n fuseki = GraphStore()\\n with self.assertRaises(ConnectionError):\\n fuseki._drop_graph(\\\"default\\\")\",\n \"def test_network_drops(self):\\n self.mocking = False\\n try:\\n if conf.block_storage_driver.swift.testing.is_mocking:\\n self.mocking = True\\n except:\\n self.mocking = False\\n\\n if self.mocking:\\n\\n vault_id = 'notmatter'\\n block_id = 'notmatter'\\n\\n driver = self.create_driver()\\n assert isinstance(driver, SwiftStorageDriver)\\n assert isinstance(driver, object)\\n\\n # simulate swiftclient tossing exceptions\\n driver.Conn.mock_drop_connections(True)\\n\\n self.assertFalse(driver.create_vault(vault_id))\\n\\n self.assertFalse(driver.vault_exists(vault_id))\\n\\n self.assertFalse(driver.delete_vault(vault_id))\\n\\n self.assertFalse(driver.store_block(vault_id, block_id,\\n str('').encode('utf-8')))\\n\\n self.assertFalse(driver.block_exists(vault_id, block_id))\\n\\n self.assertFalse(driver.delete_block(vault_id, block_id))\\n\\n self.assertIsNone(driver.get_block_obj(vault_id, block_id))\\n\\n # Stats should come back as zero even though the connection\\n # \\\"dropped\\\"\\n bad_vault_stats = driver.get_vault_statistics(vault_id)\\n main_keys = ('total-size', 'block-count')\\n for key in main_keys:\\n assert key in bad_vault_stats.keys()\\n assert bad_vault_stats[key] == 0\\n\\n # simulate swiftclient tossing exceptions\\n driver.Conn.mock_drop_connections(False)\",\n \"def TestClosedSocketAndConnection(self):\\n self.connection.close()\\n self.s.close()\\n byte_array_msg_tx = bytes('\\\\x0C\\\\x0D\\\\x0E\\\\x0F\\\\x10\\\\x11', encoding=DATA_ENCODING)\\n\\n self.txrx.tx_msg(byte_array_msg_tx)\\n with self.assertRaises(PercivalCommsError):\\n reply = self.txrx.rx_msg()\",\n \"def test_disconnect_and_still_works(self):\\n self.client.ensure_path(\\\"/services/db/1.1.1.1\\\")\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"1\\\"}))\\n z = ZkFarmExporter(self.client, \\\"/services/db\\\", self.conf)\\n z.loop(2, timeout=self.TIMEOUT)\\n self.expire_session()\\n z.loop(10, timeout=self.TIMEOUT)\\n self.client.set(\\\"/services/db/1.1.1.1\\\",\\n json.dumps({\\\"enabled\\\": \\\"2\\\"}))\\n z.loop(2, timeout=self.TIMEOUT)\\n self.conf.write.assert_called_with({\\\"1.1.1.1\\\": {\\\"enabled\\\": \\\"2\\\"}})\",\n \"def test_disconnect_with_commit(self):\\n\\n mock_connector = MagicMock()\\n database = Database()\\n database.connect(connector_impl=mock_connector)\\n\\n # commit\\n database.disconnect(True)\\n\\n connection = mock_connector.connect()\\n self.assertTrue(connection.commit.called)\\n self.assertTrue(connection.close.called)\",\n \"async def test_endpoint_delete_share_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await delete_share_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test_rollback_and_close_on_failure(self):\\n\\n mock_connector = MagicMock()\\n\\n try:\\n with Database.connect(mysql_connector_impl=mock_connector) as database:\\n connection = database.connection\\n raise Exception('intentional test of exception handling')\\n except Exception:\\n pass\\n\\n mock_connector.connect.assert_called_once()\\n connection.commit.assert_not_called()\\n connection.close.assert_called_once()\",\n \"def test_0005(self):\\n vdc_name = config['vcloud']['vdc']\\n vapp_name = config['vcloud']['vapp']\\n the_vdc = self.vca.get_vdc(vdc_name)\\n assert the_vdc\\n assert the_vdc.get_name() == vdc_name\\n the_vapp = self.vca.get_vapp(the_vdc, vapp_name)\\n assert the_vapp\\n assert the_vapp.name == vapp_name\\n task = the_vapp.disconnect_from_networks()\\n assert task\\n result = self.vca.block_until_completed(task)\\n assert result\",\n \"def test_startconnector_with_noretry_on_con_failure(self):\\n\\n yield self.connect('127.0.0.1', self.pbPort)\\n\\n localConfig = copy.copy(self.defaultConfig)\\n localConfig.reconnectOnConnectionFailure = False\\n yield self.add(localConfig)\\n yield self.start(localConfig.id)\\n\\n # It takes a moment to stop the service after a connection failure\\n while True:\\n ssRet = yield self.service_status(localConfig.id)\\n if ssRet != 1:\\n break;\\n else:\\n time.sleep(1)\\n\\n self.assertEqual(0, ssRet)\\n\\n yield self.stop(localConfig.id)\",\n \"def test_connection_failure(aggregator, check, bad_instance):\\n instance_tags = [\\\"supervisord_server:travis\\\"]\\n with pytest.raises(Exception):\\n check.check(bad_instance)\\n aggregator.assert_service_check(\\\"supervisord.can_connect\\\", status=check.CRITICAL, tags=instance_tags, count=1)\",\n \"def _fixture(\\n self,\\n dialect_name,\\n exception,\\n db_stays_down,\\n is_disconnect=True,\\n ):\\n connect_args = {}\\n patchers = []\\n db_disconnected = False\\n\\n class DisconnectCursorMixin:\\n def execute(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return super().execute(*arg, **kw)\\n\\n if dialect_name == \\\"postgresql\\\":\\n import psycopg2.extensions\\n\\n class Curs(DisconnectCursorMixin, psycopg2.extensions.cursor):\\n pass\\n\\n connect_args = {\\\"cursor_factory\\\": Curs}\\n\\n elif dialect_name == \\\"mysql\\\":\\n import pymysql\\n\\n def fake_ping(self, *arg, **kw):\\n if db_disconnected:\\n raise exception\\n else:\\n return True\\n\\n class Curs(DisconnectCursorMixin, pymysql.cursors.Cursor):\\n pass\\n\\n connect_args = {\\\"cursorclass\\\": Curs}\\n\\n patchers.append(\\n mock.patch.object(\\n pymysql.Connection, \\\"ping\\\", fake_ping\\n )\\n )\\n else:\\n raise NotImplementedError()\\n\\n with mock.patch.object(\\n compat,\\n \\\"native_pre_ping_event_support\\\",\\n self.native_pre_ping,\\n ):\\n engine = engines.create_engine(\\n self.engine.url, max_retries=0)\\n\\n # 1. override how we connect. if we want the DB to be down\\n # for the moment, but recover, reset db_disconnected after\\n # connect is called. If we want the DB to stay down, then\\n # make sure connect raises the error also.\\n @event.listens_for(engine, \\\"do_connect\\\")\\n def _connect(dialect, connrec, cargs, cparams):\\n nonlocal db_disconnected\\n\\n # while we're here, add our cursor classes to the DBAPI\\n # connect args\\n cparams.update(connect_args)\\n\\n if db_disconnected:\\n if db_stays_down:\\n raise exception\\n else:\\n db_disconnected = False\\n\\n # 2. initialize the dialect with a first connect\\n conn = engine.connect()\\n conn.close()\\n\\n # 3. add additional patchers\\n patchers.extend([\\n mock.patch.object(\\n engine.dialect.dbapi,\\n \\\"Error\\\",\\n self.Error,\\n ),\\n mock.patch.object(\\n engine.dialect,\\n \\\"is_disconnect\\\",\\n mock.Mock(return_value=is_disconnect),\\n ),\\n ])\\n\\n with test_utils.nested(*patchers):\\n # \\\"disconnect\\\" the DB\\n db_disconnected = True\\n yield engine\",\n \"def test_connection_failure(self, exc: Exception) -> None:\\n self.sydent.run()\\n with patch.object(\\n self.sydent.sig_verifier, \\\"authenticate_request\\\", side_effect=exc\\n ):\\n request, channel = make_request(\\n self.sydent.reactor,\\n self.sydent.clientApiHttpServer.factory,\\n \\\"POST\\\",\\n \\\"/_matrix/identity/v2/3pid/unbind\\\",\\n content={\\n \\\"mxid\\\": \\\"@alice:wonderland\\\",\\n \\\"threepid\\\": {\\n \\\"address\\\": \\\"alice.cooper@wonderland.biz\\\",\\n \\\"medium\\\": \\\"email\\\",\\n },\\n },\\n )\\n self.assertEqual(channel.code, HTTPStatus.INTERNAL_SERVER_ERROR)\\n self.assertEqual(channel.json_body[\\\"errcode\\\"], \\\"M_UNKNOWN\\\")\\n self.assertIn(\\\"contact\\\", channel.json_body[\\\"error\\\"])\",\n \"def test_connect_fail(self):\\n with pytest.raises(InstrumentGatewayError):\\n with InstrumentGateway(addr='an invalid ip!'):\\n pass\",\n \"def dropConnection(): #@NoSelf\",\n \"def test_connectFailure(self):\\n db = Database.TestDB(self.mktemp())\\n # Make _db_init fail\\n db._db_init = lambda: 1 / 0\\n self.assertFalse(db.initialized)\\n try:\\n yield db.open()\\n except:\\n pass\\n self.assertFalse(db.initialized)\\n self.assertEquals(db.pool, None)\",\n \"def test_disconnect(self):\\n mediator = Mediator()\\n mediator.connect(\\\"set_dog_sound\\\", self.dog.set_sound)\\n self.assertEquals([self.dog.set_sound], mediator.signals[\\\"set_dog_sound\\\"])\\n\\n mediator.disconnect(\\\"set_dog_sound\\\", self.dog.set_sound)\\n self.assertEquals([], mediator.signals[\\\"set_dog_sound\\\"])\",\n \"def test_dependency_disconnect(self):\\n actor1 = self.create(ActorItem, UML.Actor)\\n actor2 = self.create(ActorItem, UML.Actor)\\n dep = self.create(DependencyItem)\\n\\n self.connect(dep, dep.head, actor1)\\n self.connect(dep, dep.tail, actor2)\\n\\n dep_subj = dep.subject\\n self.disconnect(dep, dep.tail)\\n\\n assert dep.subject is None\\n assert self.get_connected(dep.tail) is None\\n assert dep_subj not in self.element_factory.select()\\n assert dep_subj not in actor1.subject.supplierDependency\\n assert dep_subj not in actor2.subject.clientDependency\",\n \"def test_validation(self):\\n with self.assertRaises(DeletionError):\\n Band.delete().run_sync()\\n\\n Band.delete(force=True).run_sync()\",\n \"def handle_unexpected_disconnect(self,client_id, conn):\\n try:\\n if self.connections[client_id][\\\"host\\\"] == True: #if user is host, delete all connections\\n session_location = self.connections[client_id][\\\"session_id\\\"]\\n for key in self.sessions[session_location][\\\"USERS\\\"].keys():\\n self.disconnect(self.connections[key][\\\"CONN\\\"],client_id,f\\\"[HOST <{client_id}>:<{self.connections[client_id]['display_name']}>] Unexpectedly Disconnected\\\") #close each connection\\n self.delete_connection_entry(key) #delete the connection from the connections dictionary\\n self.delete_session(session_location) # delete the session\\n self.delete_connection_entry(client_id) # delete the original client entry from connections\\n self.disconnect(conn,client_id,\\\"You Disconnected\\\")\\n else:\\n session_location = self.connections[client_id][\\\"session_id\\\"]\\n self.delete_session_entry(session_location,client_id)\\n self.broadcast_to_session(session_location, \\\"USER_DISCONNECT_UNEXPECTED\\\",f\\\"[USER <{client_id}>:<{self.connections[client_id]['display_name']}>] Unexpectedly Disconnected\\\", exclude=[client_id])\\n self.delete_connection_entry(client_id)\\n self.disconnect(conn,client_id,\\\"You Disconnected\\\")\\n except:\\n print(\\\"Something went wrong\\\")\",\n \"def test_cannotDeleteOtherStuff(self):\\n store = Store()\\n factory = DummyFactory(store=store)\\n tcp = TCPPort(\\n store=store, factory=factory, interface=u\\\"foo\\\", portNumber=1234)\\n self.assertFailStatus(\\n 1,\\n self._makeConfig(store),\\n [\\\"delete\\\",\\n \\\"--port-identifier\\\", str(tcp.storeID),\\n \\\"--port-identifier\\\", str(factory.storeID)])\\n self.assertEqual(\\n \\\"%d does not identify a port.\\\\n\\\" % (factory.storeID,),\\n sys.stdout.getvalue())\\n self.assertEqual(list(store.query(DummyFactory)), [factory])\\n self.assertEqual(list(store.query(TCPPort)), [tcp])\",\n \"def test_connection_error(self, bad_mock):\\n bad_mock.side_effect = ConnectionError()\\n self.assertRaises(DatabaseConnectionError, Promotion.init_db, 'test')\",\n \"def test_shutdown(self):\\n server = self._server(None)\\n server.bio_shutdown()\\n with pytest.raises(Error) as err:\\n server.recv(1024)\\n # We don't want WantReadError or ZeroReturnError or anything - it's a\\n # handshake failure.\\n assert type(err.value) in [Error, SysCallError]\",\n \"def test_teardown(self):\\n with pytest.raises(NotImplementedError):\\n self.behaviour.teardown()\",\n \"def test_already_connected(connection, events, writer, schedule, flush):\\n schedule(connection.connect(), connection.connect())\\n flush()\\n assert not writer.closed\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\",\n \"def test_disconnect(self):\\n asc = self.create(AssociationItem)\\n c1 = self.create(ClassItem, UML.Class)\\n c2 = self.create(ClassItem, UML.Class)\\n\\n self.connect(asc, asc.head, c1)\\n assert asc.subject is None # no UML metaclass yet\\n\\n self.connect(asc, asc.tail, c2)\\n assert asc.subject is not None\\n\\n self.disconnect(asc, asc.head)\\n\\n # after disconnection: one diagram and two classes\\n self.assertEqual(3, len(list(self.element_factory.select())))\",\n \"def test_shutdown_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as exc:\\n server.shutdown()\\n if platform == \\\"win32\\\":\\n assert exc.value.args[0] == ESHUTDOWN\\n else:\\n assert exc.value.args[0] == EPIPE\",\n \"def stopConnecting(self):\\n self.failIfNotConnected(error.UserError())\",\n \"def test_connect_disconnect(self):\\n ms_srv = common.MatchMakingServer(2222)\\n ms_srv.start()\\n time.sleep(2)\\n\\n clients = common.start_multiple_clients(ms_srv.port, 1)\\n\\n # Disconnect the client by killing it.\\n # The sleeps here ensure the MS server and client are given enough time\\n # to interact for log entries to be written.\\n time.sleep(5)\\n clients[0].kill()\\n time.sleep(5)\\n\\n starting_game_found = False\\n player_count_found = False\\n with open(ms_srv.local_log_path) as log_file:\\n for line in log_file:\\n if \\\"Starting Game\\\" in line:\\n starting_game_found = True\\n continue\\n elif \\\"1 players\\\" in line:\\n player_count_found = True\\n continue\\n\\n self.assertTrue(player_count_found,\\n \\\"MS server should have been connected to\\\")\\n self.assertFalse(starting_game_found, \\\"Game should not have started\\\")\",\n \"def test_verify_connection_to_a_device():\",\n \"async def test_listener_del(endpoint_error_handling):\\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\\n pytest.skip(\\\"Endpoint error handling is only supported for UCX >= 1.10\\\")\\n\\n async def server_node(ep):\\n await ep.send(np.arange(100, dtype=np.int64))\\n await ep.send(np.arange(100, dtype=np.int64))\\n\\n listener = ucp.create_listener(\\n server_node, endpoint_error_handling=endpoint_error_handling\\n )\\n ep = await ucp.create_endpoint(\\n ucp.get_address(),\\n listener.port,\\n endpoint_error_handling=endpoint_error_handling,\\n )\\n msg = np.empty(100, dtype=np.int64)\\n await ep.recv(msg)\\n assert listener.closed() is False\\n del listener\\n await ep.recv(msg)\",\n \"def tearDown(self):\\n self.conn.close()\",\n \"def test_disconnectWhileProducing(self):\\n reactor = self.buildReactor()\\n\\n # For some reason, pyobject/pygtk will not deliver the close\\n # notification that should happen after the unregisterProducer call in\\n # this test. The selectable is in the write notification set, but no\\n # notification ever arrives. Probably for the same reason #5233 led\\n # win32eventreactor to be broken.\\n skippedReactors = [\\\"Glib2Reactor\\\", \\\"Gtk2Reactor\\\"]\\n reactorClassName = reactor.__class__.__name__\\n if reactorClassName in skippedReactors and platform.isWindows():\\n raise SkipTest(\\n \\\"A pygobject/pygtk bug disables this functionality \\\" \\\"on Windows.\\\"\\n )\\n\\n class Producer:\\n def resumeProducing(self):\\n log.msg(\\\"Producer.resumeProducing\\\")\\n\\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\\n\\n finished = Deferred()\\n finished.addErrback(log.err)\\n finished.addCallback(lambda ign: reactor.stop())\\n\\n class ClientProtocol(Protocol):\\n \\\"\\\"\\\"\\n Protocol to connect, register a producer, try to lose the\\n connection, unregister the producer, and wait for the connection to\\n actually be lost.\\n \\\"\\\"\\\"\\n\\n def connectionMade(self):\\n log.msg(\\\"ClientProtocol.connectionMade\\\")\\n self.transport.registerProducer(Producer(), False)\\n self.transport.loseConnection()\\n # Let the reactor tick over, in case synchronously calling\\n # loseConnection and then unregisterProducer is the same as\\n # synchronously calling unregisterProducer and then\\n # loseConnection (as it is in several reactors).\\n reactor.callLater(0, reactor.callLater, 0, self.unregister)\\n\\n def unregister(self):\\n log.msg(\\\"ClientProtocol unregister\\\")\\n self.transport.unregisterProducer()\\n # This should all be pretty quick. Fail the test\\n # if we don't get a connectionLost event really\\n # soon.\\n reactor.callLater(\\n 1.0, finished.errback, Failure(Exception(\\\"Connection was not lost\\\"))\\n )\\n\\n def connectionLost(self, reason):\\n log.msg(\\\"ClientProtocol.connectionLost\\\")\\n finished.callback(None)\\n\\n clientFactory = ClientFactory()\\n clientFactory.protocol = ClientProtocol\\n self.connect(reactor, clientFactory)\\n self.runReactor(reactor)\\n # If the test failed, we logged an error already and trial\\n # will catch it.\",\n \"def test_error(self, mock_validate_session):\\n mock_validate_session.return_value = False\\n with pytest.raises(SystemExit) as ctx:\\n celery_command.worker(Namespace(queues=1, concurrency=1))\\n assert str(ctx.value) == \\\"Worker exiting, database connection precheck failed.\\\"\",\n \"def connection_teardown():\\n test_str = make_random(100)\\n server = start_server()\\n client = start_client()\\n\\n # First write some data at both ends.\\n write_to(client, test_str)\\n write_to(server, test_str)\\n time.sleep(TEST_TIMEOUT)\\n\\n # Write EOFs on both sides.\\n write_to(client, '\\\\x1a')\\n write_to(server, '\\\\x1a')\\n client.stdin.close()\\n server.stdin.close()\\n time.sleep(TEST_TIMEOUT)\\n\\n return (\\n DEBUG_TEARDOWN in read_debug_messages_from(client) and\\n DEBUG_TEARDOWN in read_debug_messages_from(server)\\n )\",\n \"def test_disconnect_loop_auth_issue(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"def test_dead_node(self):\\r\\n self.pool._hosts.append(self.host)\\r\\n\\r\\n # cursor mock needed so set_cql_version doesn't crap out\\r\\n ok_cur = MagicMock()\\r\\n\\r\\n ok_conn = MagicMock()\\r\\n ok_conn.return_value = ok_cur\\r\\n\\r\\n\\r\\n returns = [CQLEngineException(), ok_conn]\\r\\n\\r\\n def side_effect(*args, **kwargs):\\r\\n result = returns.pop(0)\\r\\n if isinstance(result, Exception):\\r\\n raise result\\r\\n return result\\r\\n\\r\\n with patch('cqlengine.connection.cql.connect') as mock:\\r\\n mock.side_effect = side_effect\\r\\n conn = self.pool._create_connection()\",\n \"def test_shutdown(self):\\n server, client = loopback()\\n assert not server.shutdown()\\n assert server.get_shutdown() == SENT_SHUTDOWN\\n with pytest.raises(ZeroReturnError):\\n client.recv(1024)\\n assert client.get_shutdown() == RECEIVED_SHUTDOWN\\n client.shutdown()\\n assert client.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\\n with pytest.raises(ZeroReturnError):\\n server.recv(1024)\\n assert server.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\",\n \"async def test_endpoint_delete_container_shares_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await delete_container_shares_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test_reconnect_another(self):\\n line, head = self._get_line()\\n self.tool.connect(line, head, (120, 50))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n item = cinfo.connected\\n port = cinfo.port\\n constraint = cinfo.constraint\\n\\n assert item == self.box1\\n assert port == self.box1.ports()[0]\\n assert item != self.box2\\n\\n # connect to box2, handle's connected item and connection data\\n # should differ\\n self.tool.connect(line, head, (120, 150))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n self.assertEqual(self.box2, cinfo.connected)\\n self.assertEqual(self.box2.ports()[0], cinfo.port)\\n\\n # old connection does not exist\\n self.assertNotEqual(item, cinfo.connected)\\n self.assertNotEqual(constraint, cinfo.constraint)\",\n \"def test_unexpected_EOF(self):\\n server_conn, client_conn = loopback()\\n client_conn.sock_shutdown(SHUT_RDWR)\\n with pytest.raises(SysCallError) as err:\\n server_conn.recv(1024)\\n if platform == \\\"win32\\\":\\n assert err.value.args == (10054, \\\"WSAECONNRESET\\\")\\n else:\\n assert err.value.args == (-1, \\\"Unexpected EOF\\\")\",\n \"async def test_connect_ConnectorLoopError() -> None:\\n current_loop = asyncio.get_running_loop()\\n connector = Connector(loop=current_loop)\\n # try to connect using current thread's loop, should raise error\\n pytest.raises(\\n ConnectorLoopError,\\n connector.connect,\\n \\\"my-project:my-region:my-instance\\\",\\n \\\"pg8000\\\",\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8239868","0.8152695","0.77598417","0.7655665","0.75864327","0.7565692","0.75071055","0.7395507","0.73369473","0.72375166","0.7187973","0.7111573","0.7008865","0.70034695","0.6906625","0.686975","0.6785399","0.67540044","0.66884893","0.66840935","0.66407675","0.65722746","0.6555313","0.6540761","0.65373874","0.65331596","0.65150994","0.65145046","0.64680463","0.645883","0.64565665","0.64508176","0.6436945","0.6429444","0.64198923","0.6403055","0.64010745","0.6400469","0.63946515","0.6364314","0.63627464","0.6356576","0.6326292","0.6322489","0.6309458","0.6303666","0.62799436","0.62662035","0.62635916","0.6259944","0.6243845","0.6220073","0.62127036","0.62125504","0.6211044","0.6195813","0.6188611","0.6168893","0.61600935","0.61596507","0.61562634","0.614916","0.61434215","0.6141934","0.6141664","0.6141424","0.6128782","0.6126956","0.61254734","0.61235344","0.61227536","0.6117665","0.6111204","0.6101754","0.60995317","0.6097578","0.6078136","0.6068077","0.6059822","0.60479885","0.6039654","0.6019173","0.60046285","0.59989864","0.59913176","0.59825605","0.59807914","0.5962642","0.5962524","0.5954845","0.59539586","0.59466356","0.5943572","0.5940591","0.59322244","0.59259677","0.5924054","0.5919667","0.59194064","0.59191185"],"string":"[\n \"0.8239868\",\n \"0.8152695\",\n \"0.77598417\",\n \"0.7655665\",\n \"0.75864327\",\n \"0.7565692\",\n \"0.75071055\",\n \"0.7395507\",\n \"0.73369473\",\n \"0.72375166\",\n \"0.7187973\",\n \"0.7111573\",\n \"0.7008865\",\n \"0.70034695\",\n \"0.6906625\",\n \"0.686975\",\n \"0.6785399\",\n \"0.67540044\",\n \"0.66884893\",\n \"0.66840935\",\n \"0.66407675\",\n \"0.65722746\",\n \"0.6555313\",\n \"0.6540761\",\n \"0.65373874\",\n \"0.65331596\",\n \"0.65150994\",\n \"0.65145046\",\n \"0.64680463\",\n \"0.645883\",\n \"0.64565665\",\n \"0.64508176\",\n \"0.6436945\",\n \"0.6429444\",\n \"0.64198923\",\n \"0.6403055\",\n \"0.64010745\",\n \"0.6400469\",\n \"0.63946515\",\n \"0.6364314\",\n \"0.63627464\",\n \"0.6356576\",\n \"0.6326292\",\n \"0.6322489\",\n \"0.6309458\",\n \"0.6303666\",\n \"0.62799436\",\n \"0.62662035\",\n \"0.62635916\",\n \"0.6259944\",\n \"0.6243845\",\n \"0.6220073\",\n \"0.62127036\",\n \"0.62125504\",\n \"0.6211044\",\n \"0.6195813\",\n \"0.6188611\",\n \"0.6168893\",\n \"0.61600935\",\n \"0.61596507\",\n \"0.61562634\",\n \"0.614916\",\n \"0.61434215\",\n \"0.6141934\",\n \"0.6141664\",\n \"0.6141424\",\n \"0.6128782\",\n \"0.6126956\",\n \"0.61254734\",\n \"0.61235344\",\n \"0.61227536\",\n \"0.6117665\",\n \"0.6111204\",\n \"0.6101754\",\n \"0.60995317\",\n \"0.6097578\",\n \"0.6078136\",\n \"0.6068077\",\n \"0.6059822\",\n \"0.60479885\",\n \"0.6039654\",\n \"0.6019173\",\n \"0.60046285\",\n \"0.59989864\",\n \"0.59913176\",\n \"0.59825605\",\n \"0.59807914\",\n \"0.5962642\",\n \"0.5962524\",\n \"0.5954845\",\n \"0.59539586\",\n \"0.59466356\",\n \"0.5943572\",\n \"0.5940591\",\n \"0.59322244\",\n \"0.59259677\",\n \"0.5924054\",\n \"0.5919667\",\n \"0.59194064\",\n \"0.59191185\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7288089"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":84667,"cells":{"query":{"kind":"string","value":"test that having an event handler that doesn't do anything keeps the behavior in place for a fatal error."},"document":{"kind":"string","value":"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()"},"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 test_not_implemented(self):\n\n test_handler = EventHandler(self.mock_interruption_event)\n\n with self.assertRaises(NotImplementedError):\n test_handler.handle()","def test_sandbox_errors_false(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=False)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.assertRaises(Exception, self.signal.send, self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def test_unsupported_event(event_manager: EventManager, subscriber: Mock) -> None:\n event_manager.handler(GLOBAL_SCENE_CHANGE)\n subscriber.assert_not_called()","async def test_event_handler_asserts_if_called_off_event_loop(self):\n event_loop = asyncio.get_running_loop()\n session = _create_test_session(event_loop)\n\n # Pretend we're calling this function from a thread with another event_loop.\n with patch(\n \"streamlit.runtime.app_session.asyncio.get_running_loop\",\n return_value=MagicMock(),\n ):\n with self.assertRaises(AssertionError):\n session._handle_scriptrunner_event_on_event_loop(\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\n )","def test_no_alerts(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait() # no print\n event.stop()\n assert fd.getvalue() == ''","def unhandled(self):\n return True","def test_error_bubbles_up(self):\n\n def fail(box):\n box.fail(ValueError(\"oh dear\"))\n\n self.assertThat(\n lambda: sync_perform(func_dispatcher, Effect(fail)),\n raises(ValueError(\"oh dear\")),\n )","def test_no_arg(self):\n self.assertRaises(ValueError, NewickEventFactory)","def handle_uncaught_event(self, event):\r\n if widget.Widget.handle_uncaught_event(self, event):\r\n app.App.handle_uncaught_event(self, event)\r\n return True\r\n return False","def unknown_event(self, event):\r\n pass","def test_ignore_return(self):\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\n\n try:\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\n signal(SIGINT, SIG_IGN)\n assert signal(SIGINT, handler) == SIG_IGN\n finally:\n signal(SIGINT, SIG_DFL)","def test_send_event_raises():\n send_event('pytest-reportportal', '5.0.5')","def exit_if_error_handler_fired(error_handler):\n if error_handler.fired:\n logging.critical(\"Failure: exiting with code 1 due to logged errors\")\n raise SystemExit(1)","def assert_no_events_were_emitted(self):\r\n self.assertFalse(self.mock_tracker.emit.called) # pylint: disable=maybe-no-member\r\n self.mock_tracker.reset_mock()","def test_invalid_signal(self):\n mediator = Mediator()\n\n try:\n mediator.signal(\"foo\")\n except:\n raise AssertionError()","def test_segfault(self, *args, **kw):\n import aio\n\n self.assertRaises(IOError, aio.Queue, -1)\n self.assertRaises(IOError, aio.Queue, -0)\n self.assertRaises(IOError, aio.Queue, sys.maxint)\n\n q = aio.Queue()\n self.assertEquals(q.processEvents(), None)\n self.assertRaises(IOError, q.processEvents, minEvents = -1, maxEvents = -1, timeoutNSec = -1)\n self.assertRaises(IOError, q.scheduleRead, 0, 0, 0, 4096)\n self.assertRaises(IOError, q.scheduleRead, -1, 0, 1, 4096)","def test_invalid_event(bot):\n expect_error(edit, InputError, bot.username, 1, False, None, None)","def test_handle(self):\n with pytest.raises(NotImplementedError):\n self.behaviour.act()","def _dummy_callback():\n assert False, \"TRESPASS - set_callback() must be called\"","def test_sandbox_errors_true(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=True)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.signal.send(self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def test_error_handler_that_raises_errors(self, dp):\n handler_raise_error = MessageHandler(Filters.all, self.callback_raise_error)\n handler_increase_count = MessageHandler(Filters.all, self.callback_increase_count)\n error = TelegramError('Unauthorized.')\n\n dp.add_error_handler(self.error_handler_raise_error)\n\n # From errors caused by handlers\n dp.add_handler(handler_raise_error)\n dp.update_queue.put(self.message_update)\n sleep(.1)\n\n # From errors in the update_queue\n dp.remove_handler(handler_raise_error)\n dp.add_handler(handler_increase_count)\n dp.update_queue.put(error)\n dp.update_queue.put(self.message_update)\n sleep(.1)\n\n assert self.count == 1","def main():\n cause_a_bunch_of_exceptions_to_happen()","def test_alert_should_not_trigger(self, mock_print_alert):\n\n w = Worker(mock.Mock(), mock.Mock(), WORKER_CONFIG)\n\n w.tracking = deque([5, 5])\n\n w._alert()\n\n assert not w.alert\n mock_print_alert.assert_not_called()","def test_running_main_error_in_app_startup(exopy_qtbot, monkeypatch):\n from exopy.app.app_plugin import AppPlugin\n\n def false_run_startup(self, args):\n raise Exception('Fail to run start up')\n\n monkeypatch.setattr(AppPlugin, 'run_app_startup', false_run_startup)\n\n def check_dialog(qtbot, dial):\n assert 'starting' in dial.text\n\n with pytest.raises(SystemExit):\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\n main([])","def test_can_not_handle_brew_container_task_failed_event(self):\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\n self.assertFalse(self.handler.can_handle(event))","def test_no_sideeffects(self):\n c = EventLoop(\n lambda: None,\n lambda f, g: 1 / 0,\n lambda *args: 1 / 0,\n watchdog_thread=object(),\n reapAllProcesses=lambda: 1 / 0)\n del c","def test_default_return(self):\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\n\n try:\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\n signal(SIGINT, SIG_DFL)\n assert signal(SIGINT, handler) == SIG_DFL\n finally:\n signal(SIGINT, SIG_DFL)","def ensure_no_exception(values, action=\"abort\"):\n from spytest import st\n for exp in values:\n if exp is None: continue\n elif action == \"abort\": st.report_fail(\"exception_observed\", exp)\n elif action == \"trace\": st.error(\"exception in thread: {}\".format(exp))\n return True","def test_exception_raised_no_dlq():\n\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\n\n @proc.handle_for(always)\n def crash(message, ctx):\n raise RuntimeError(\"bad bytes!\")\n\n with proc.test_client() as test_client:\n blank_message = missive.RawMessage(b\"\")\n with pytest.raises(RuntimeError):\n test_client.send(blank_message)","def test_has_receivers(error_report_mock):\n\n app_crash()\n error_report_mock.assert_not_called()\n\n signal('panic').connect(triage)\n app_crash()\n error_report_mock.assert_called_with()","def test_watch_no_source():\n with pytest.raises(ValueError):\n uflash.watch_file(None, lambda: \"should never be called!\")","def test_notificationCausesException(self):\n\t\tloggedErrors = []\n\t\tdef logError(message, failure):\n\t\t\tloggedErrors.append((message, failure))\n\n\t\tdef bodyReceived(body, isQuestion):\n\t\t\traise ValueError(\"bodyReceived did something wrong\")\n\n\t\tsent = ListLog()\n\t\tdef sendQANFrame(frame):\n\t\t\tsent.append(frame)\n\n\t\th = QANHelper(bodyReceived, logError, sendQANFrame, None)\n\t\th.handleQANFrame(Notification(\"You've got more mail\"))\n\n\t\tself.assertEqual(\"Peer's Notification caused uncaught exception\", loggedErrors[0][0])\n\t\tself.assertIsInstance(loggedErrors[0][1], failure.Failure)\n\n\t\tself.assertEqual([], sent.getNew())","def test_future_event(self):\n pass","def test_silent_write_errors():\n\n tracker = pawprint.Tracker(db=None, table=None)\n\n try:\n tracker.write(event=\"This will fail silently.\")\n except Exception:\n pytest.fail(\"Failed to fail silently.\")","def test_reactor_thread_disallowed(self):\n self.patch(threadable, \"isInIOThread\", lambda: True)\n d = Deferred()\n dr = EventualResult(d, None)\n self.assertRaises(RuntimeError, dr.wait, 0)","def test_does_not_crash(self):\n py_function(6)","def testUndefinedPlaybackRaisesException(self):\n\t\tx = BaseAction('x')\n\t\ttry:\n\t\t\tpass\n\t\texcept PlayackException, e:\n\t\t\tpass","def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_thingname_nokey(self, mock):\n self.assertRaises(\n KeyError,\n lf.lambda_handler, event=self.lambdaevent_nokey, context=None)\n mock.client.return_value.update_thing_shadow.assert_not_called()","def test_filters_anonymous_with_empty_events():\n event = {}\n with pytest.raises(EventKeyError):\n filters.anonymous(event)","def test_invalid_callbacks(self):\n # Create bus\n bus = pubsub.PubSubBus()\n\n # Try to subscribe with a non-callable callback\n foo_sub = SingleSubscriber(self, bus, 'foo', 'data')\n self.assertRaises(TypeError, foo_sub.sub_cb_invalid)\n\n # Create second sub to check bus will not be broken\n foo_sub2 = SingleSubscriber(self, bus, 'foo', 'data')\n foo_sub2.subscribe_good()\n\n # Ensure that invalid callbacks (invalid signatures) do not get called\n # and do not break the bus for other subscribers\n foo_sub.subscribe_incorrect_sig()\n bus.publish('foo', 'data')\n self.assertEquals(foo_sub2.num_cb, 1)","def test_ignore_interupts():\n\n with pytest.raises(AssertionError):\n a = AssertionError()\n prefork._ignore_interrupts(a)\n with pytest.raises(AssertionError):\n a = AssertionError('Hello, how are you?', 'I am fine')\n prefork._ignore_interrupts(a)\n\n # Now, this one shouldn't raise\n a = AssertionError(errno.EINTR, 'This is a happy error.')\n prefork._ignore_interrupts(a)\n\n # Similarly\n a = AssertionError(errno.EAGAIN, 'This is a happy error.')\n prefork._ignore_interrupts(a)","async def test_http2_wrong_event(mocker):\n mocker.patch(\"aiosonic.http2.Http2Handler.__init__\", lambda x: None)\n mocker.patch(\"aiosonic.http2.Http2Handler.h2conn\")\n\n handler = Http2Handler()\n\n async def coro():\n pass\n\n with pytest.raises(MissingEvent):\n await handler.handle_events([WrongEvent])","def test_shutdown(self):\n hook = SignalHook(self.test_extension, self.signal,\n self._on_signal_fired)\n hook.disable_hook()\n\n self.assertEqual(len(self._on_signal_fired.calls), 0)\n self.signal.send(self)\n self.assertEqual(len(self._on_signal_fired.calls), 0)","def test_not_implemented(capsys):\n # TODO: line number should also be tested.\n # Initialize logging\n log.init(log_level=\"fatal\")\n\n # Run dummy() function by capturing fatal error message\n def dummy():\n util.not_implemented()\n\n dummy()\n _, stderr = capsys.readouterr()\n\n assert re.search(\"FATAL Function dummy()\", stderr) and re.search(\"midgard/tests/dev/test_util.py\", stderr)","def test_runsUntilSyncCallback(self):\n def main(reactor):\n return defer.succeed(None)\n r = _FakeReactor()\n exitError = self.assertRaises(\n SystemExit, task.react, main, _reactor=r)\n self.assertEqual(0, exitError.code)\n self.assertEqual(r.seconds(), 0)","def fatal(self, *args, **kwargs):","def test_noop():\n assert True","def test_run__not_enabled(self, init_event, mocker):\n mocker.patch.object(\n houdini_toolbox.events.event.HoudiniEvent,\n \"enabled\",\n new_callable=mocker.PropertyMock(return_value=False),\n )\n\n event = init_event()\n\n scriptargs = {\"key\": \"value\"}\n event.run(scriptargs)\n\n # If the event is disabled nothing should happen and scriptargs should\n # be unchanged.\n expected_scriptargs = {\"key\": \"value\"}\n assert scriptargs == expected_scriptargs","def test_singleStopErrback(self):\n class ExpectedException(Exception):\n pass\n\n def main(reactor):\n reactor.callLater(1, reactor.stop)\n finished = defer.Deferred()\n reactor.addSystemEventTrigger(\n 'during', 'shutdown', finished.errback, ExpectedException())\n return finished\n r = _FakeReactor()\n exitError = self.assertRaises(\n SystemExit, task.react, main, _reactor=r)\n\n self.assertEqual(1, exitError.code)\n\n self.assertEqual(r.seconds(), 1)\n errors = self.flushLoggedErrors(ExpectedException)\n self.assertEqual(len(errors), 1)","def report_unexpected_exception(self, *args, **kwargs):\n pass","def test_running_main_error_in_parsing(exopy_qtbot):\n def check_dialog(qtbot, dial):\n assert 'cmd' in dial.text\n\n with pytest.raises(SystemExit):\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\n main(['dummy'])","def test_trigger_decorator(self) -> None:\n\n def test(_: auraxium.event.Death) -> None:\n pass\n\n # pylint: disable=not-callable\n self.client.trigger(auraxium.event.Death)(test)\n self.assertEqual(len(self.client.triggers), 1)\n with self.assertRaises(KeyError):\n self.client.trigger(auraxium.event.Death)(test)\n self.assertEqual(len(self.client.triggers), 1)","def unexpectedException(self):","def must_handle_error(self):\n return (self.have_error() and\n hasattr(self, \"error_handler\") and\n (self.error_handler is not None))","def test_can_not_handle_brew_container_task_closed_event(self):\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_closed'))\n self.assertFalse(self.handler.can_handle(event))","def test_load_events_noclobber(self):\n with catch_warnings() as w:\n command = \\\n '{0} --noclobber'.format(\n os.path.join(self.datadir, 'monol_testB.evt'))\n hen.read_events.main(command.split())\n assert str(w[0].message).strip().endswith(\n \"exists and using noclobber. Skipping\"), \\\n \"Unexpected warning output\"","def test_textAsEvent_NoneText(self):\n self.assertRaises(TypeError, textAsEvent, None)","def uninstallExceptionHandler():\n\n\tsys.excepthook = sys.__excepthook__\n\treturn True","async def test_unhandled_exception_breaks_loop(\n decoy: Decoy,\n state_store: StateStore,\n command_executor: CommandExecutor,\n subject: QueueWorker,\n) -> None:\n decoy.when(await command_executor.execute(command_id=\"command-id-1\")).then_raise(\n RuntimeError(\"oh no\")\n )\n\n subject.start()\n\n with pytest.raises(RuntimeError, match=\"oh no\"):\n await subject.join()","def dummy_callback_handler(self, ret):\n pass","def handler(signum, frame):\n logging.warning(\"Got a {} signal. Doing nothing\".format(signum))","def test_main_failure(logger, argv):\n assert app.main(argv) == 1\n logger.error.called_once()","def test_error_logged_no_wait(self):\n dr = EventualResult(fail(ZeroDivisionError()), None)\n del dr\n gc.collect()\n excs = self.flushLoggedErrors(ZeroDivisionError)\n self.assertEqual(len(excs), 1)","def test_failing_action(self):\n dummy_calls = []\n\n self.ch_core.hookenv.action_fail.side_effect = dummy_calls.append\n\n def dummy_action(args):\n raise ValueError('uh oh')\n\n with mock.patch.dict(actions.ACTIONS, {'foo': dummy_action}):\n actions.main(['foo'])\n self.assertEqual(dummy_calls, ['Action \"foo\" failed: \"uh oh\"'])","def state_failsafe_do(cfg, app, win, events):","def test_gameHandleEvents(self):\n # this kinda gonna be reiterating the other tests??\n # the tests of all the individual methods below make this test work\n pass","def test_reraise_no_trigger() -> None:\n with pytest.raises(RuntimeError):\n with reraise(RuntimeError(\"got exception\")):\n raise ValueError(\"boom\")","def test_exceptions():\r\n # test that trying to connect_ to a non existent app fails\r\n try:\r\n app = application.Application()\r\n app.connect(path=r\"No process with this please\")\r\n assert False\r\n except application.ProcessNotFoundError:\r\n print('ProcessNotFoundError has been raised. OK.')\r\n\r\n # test that trying to connect_ to a non existent app fails\r\n try:\r\n app = application.Application()\r\n app.start(cmd_line = r\"No process with this please\")\r\n assert False\r\n except application.AppStartError:\r\n print('AppStartError has been raised. OK.')","def test_work_without_activity(human):\n with pytest.raises(AttributeError):\n human.work()","async def test_child_crash_propagation():\n looper_cancelled = False\n\n async def looper():\n nonlocal looper_cancelled\n try:\n while True:\n await asyncio.sleep(0)\n except asyncio.CancelledError:\n looper_cancelled = True\n\n error = ValueError('crashed')\n\n async def crasher():\n raise error\n\n with pytest.raises(ValueError) as excinfo:\n async with Nursery() as nursery:\n nursery.start_soon(looper())\n nursery.start_soon(crasher())\n\n assert looper_cancelled\n assert excinfo.value is error","def test_remove_nonexistent_listener(self):\n self.assertRaises(KeyError, self.wrapper.remove_listener, object())","def test_fails(self):\n raise FoolishError(\"I am a broken test\")","def test_tolerate_decorated_function_raise_if_exception_is_not_found():\n def test_function():\n raise AttributeError()\n fn = tolerate(exceptions=[KeyError])(test_function)\n fn()","def test_dispatchMissingUnknown(self):\n disp = Dispatcher()\n disp.disp_unknown = None\n self.assertRaises(irc.UnhandledCommand, disp.dispatch, \"bar\")","def test_method_not_found(self):\n\n pkt = {'type': 'event',\n 'name': 'foo',\n 'endpoint': '/chat',\n 'args': []\n }\n\n self.ns.process_packet(pkt)\n\n kwargs = dict(\n msg_id=None,\n endpoint='/woot',\n quiet=False\n )\n\n self.environ['socketio'].error.assert_called_with(\n 'no_such_method',\n 'The method \"%s\" was not found' % 'on_foo',\n **kwargs\n )","def test_running_main_error_in_loading(exopy_qtbot, monkeypatch):\n import exopy.__main__ as em\n\n def false_iter(arg):\n\n class FalseEntryPoint(EntryPoint):\n def load(self, *args, **kwargs):\n raise Exception(\"Can't load entry point\")\n\n return [FalseEntryPoint('dummy', 'dummy')]\n\n monkeypatch.setattr(em, 'iter_entry_points', false_iter)\n\n def check_dialog(qtbot, dial):\n assert 'extension' in dial.text\n\n with pytest.raises(SystemExit):\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\n main([])","def _sanity_check_listen_for(self, listen_for):\n if not listen_for:\n raise NothingToListenFor(\n \"EventTransport.consume() was called without providing anything \"\n 'to listen for in the \"listen_for\" argument.'\n )","def test_runsUntilSyncErrback(self):\n class ExpectedException(Exception):\n pass\n\n def main(reactor):\n return defer.fail(ExpectedException())\n r = _FakeReactor()\n exitError = self.assertRaises(\n SystemExit, task.react, main, _reactor=r)\n self.assertEqual(1, exitError.code)\n self.assertEqual(r.seconds(), 0)\n errors = self.flushLoggedErrors(ExpectedException)\n self.assertEqual(len(errors), 1)","def test_dies_if_no_job(self):\n from furious.async import Async\n from furious.context._execution import _ExecutionContext\n from furious.processors import run_job\n\n work = Async(\"dir\", kwargs={'something': None})\n work._options.pop('job')\n assert 'job' not in work._options\n\n with _ExecutionContext(work):\n self.assertRaises(Exception, run_job)","def test_case_01(self):\n if True:\n self.fail()","async def test_error_in_handler(self):\n validation_future = self.loop.create_future()\n\n async def test_handler(request: bytes, context: aio.ServicerContext):\n self.assertEqual(_REQUEST, request)\n validation_future.set_result(inject_callbacks(context))\n raise RuntimeError(\"A test RuntimeError\")\n\n await self._register_method_handler(\n grpc.unary_unary_rpc_method_handler(test_handler)\n )\n with self.assertRaises(aio.AioRpcError) as exception_context:\n await self._channel.unary_unary(_TEST_METHOD)(_REQUEST)\n rpc_error = exception_context.exception\n self.assertEqual(grpc.StatusCode.UNKNOWN, rpc_error.code())\n\n validation = await validation_future\n await validation","def test_obj_return(self):\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\n def installed(*a):\n pass\n\n try:\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\n signal(SIGINT, installed)\n assert signal(SIGINT, handler) is installed\n finally:\n signal(SIGINT, SIG_DFL)","def test_unhandledFunction(self):\n class Secret(object):\n \"\"\"\n A special modifier which exists on no keyboard.\n \"\"\"\n name = \"SECRET\"\n\n self.widget.keystrokeReceived('a', Secret())\n self.assertEqual(self.widget.buffer, '')\n self.assertEqual(self.widget.cursor, 0)","def test_register_item__non_item(self, init_event):\n event = init_event()\n\n with pytest.raises(TypeError):\n event.register_item(None)","def __empty_error_event_handler(self, govee, device, message, exception):\n\n pass","def assertEventNotCalled(self, event_name):\n if event_name not in self._events:\n raise AssertionError(\"Event {} not mocked.\".format(event_name))\n\n if self._events[event_name] != 0:\n raise AssertionError(\"Event {} was called {} times.\".format(\n event_name, self._events[event_name]))","def test_reactor_thread_disallowed(self):\n self.patch(threadable, \"isInIOThread\", lambda: True)\n f = self.make_wrapped_function()\n self.assertRaises(RuntimeError, f, None)","def test_handle_flag_error(self):\n pass","def test_raises_on_missing_job(self):\n from furious.async import Async\n from furious.errors import NotInContextError\n from furious.processors import run_job\n\n work = Async(\"nothere\")\n work._options.pop('job')\n assert 'job' not in work._options\n\n self.assertRaises(NotInContextError, run_job)","def test_empty(self):\n self.assertRaisesInternalError(())","def test_uncaught_wsgi_exception(self):\n\n def app(environ, start_response):\n raise Exception(\"Oops\")\n\n event = {\n \"httpMethod\": \"POST\",\n \"path\": \"/\",\n \"queryStringParameters\": {\n \"x\": \"y\"\n },\n \"headers\": {\n \"Host\": \"localhost\",\n \"Content-Type\": \"text/plain\",\n \"Content-Length\": \"2\"\n },\n \"body\": \"Hi\"\n }\n context = DummyContext()\n\n with self.assertRaisesRegexp(Exception, \"Oops\"):\n result = Handler(app)(event, context)\n\n # TODO: Test exc_info is logged somewhere","def test_commandRaisesUnhandledException(self):\n\n class UnhandledException(Exception):\n \"\"\"\n An unhandled exception.\n \"\"\"\n\n self.assertCommandExceptionResponse(\n UnhandledException(\"unhandled\"),\n b\"001\", b\"BAD Server error: unhandled\\r\\n\",\n )\n\n self.assertTrue(self.flushLoggedErrors(UnhandledException))","def test_cond_with_uncaught_error(env):\n def explode(env, delay):\n yield env.timeout(delay)\n raise ValueError(f'Onoes, failed after {delay}!')\n\n def process(env):\n yield env.timeout(1) | env.process(explode(env, 2))\n\n env.process(process(env))\n try:\n env.run()\n assert False, 'There should have been an exception.'\n except ValueError:\n pass\n assert env.now == 2","def test_running_main_error_in_parser_modifying(exopy_qtbot, monkeypatch):\n import exopy.__main__ as em\n\n def false_iter(arg):\n\n class FalseEntryPoint(EntryPoint):\n def load(self, *args, **kwargs):\n\n def false_modifier(parser):\n raise Exception('Failed to add stupid argument to parser')\n\n return (false_modifier, 1)\n\n return [FalseEntryPoint('dummy', 'dummy')]\n\n monkeypatch.setattr(em, 'iter_entry_points', false_iter)\n\n def check_dialog(qtbot, dial):\n assert 'modifying' in dial.text\n\n with pytest.raises(SystemExit):\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\n main([])","def test_none_plugin(self):\n with pytest.raises(ValueError):\n verzamelend.register_callbacks(None)","def check_no_alert(step):\r\n\r\n try:\r\n alert = Alert(world.browser)\r\n raise AssertionError(\"Should not see an alert. Alert '%s' shown.\" %\r\n alert.text)\r\n except NoAlertPresentException:\r\n pass","def test_dispatch_event_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n broker = self.setup_broker(worker_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n msg = msg_helper.make_ack()\n yield worker_helper.dispatch_event(msg)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])","def test_handle_install_not_idle(self):\n mock_status_callback = MagicMock()\n mock_firmware_handler = self.MockFirmwareHandler()\n\n firmware_update = OSFirmwareUpdate(\n mock_firmware_handler, mock_status_callback\n )\n firmware_update.logger.setLevel(logging.CRITICAL)\n firmware_update.logger.warning = MagicMock()\n\n firmware_update.current_status = 1 # Not None\n\n firmware_update.handle_install(\"some_file\")\n\n firmware_update.logger.warning.assert_called_once()","def test_post_with_ignore_errors_calls_all_registered_funcs(self):\n def _raise(_):\n raise Exception\n mock_event = Mock()\n mock_subscriptions = [Mock(), Mock(), Mock()]\n mock_subscriptions[0].deliver.side_effect = _raise\n bus = event_bus._event_bus\n for i, subscription in enumerate(mock_subscriptions):\n subscription.order = i\n bus._subscriptions[type(mock_event)] = mock_subscriptions\n\n event_bus.post(mock_event, ignore_errors=True)\n\n for subscription in mock_subscriptions:\n subscription.deliver.assert_called_once_with(mock_event)"],"string":"[\n \"def test_not_implemented(self):\\n\\n test_handler = EventHandler(self.mock_interruption_event)\\n\\n with self.assertRaises(NotImplementedError):\\n test_handler.handle()\",\n \"def test_sandbox_errors_false(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=False)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.assertRaises(Exception, self.signal.send, self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def test_unsupported_event(event_manager: EventManager, subscriber: Mock) -> None:\\n event_manager.handler(GLOBAL_SCENE_CHANGE)\\n subscriber.assert_not_called()\",\n \"async def test_event_handler_asserts_if_called_off_event_loop(self):\\n event_loop = asyncio.get_running_loop()\\n session = _create_test_session(event_loop)\\n\\n # Pretend we're calling this function from a thread with another event_loop.\\n with patch(\\n \\\"streamlit.runtime.app_session.asyncio.get_running_loop\\\",\\n return_value=MagicMock(),\\n ):\\n with self.assertRaises(AssertionError):\\n session._handle_scriptrunner_event_on_event_loop(\\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\\n )\",\n \"def test_no_alerts(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait() # no print\\n event.stop()\\n assert fd.getvalue() == ''\",\n \"def unhandled(self):\\n return True\",\n \"def test_error_bubbles_up(self):\\n\\n def fail(box):\\n box.fail(ValueError(\\\"oh dear\\\"))\\n\\n self.assertThat(\\n lambda: sync_perform(func_dispatcher, Effect(fail)),\\n raises(ValueError(\\\"oh dear\\\")),\\n )\",\n \"def test_no_arg(self):\\n self.assertRaises(ValueError, NewickEventFactory)\",\n \"def handle_uncaught_event(self, event):\\r\\n if widget.Widget.handle_uncaught_event(self, event):\\r\\n app.App.handle_uncaught_event(self, event)\\r\\n return True\\r\\n return False\",\n \"def unknown_event(self, event):\\r\\n pass\",\n \"def test_ignore_return(self):\\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\\n\\n try:\\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\\n signal(SIGINT, SIG_IGN)\\n assert signal(SIGINT, handler) == SIG_IGN\\n finally:\\n signal(SIGINT, SIG_DFL)\",\n \"def test_send_event_raises():\\n send_event('pytest-reportportal', '5.0.5')\",\n \"def exit_if_error_handler_fired(error_handler):\\n if error_handler.fired:\\n logging.critical(\\\"Failure: exiting with code 1 due to logged errors\\\")\\n raise SystemExit(1)\",\n \"def assert_no_events_were_emitted(self):\\r\\n self.assertFalse(self.mock_tracker.emit.called) # pylint: disable=maybe-no-member\\r\\n self.mock_tracker.reset_mock()\",\n \"def test_invalid_signal(self):\\n mediator = Mediator()\\n\\n try:\\n mediator.signal(\\\"foo\\\")\\n except:\\n raise AssertionError()\",\n \"def test_segfault(self, *args, **kw):\\n import aio\\n\\n self.assertRaises(IOError, aio.Queue, -1)\\n self.assertRaises(IOError, aio.Queue, -0)\\n self.assertRaises(IOError, aio.Queue, sys.maxint)\\n\\n q = aio.Queue()\\n self.assertEquals(q.processEvents(), None)\\n self.assertRaises(IOError, q.processEvents, minEvents = -1, maxEvents = -1, timeoutNSec = -1)\\n self.assertRaises(IOError, q.scheduleRead, 0, 0, 0, 4096)\\n self.assertRaises(IOError, q.scheduleRead, -1, 0, 1, 4096)\",\n \"def test_invalid_event(bot):\\n expect_error(edit, InputError, bot.username, 1, False, None, None)\",\n \"def test_handle(self):\\n with pytest.raises(NotImplementedError):\\n self.behaviour.act()\",\n \"def _dummy_callback():\\n assert False, \\\"TRESPASS - set_callback() must be called\\\"\",\n \"def test_sandbox_errors_true(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=True)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.signal.send(self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def test_error_handler_that_raises_errors(self, dp):\\n handler_raise_error = MessageHandler(Filters.all, self.callback_raise_error)\\n handler_increase_count = MessageHandler(Filters.all, self.callback_increase_count)\\n error = TelegramError('Unauthorized.')\\n\\n dp.add_error_handler(self.error_handler_raise_error)\\n\\n # From errors caused by handlers\\n dp.add_handler(handler_raise_error)\\n dp.update_queue.put(self.message_update)\\n sleep(.1)\\n\\n # From errors in the update_queue\\n dp.remove_handler(handler_raise_error)\\n dp.add_handler(handler_increase_count)\\n dp.update_queue.put(error)\\n dp.update_queue.put(self.message_update)\\n sleep(.1)\\n\\n assert self.count == 1\",\n \"def main():\\n cause_a_bunch_of_exceptions_to_happen()\",\n \"def test_alert_should_not_trigger(self, mock_print_alert):\\n\\n w = Worker(mock.Mock(), mock.Mock(), WORKER_CONFIG)\\n\\n w.tracking = deque([5, 5])\\n\\n w._alert()\\n\\n assert not w.alert\\n mock_print_alert.assert_not_called()\",\n \"def test_running_main_error_in_app_startup(exopy_qtbot, monkeypatch):\\n from exopy.app.app_plugin import AppPlugin\\n\\n def false_run_startup(self, args):\\n raise Exception('Fail to run start up')\\n\\n monkeypatch.setattr(AppPlugin, 'run_app_startup', false_run_startup)\\n\\n def check_dialog(qtbot, dial):\\n assert 'starting' in dial.text\\n\\n with pytest.raises(SystemExit):\\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\\n main([])\",\n \"def test_can_not_handle_brew_container_task_failed_event(self):\\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\\n self.assertFalse(self.handler.can_handle(event))\",\n \"def test_no_sideeffects(self):\\n c = EventLoop(\\n lambda: None,\\n lambda f, g: 1 / 0,\\n lambda *args: 1 / 0,\\n watchdog_thread=object(),\\n reapAllProcesses=lambda: 1 / 0)\\n del c\",\n \"def test_default_return(self):\\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\\n\\n try:\\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\\n signal(SIGINT, SIG_DFL)\\n assert signal(SIGINT, handler) == SIG_DFL\\n finally:\\n signal(SIGINT, SIG_DFL)\",\n \"def ensure_no_exception(values, action=\\\"abort\\\"):\\n from spytest import st\\n for exp in values:\\n if exp is None: continue\\n elif action == \\\"abort\\\": st.report_fail(\\\"exception_observed\\\", exp)\\n elif action == \\\"trace\\\": st.error(\\\"exception in thread: {}\\\".format(exp))\\n return True\",\n \"def test_exception_raised_no_dlq():\\n\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n with pytest.raises(RuntimeError):\\n test_client.send(blank_message)\",\n \"def test_has_receivers(error_report_mock):\\n\\n app_crash()\\n error_report_mock.assert_not_called()\\n\\n signal('panic').connect(triage)\\n app_crash()\\n error_report_mock.assert_called_with()\",\n \"def test_watch_no_source():\\n with pytest.raises(ValueError):\\n uflash.watch_file(None, lambda: \\\"should never be called!\\\")\",\n \"def test_notificationCausesException(self):\\n\\t\\tloggedErrors = []\\n\\t\\tdef logError(message, failure):\\n\\t\\t\\tloggedErrors.append((message, failure))\\n\\n\\t\\tdef bodyReceived(body, isQuestion):\\n\\t\\t\\traise ValueError(\\\"bodyReceived did something wrong\\\")\\n\\n\\t\\tsent = ListLog()\\n\\t\\tdef sendQANFrame(frame):\\n\\t\\t\\tsent.append(frame)\\n\\n\\t\\th = QANHelper(bodyReceived, logError, sendQANFrame, None)\\n\\t\\th.handleQANFrame(Notification(\\\"You've got more mail\\\"))\\n\\n\\t\\tself.assertEqual(\\\"Peer's Notification caused uncaught exception\\\", loggedErrors[0][0])\\n\\t\\tself.assertIsInstance(loggedErrors[0][1], failure.Failure)\\n\\n\\t\\tself.assertEqual([], sent.getNew())\",\n \"def test_future_event(self):\\n pass\",\n \"def test_silent_write_errors():\\n\\n tracker = pawprint.Tracker(db=None, table=None)\\n\\n try:\\n tracker.write(event=\\\"This will fail silently.\\\")\\n except Exception:\\n pytest.fail(\\\"Failed to fail silently.\\\")\",\n \"def test_reactor_thread_disallowed(self):\\n self.patch(threadable, \\\"isInIOThread\\\", lambda: True)\\n d = Deferred()\\n dr = EventualResult(d, None)\\n self.assertRaises(RuntimeError, dr.wait, 0)\",\n \"def test_does_not_crash(self):\\n py_function(6)\",\n \"def testUndefinedPlaybackRaisesException(self):\\n\\t\\tx = BaseAction('x')\\n\\t\\ttry:\\n\\t\\t\\tpass\\n\\t\\texcept PlayackException, e:\\n\\t\\t\\tpass\",\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_thingname_nokey(self, mock):\\n self.assertRaises(\\n KeyError,\\n lf.lambda_handler, event=self.lambdaevent_nokey, context=None)\\n mock.client.return_value.update_thing_shadow.assert_not_called()\",\n \"def test_filters_anonymous_with_empty_events():\\n event = {}\\n with pytest.raises(EventKeyError):\\n filters.anonymous(event)\",\n \"def test_invalid_callbacks(self):\\n # Create bus\\n bus = pubsub.PubSubBus()\\n\\n # Try to subscribe with a non-callable callback\\n foo_sub = SingleSubscriber(self, bus, 'foo', 'data')\\n self.assertRaises(TypeError, foo_sub.sub_cb_invalid)\\n\\n # Create second sub to check bus will not be broken\\n foo_sub2 = SingleSubscriber(self, bus, 'foo', 'data')\\n foo_sub2.subscribe_good()\\n\\n # Ensure that invalid callbacks (invalid signatures) do not get called\\n # and do not break the bus for other subscribers\\n foo_sub.subscribe_incorrect_sig()\\n bus.publish('foo', 'data')\\n self.assertEquals(foo_sub2.num_cb, 1)\",\n \"def test_ignore_interupts():\\n\\n with pytest.raises(AssertionError):\\n a = AssertionError()\\n prefork._ignore_interrupts(a)\\n with pytest.raises(AssertionError):\\n a = AssertionError('Hello, how are you?', 'I am fine')\\n prefork._ignore_interrupts(a)\\n\\n # Now, this one shouldn't raise\\n a = AssertionError(errno.EINTR, 'This is a happy error.')\\n prefork._ignore_interrupts(a)\\n\\n # Similarly\\n a = AssertionError(errno.EAGAIN, 'This is a happy error.')\\n prefork._ignore_interrupts(a)\",\n \"async def test_http2_wrong_event(mocker):\\n mocker.patch(\\\"aiosonic.http2.Http2Handler.__init__\\\", lambda x: None)\\n mocker.patch(\\\"aiosonic.http2.Http2Handler.h2conn\\\")\\n\\n handler = Http2Handler()\\n\\n async def coro():\\n pass\\n\\n with pytest.raises(MissingEvent):\\n await handler.handle_events([WrongEvent])\",\n \"def test_shutdown(self):\\n hook = SignalHook(self.test_extension, self.signal,\\n self._on_signal_fired)\\n hook.disable_hook()\\n\\n self.assertEqual(len(self._on_signal_fired.calls), 0)\\n self.signal.send(self)\\n self.assertEqual(len(self._on_signal_fired.calls), 0)\",\n \"def test_not_implemented(capsys):\\n # TODO: line number should also be tested.\\n # Initialize logging\\n log.init(log_level=\\\"fatal\\\")\\n\\n # Run dummy() function by capturing fatal error message\\n def dummy():\\n util.not_implemented()\\n\\n dummy()\\n _, stderr = capsys.readouterr()\\n\\n assert re.search(\\\"FATAL Function dummy()\\\", stderr) and re.search(\\\"midgard/tests/dev/test_util.py\\\", stderr)\",\n \"def test_runsUntilSyncCallback(self):\\n def main(reactor):\\n return defer.succeed(None)\\n r = _FakeReactor()\\n exitError = self.assertRaises(\\n SystemExit, task.react, main, _reactor=r)\\n self.assertEqual(0, exitError.code)\\n self.assertEqual(r.seconds(), 0)\",\n \"def fatal(self, *args, **kwargs):\",\n \"def test_noop():\\n assert True\",\n \"def test_run__not_enabled(self, init_event, mocker):\\n mocker.patch.object(\\n houdini_toolbox.events.event.HoudiniEvent,\\n \\\"enabled\\\",\\n new_callable=mocker.PropertyMock(return_value=False),\\n )\\n\\n event = init_event()\\n\\n scriptargs = {\\\"key\\\": \\\"value\\\"}\\n event.run(scriptargs)\\n\\n # If the event is disabled nothing should happen and scriptargs should\\n # be unchanged.\\n expected_scriptargs = {\\\"key\\\": \\\"value\\\"}\\n assert scriptargs == expected_scriptargs\",\n \"def test_singleStopErrback(self):\\n class ExpectedException(Exception):\\n pass\\n\\n def main(reactor):\\n reactor.callLater(1, reactor.stop)\\n finished = defer.Deferred()\\n reactor.addSystemEventTrigger(\\n 'during', 'shutdown', finished.errback, ExpectedException())\\n return finished\\n r = _FakeReactor()\\n exitError = self.assertRaises(\\n SystemExit, task.react, main, _reactor=r)\\n\\n self.assertEqual(1, exitError.code)\\n\\n self.assertEqual(r.seconds(), 1)\\n errors = self.flushLoggedErrors(ExpectedException)\\n self.assertEqual(len(errors), 1)\",\n \"def report_unexpected_exception(self, *args, **kwargs):\\n pass\",\n \"def test_running_main_error_in_parsing(exopy_qtbot):\\n def check_dialog(qtbot, dial):\\n assert 'cmd' in dial.text\\n\\n with pytest.raises(SystemExit):\\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\\n main(['dummy'])\",\n \"def test_trigger_decorator(self) -> None:\\n\\n def test(_: auraxium.event.Death) -> None:\\n pass\\n\\n # pylint: disable=not-callable\\n self.client.trigger(auraxium.event.Death)(test)\\n self.assertEqual(len(self.client.triggers), 1)\\n with self.assertRaises(KeyError):\\n self.client.trigger(auraxium.event.Death)(test)\\n self.assertEqual(len(self.client.triggers), 1)\",\n \"def unexpectedException(self):\",\n \"def must_handle_error(self):\\n return (self.have_error() and\\n hasattr(self, \\\"error_handler\\\") and\\n (self.error_handler is not None))\",\n \"def test_can_not_handle_brew_container_task_closed_event(self):\\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_closed'))\\n self.assertFalse(self.handler.can_handle(event))\",\n \"def test_load_events_noclobber(self):\\n with catch_warnings() as w:\\n command = \\\\\\n '{0} --noclobber'.format(\\n os.path.join(self.datadir, 'monol_testB.evt'))\\n hen.read_events.main(command.split())\\n assert str(w[0].message).strip().endswith(\\n \\\"exists and using noclobber. Skipping\\\"), \\\\\\n \\\"Unexpected warning output\\\"\",\n \"def test_textAsEvent_NoneText(self):\\n self.assertRaises(TypeError, textAsEvent, None)\",\n \"def uninstallExceptionHandler():\\n\\n\\tsys.excepthook = sys.__excepthook__\\n\\treturn True\",\n \"async def test_unhandled_exception_breaks_loop(\\n decoy: Decoy,\\n state_store: StateStore,\\n command_executor: CommandExecutor,\\n subject: QueueWorker,\\n) -> None:\\n decoy.when(await command_executor.execute(command_id=\\\"command-id-1\\\")).then_raise(\\n RuntimeError(\\\"oh no\\\")\\n )\\n\\n subject.start()\\n\\n with pytest.raises(RuntimeError, match=\\\"oh no\\\"):\\n await subject.join()\",\n \"def dummy_callback_handler(self, ret):\\n pass\",\n \"def handler(signum, frame):\\n logging.warning(\\\"Got a {} signal. Doing nothing\\\".format(signum))\",\n \"def test_main_failure(logger, argv):\\n assert app.main(argv) == 1\\n logger.error.called_once()\",\n \"def test_error_logged_no_wait(self):\\n dr = EventualResult(fail(ZeroDivisionError()), None)\\n del dr\\n gc.collect()\\n excs = self.flushLoggedErrors(ZeroDivisionError)\\n self.assertEqual(len(excs), 1)\",\n \"def test_failing_action(self):\\n dummy_calls = []\\n\\n self.ch_core.hookenv.action_fail.side_effect = dummy_calls.append\\n\\n def dummy_action(args):\\n raise ValueError('uh oh')\\n\\n with mock.patch.dict(actions.ACTIONS, {'foo': dummy_action}):\\n actions.main(['foo'])\\n self.assertEqual(dummy_calls, ['Action \\\"foo\\\" failed: \\\"uh oh\\\"'])\",\n \"def state_failsafe_do(cfg, app, win, events):\",\n \"def test_gameHandleEvents(self):\\n # this kinda gonna be reiterating the other tests??\\n # the tests of all the individual methods below make this test work\\n pass\",\n \"def test_reraise_no_trigger() -> None:\\n with pytest.raises(RuntimeError):\\n with reraise(RuntimeError(\\\"got exception\\\")):\\n raise ValueError(\\\"boom\\\")\",\n \"def test_exceptions():\\r\\n # test that trying to connect_ to a non existent app fails\\r\\n try:\\r\\n app = application.Application()\\r\\n app.connect(path=r\\\"No process with this please\\\")\\r\\n assert False\\r\\n except application.ProcessNotFoundError:\\r\\n print('ProcessNotFoundError has been raised. OK.')\\r\\n\\r\\n # test that trying to connect_ to a non existent app fails\\r\\n try:\\r\\n app = application.Application()\\r\\n app.start(cmd_line = r\\\"No process with this please\\\")\\r\\n assert False\\r\\n except application.AppStartError:\\r\\n print('AppStartError has been raised. OK.')\",\n \"def test_work_without_activity(human):\\n with pytest.raises(AttributeError):\\n human.work()\",\n \"async def test_child_crash_propagation():\\n looper_cancelled = False\\n\\n async def looper():\\n nonlocal looper_cancelled\\n try:\\n while True:\\n await asyncio.sleep(0)\\n except asyncio.CancelledError:\\n looper_cancelled = True\\n\\n error = ValueError('crashed')\\n\\n async def crasher():\\n raise error\\n\\n with pytest.raises(ValueError) as excinfo:\\n async with Nursery() as nursery:\\n nursery.start_soon(looper())\\n nursery.start_soon(crasher())\\n\\n assert looper_cancelled\\n assert excinfo.value is error\",\n \"def test_remove_nonexistent_listener(self):\\n self.assertRaises(KeyError, self.wrapper.remove_listener, object())\",\n \"def test_fails(self):\\n raise FoolishError(\\\"I am a broken test\\\")\",\n \"def test_tolerate_decorated_function_raise_if_exception_is_not_found():\\n def test_function():\\n raise AttributeError()\\n fn = tolerate(exceptions=[KeyError])(test_function)\\n fn()\",\n \"def test_dispatchMissingUnknown(self):\\n disp = Dispatcher()\\n disp.disp_unknown = None\\n self.assertRaises(irc.UnhandledCommand, disp.dispatch, \\\"bar\\\")\",\n \"def test_method_not_found(self):\\n\\n pkt = {'type': 'event',\\n 'name': 'foo',\\n 'endpoint': '/chat',\\n 'args': []\\n }\\n\\n self.ns.process_packet(pkt)\\n\\n kwargs = dict(\\n msg_id=None,\\n endpoint='/woot',\\n quiet=False\\n )\\n\\n self.environ['socketio'].error.assert_called_with(\\n 'no_such_method',\\n 'The method \\\"%s\\\" was not found' % 'on_foo',\\n **kwargs\\n )\",\n \"def test_running_main_error_in_loading(exopy_qtbot, monkeypatch):\\n import exopy.__main__ as em\\n\\n def false_iter(arg):\\n\\n class FalseEntryPoint(EntryPoint):\\n def load(self, *args, **kwargs):\\n raise Exception(\\\"Can't load entry point\\\")\\n\\n return [FalseEntryPoint('dummy', 'dummy')]\\n\\n monkeypatch.setattr(em, 'iter_entry_points', false_iter)\\n\\n def check_dialog(qtbot, dial):\\n assert 'extension' in dial.text\\n\\n with pytest.raises(SystemExit):\\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\\n main([])\",\n \"def _sanity_check_listen_for(self, listen_for):\\n if not listen_for:\\n raise NothingToListenFor(\\n \\\"EventTransport.consume() was called without providing anything \\\"\\n 'to listen for in the \\\"listen_for\\\" argument.'\\n )\",\n \"def test_runsUntilSyncErrback(self):\\n class ExpectedException(Exception):\\n pass\\n\\n def main(reactor):\\n return defer.fail(ExpectedException())\\n r = _FakeReactor()\\n exitError = self.assertRaises(\\n SystemExit, task.react, main, _reactor=r)\\n self.assertEqual(1, exitError.code)\\n self.assertEqual(r.seconds(), 0)\\n errors = self.flushLoggedErrors(ExpectedException)\\n self.assertEqual(len(errors), 1)\",\n \"def test_dies_if_no_job(self):\\n from furious.async import Async\\n from furious.context._execution import _ExecutionContext\\n from furious.processors import run_job\\n\\n work = Async(\\\"dir\\\", kwargs={'something': None})\\n work._options.pop('job')\\n assert 'job' not in work._options\\n\\n with _ExecutionContext(work):\\n self.assertRaises(Exception, run_job)\",\n \"def test_case_01(self):\\n if True:\\n self.fail()\",\n \"async def test_error_in_handler(self):\\n validation_future = self.loop.create_future()\\n\\n async def test_handler(request: bytes, context: aio.ServicerContext):\\n self.assertEqual(_REQUEST, request)\\n validation_future.set_result(inject_callbacks(context))\\n raise RuntimeError(\\\"A test RuntimeError\\\")\\n\\n await self._register_method_handler(\\n grpc.unary_unary_rpc_method_handler(test_handler)\\n )\\n with self.assertRaises(aio.AioRpcError) as exception_context:\\n await self._channel.unary_unary(_TEST_METHOD)(_REQUEST)\\n rpc_error = exception_context.exception\\n self.assertEqual(grpc.StatusCode.UNKNOWN, rpc_error.code())\\n\\n validation = await validation_future\\n await validation\",\n \"def test_obj_return(self):\\n from signal import signal, SIGINT, SIG_DFL, SIG_IGN\\n def installed(*a):\\n pass\\n\\n try:\\n for handler in SIG_DFL, SIG_IGN, lambda *a: None:\\n signal(SIGINT, installed)\\n assert signal(SIGINT, handler) is installed\\n finally:\\n signal(SIGINT, SIG_DFL)\",\n \"def test_unhandledFunction(self):\\n class Secret(object):\\n \\\"\\\"\\\"\\n A special modifier which exists on no keyboard.\\n \\\"\\\"\\\"\\n name = \\\"SECRET\\\"\\n\\n self.widget.keystrokeReceived('a', Secret())\\n self.assertEqual(self.widget.buffer, '')\\n self.assertEqual(self.widget.cursor, 0)\",\n \"def test_register_item__non_item(self, init_event):\\n event = init_event()\\n\\n with pytest.raises(TypeError):\\n event.register_item(None)\",\n \"def __empty_error_event_handler(self, govee, device, message, exception):\\n\\n pass\",\n \"def assertEventNotCalled(self, event_name):\\n if event_name not in self._events:\\n raise AssertionError(\\\"Event {} not mocked.\\\".format(event_name))\\n\\n if self._events[event_name] != 0:\\n raise AssertionError(\\\"Event {} was called {} times.\\\".format(\\n event_name, self._events[event_name]))\",\n \"def test_reactor_thread_disallowed(self):\\n self.patch(threadable, \\\"isInIOThread\\\", lambda: True)\\n f = self.make_wrapped_function()\\n self.assertRaises(RuntimeError, f, None)\",\n \"def test_handle_flag_error(self):\\n pass\",\n \"def test_raises_on_missing_job(self):\\n from furious.async import Async\\n from furious.errors import NotInContextError\\n from furious.processors import run_job\\n\\n work = Async(\\\"nothere\\\")\\n work._options.pop('job')\\n assert 'job' not in work._options\\n\\n self.assertRaises(NotInContextError, run_job)\",\n \"def test_empty(self):\\n self.assertRaisesInternalError(())\",\n \"def test_uncaught_wsgi_exception(self):\\n\\n def app(environ, start_response):\\n raise Exception(\\\"Oops\\\")\\n\\n event = {\\n \\\"httpMethod\\\": \\\"POST\\\",\\n \\\"path\\\": \\\"/\\\",\\n \\\"queryStringParameters\\\": {\\n \\\"x\\\": \\\"y\\\"\\n },\\n \\\"headers\\\": {\\n \\\"Host\\\": \\\"localhost\\\",\\n \\\"Content-Type\\\": \\\"text/plain\\\",\\n \\\"Content-Length\\\": \\\"2\\\"\\n },\\n \\\"body\\\": \\\"Hi\\\"\\n }\\n context = DummyContext()\\n\\n with self.assertRaisesRegexp(Exception, \\\"Oops\\\"):\\n result = Handler(app)(event, context)\\n\\n # TODO: Test exc_info is logged somewhere\",\n \"def test_commandRaisesUnhandledException(self):\\n\\n class UnhandledException(Exception):\\n \\\"\\\"\\\"\\n An unhandled exception.\\n \\\"\\\"\\\"\\n\\n self.assertCommandExceptionResponse(\\n UnhandledException(\\\"unhandled\\\"),\\n b\\\"001\\\", b\\\"BAD Server error: unhandled\\\\r\\\\n\\\",\\n )\\n\\n self.assertTrue(self.flushLoggedErrors(UnhandledException))\",\n \"def test_cond_with_uncaught_error(env):\\n def explode(env, delay):\\n yield env.timeout(delay)\\n raise ValueError(f'Onoes, failed after {delay}!')\\n\\n def process(env):\\n yield env.timeout(1) | env.process(explode(env, 2))\\n\\n env.process(process(env))\\n try:\\n env.run()\\n assert False, 'There should have been an exception.'\\n except ValueError:\\n pass\\n assert env.now == 2\",\n \"def test_running_main_error_in_parser_modifying(exopy_qtbot, monkeypatch):\\n import exopy.__main__ as em\\n\\n def false_iter(arg):\\n\\n class FalseEntryPoint(EntryPoint):\\n def load(self, *args, **kwargs):\\n\\n def false_modifier(parser):\\n raise Exception('Failed to add stupid argument to parser')\\n\\n return (false_modifier, 1)\\n\\n return [FalseEntryPoint('dummy', 'dummy')]\\n\\n monkeypatch.setattr(em, 'iter_entry_points', false_iter)\\n\\n def check_dialog(qtbot, dial):\\n assert 'modifying' in dial.text\\n\\n with pytest.raises(SystemExit):\\n with handle_dialog(exopy_qtbot, 'reject', check_dialog):\\n main([])\",\n \"def test_none_plugin(self):\\n with pytest.raises(ValueError):\\n verzamelend.register_callbacks(None)\",\n \"def check_no_alert(step):\\r\\n\\r\\n try:\\r\\n alert = Alert(world.browser)\\r\\n raise AssertionError(\\\"Should not see an alert. Alert '%s' shown.\\\" %\\r\\n alert.text)\\r\\n except NoAlertPresentException:\\r\\n pass\",\n \"def test_dispatch_event_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n broker = self.setup_broker(worker_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n msg = msg_helper.make_ack()\\n yield worker_helper.dispatch_event(msg)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])\",\n \"def test_handle_install_not_idle(self):\\n mock_status_callback = MagicMock()\\n mock_firmware_handler = self.MockFirmwareHandler()\\n\\n firmware_update = OSFirmwareUpdate(\\n mock_firmware_handler, mock_status_callback\\n )\\n firmware_update.logger.setLevel(logging.CRITICAL)\\n firmware_update.logger.warning = MagicMock()\\n\\n firmware_update.current_status = 1 # Not None\\n\\n firmware_update.handle_install(\\\"some_file\\\")\\n\\n firmware_update.logger.warning.assert_called_once()\",\n \"def test_post_with_ignore_errors_calls_all_registered_funcs(self):\\n def _raise(_):\\n raise Exception\\n mock_event = Mock()\\n mock_subscriptions = [Mock(), Mock(), Mock()]\\n mock_subscriptions[0].deliver.side_effect = _raise\\n bus = event_bus._event_bus\\n for i, subscription in enumerate(mock_subscriptions):\\n subscription.order = i\\n bus._subscriptions[type(mock_event)] = mock_subscriptions\\n\\n event_bus.post(mock_event, ignore_errors=True)\\n\\n for subscription in mock_subscriptions:\\n subscription.deliver.assert_called_once_with(mock_event)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7467973","0.6660555","0.65037405","0.64326495","0.64048284","0.63686633","0.63043034","0.62444484","0.62275404","0.62135327","0.62035763","0.6167127","0.61608183","0.6148361","0.6082591","0.60748696","0.6074616","0.6068908","0.6063432","0.6061368","0.6038419","0.60275656","0.6017873","0.59864116","0.59813124","0.5968436","0.59673285","0.5966956","0.59570396","0.59489644","0.59343475","0.5932435","0.59298617","0.5925118","0.5909204","0.5895916","0.589439","0.589435","0.5885058","0.58846915","0.58771956","0.5853919","0.5848794","0.58378947","0.5833192","0.58314776","0.5826612","0.5820521","0.58162427","0.5810215","0.5810033","0.5805432","0.58039355","0.5798851","0.5796536","0.5792627","0.57802385","0.57767606","0.5774769","0.5772673","0.5771511","0.5767019","0.5758892","0.57547104","0.57490844","0.57485664","0.5746294","0.5732956","0.5731953","0.5723388","0.5714801","0.5714606","0.5710325","0.5709791","0.5707185","0.57069576","0.5693444","0.5689643","0.56826544","0.56793475","0.5677757","0.56766504","0.5675103","0.56720483","0.5671596","0.5669498","0.5668173","0.56678843","0.5666558","0.5655557","0.5654907","0.56531435","0.56520313","0.56474054","0.5647249","0.56456983","0.5637711","0.5637582","0.5637541","0.5629198"],"string":"[\n \"0.7467973\",\n \"0.6660555\",\n \"0.65037405\",\n \"0.64326495\",\n \"0.64048284\",\n \"0.63686633\",\n \"0.63043034\",\n \"0.62444484\",\n \"0.62275404\",\n \"0.62135327\",\n \"0.62035763\",\n \"0.6167127\",\n \"0.61608183\",\n \"0.6148361\",\n \"0.6082591\",\n \"0.60748696\",\n \"0.6074616\",\n \"0.6068908\",\n \"0.6063432\",\n \"0.6061368\",\n \"0.6038419\",\n \"0.60275656\",\n \"0.6017873\",\n \"0.59864116\",\n \"0.59813124\",\n \"0.5968436\",\n \"0.59673285\",\n \"0.5966956\",\n \"0.59570396\",\n \"0.59489644\",\n \"0.59343475\",\n \"0.5932435\",\n \"0.59298617\",\n \"0.5925118\",\n \"0.5909204\",\n \"0.5895916\",\n \"0.589439\",\n \"0.589435\",\n \"0.5885058\",\n \"0.58846915\",\n \"0.58771956\",\n \"0.5853919\",\n \"0.5848794\",\n \"0.58378947\",\n \"0.5833192\",\n \"0.58314776\",\n \"0.5826612\",\n \"0.5820521\",\n \"0.58162427\",\n \"0.5810215\",\n \"0.5810033\",\n \"0.5805432\",\n \"0.58039355\",\n \"0.5798851\",\n \"0.5796536\",\n \"0.5792627\",\n \"0.57802385\",\n \"0.57767606\",\n \"0.5774769\",\n \"0.5772673\",\n \"0.5771511\",\n \"0.5767019\",\n \"0.5758892\",\n \"0.57547104\",\n \"0.57490844\",\n \"0.57485664\",\n \"0.5746294\",\n \"0.5732956\",\n \"0.5731953\",\n \"0.5723388\",\n \"0.5714801\",\n \"0.5714606\",\n \"0.5710325\",\n \"0.5709791\",\n \"0.5707185\",\n \"0.57069576\",\n \"0.5693444\",\n \"0.5689643\",\n \"0.56826544\",\n \"0.56793475\",\n \"0.5677757\",\n \"0.56766504\",\n \"0.5675103\",\n \"0.56720483\",\n \"0.5671596\",\n \"0.5669498\",\n \"0.5668173\",\n \"0.56678843\",\n \"0.5666558\",\n \"0.5655557\",\n \"0.5654907\",\n \"0.56531435\",\n \"0.56520313\",\n \"0.56474054\",\n \"0.5647249\",\n \"0.56456983\",\n \"0.5637711\",\n \"0.5637582\",\n \"0.5637541\",\n \"0.5629198\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6120394"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":84668,"cells":{"query":{"kind":"string","value":"test that having an event handler that doesn't do anything keeps the behavior in place for a disconnect error."},"document":{"kind":"string","value":"def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()"},"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 test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()","def test_run_without_message(connection, events, loop):\n loop.run_until_complete(connection.run())\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_already_disconnected(connection, events, schedule, flush):\n schedule(connection.connect(),\n connection.disconnect(),\n connection.disconnect())\n flush()\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_disconnect_before_connect(connection, events, schedule, flush):\n schedule(connection.disconnect())\n flush()\n assert not connection.connected\n assert not events.triggered(\"CLIENT_CONNECT\")\n assert not events.triggered(\"CLIENT_DISCONNECT\")","def test_invalid_disconnect(self):\n mediator = Mediator()\n try:\n mediator.disconnect(\"foo\", self.dog.set_sound)\n mediator.disconnect(\"bar\", self.cat.set_sound)\n except:\n raise AssertionError()","def test_disconnect_multiple(self):\n self.inverter.disconnect()\n self.inverter.disconnect() # Should not raise exception","def test_disconnect(writer, patch_connection, events, connection,\n schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n assert not connection.connected\n assert writer.closed\n assert connection.writer is None\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def inner_test(param: enums.DisconnectReason):\n pass","def test_dispatch_event_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n broker = self.setup_broker(worker_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n msg = msg_helper.make_ack()\n yield worker_helper.dispatch_event(msg)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])","def test_parse_message_failure_disconnect(self, mock_disconnect):\n for test_case in self.failure_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertNotEqual(expected, mock_disconnect)","def test_verify_state_of_a_device_when_disconnected_from_the_device():","def test_clear_dispatched_events_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n msg = msg_helper.make_ack()\n self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg)\n self.assertNotEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\n worker_helper.clear_dispatched_events()\n self.assertEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])","def test_disconnect_closed(self):\n self.sock.close()\n self.inverter.sock.close()\n self.inverter.sock_file.close()\n self.inverter.disconnect() # Should not raise exception","async def test_timeout_disconnect():\n communicator = WebsocketCommunicator(ErrorWebsocketApp(), \"/testws/\")\n # Test connection\n connected, subprotocol = await communicator.connect()\n assert connected\n assert subprotocol is None\n # Test sending text (will error internally)\n await communicator.send_to(text_data=\"hello\")\n with pytest.raises(asyncio.TimeoutError):\n await communicator.receive_from()\n # Close out\n await communicator.disconnect()","async def test_disconnect(self):\n await self.webhook_connection.connect()\n assert self.webhook_connection.is_connected is True\n\n await self.webhook_connection.disconnect()\n assert self.webhook_connection.is_connected is False","def test_not_implemented(self):\n\n test_handler = EventHandler(self.mock_interruption_event)\n\n with self.assertRaises(NotImplementedError):\n test_handler.handle()","def test_send_disconnected(connection, writer, schedule, flush):\n schedule(connection.connect(), connection.disconnect())\n flush()\n connection.send(\"test\")\n assert not writer.used","async def test_event_handler_asserts_if_called_off_event_loop(self):\n event_loop = asyncio.get_running_loop()\n session = _create_test_session(event_loop)\n\n # Pretend we're calling this function from a thread with another event_loop.\n with patch(\n \"streamlit.runtime.app_session.asyncio.get_running_loop\",\n return_value=MagicMock(),\n ):\n with self.assertRaises(AssertionError):\n session._handle_scriptrunner_event_on_event_loop(\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\n )","async def test_handle_message_disconnected_empty(\n subject: helpers.ModuleListener, mock_callback: AsyncMock\n) -> None:\n message = models.Message(status=\"disconnected\", connections=[])\n await subject.handle_message(message=message)\n mock_callback.assert_called_once_with([], [])","def testConnectionLost(self):\n d = self.testSimpleRequest()\n d.addCallback(lambda _: self.factory.crash())\n d.addCallback(lambda _: self.client.check_rate_limit())\n d.addTimeout(0.01, reactor)\n self.assertFailure(d, ConnectionClosed)\n return d","def test_wait_for_dispatched_events_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n d = worker_helper.wait_for_dispatched_events(1)\n self.assertEqual(d.called, False)\n msg = msg_helper.make_ack()\n yield self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg, kick=True)\n dispatched = success_result_of(d)\n self.assertEqual(dispatched, [msg])","def test_disconnect_from_client_side(\n start_result_q_publisher, start_result_q_subscriber\n):\n\n result_pub = start_result_q_publisher()\n f = result_pub.publish(b\"Hello test_disconnect_from_client_side 1\")\n assert f.result(timeout=1) is None\n\n result_pub.stop()\n\n try_assert(lambda: not result_pub.is_alive(), \"Verify test setup\")\n with pytest.raises(ValueError):\n result_pub.publish(b\"Hello test_disconnect_from_client_side 2\")","async def test_listener_del(endpoint_error_handling):\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\n pytest.skip(\"Endpoint error handling is only supported for UCX >= 1.10\")\n\n async def server_node(ep):\n await ep.send(np.arange(100, dtype=np.int64))\n await ep.send(np.arange(100, dtype=np.int64))\n\n listener = ucp.create_listener(\n server_node, endpoint_error_handling=endpoint_error_handling\n )\n ep = await ucp.create_endpoint(\n ucp.get_address(),\n listener.port,\n endpoint_error_handling=endpoint_error_handling,\n )\n msg = np.empty(100, dtype=np.int64)\n await ep.recv(msg)\n assert listener.closed() is False\n del listener\n await ep.recv(msg)","async def test_endpoint_gave_access_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await gave_access_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test_idleClientDoesDisconnect(self):\n c = Clock()\n # Hook up our server protocol\n transport = StringTransportWithDisconnection()\n transport.protocol = self.server\n self.server.callLater = c.callLater\n self.server.makeConnection(transport)\n\n # Make sure we can notice when the connection goes away\n lost = []\n connLost = self.server.connectionLost\n self.server.connectionLost = lambda reason: (lost.append(None), connLost(reason))[1]\n\n # 2/3rds of the idle timeout elapses...\n c.pump([0.0] + [self.server.timeOut / 3.0] * 2)\n self.assertFalse(lost, lost)\n\n # Now some more\n c.pump([0.0, self.server.timeOut / 2.0])\n self.assertTrue(lost)","def test_invalid_signal(self):\n mediator = Mediator()\n\n try:\n mediator.signal(\"foo\")\n except:\n raise AssertionError()","async def test_listener_close(endpoint_error_handling):\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\n pytest.skip(\"Endpoint error handling is only supported for UCX >= 1.10\")\n\n async def client_node(listener):\n ep = await ucp.create_endpoint(\n ucp.get_address(),\n listener.port,\n endpoint_error_handling=endpoint_error_handling,\n )\n msg = np.empty(100, dtype=np.int64)\n await ep.recv(msg)\n await ep.recv(msg)\n assert listener.closed() is False\n listener.close()\n assert listener.closed() is True\n\n async def server_node(ep):\n await ep.send(np.arange(100, dtype=np.int64))\n await ep.send(np.arange(100, dtype=np.int64))\n\n listener = ucp.create_listener(\n server_node, endpoint_error_handling=endpoint_error_handling\n )\n await client_node(listener)","def test_disconnect(self):\n self.inverter.disconnect()\n sleep(0.02)","def test_parse_message_failure_connect(self):\n for test_case in self.failure_test_params_wrong_connect:\n expected = test_case[KEY_EXPECTED]\n mock_connect = app.on_connect()\n\n self.assertNotEqual(expected, mock_connect)","async def test_context_manager_disconnect_handling(preset_server, event_loop):\n preset_client = SMTP(\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\n )\n\n async with preset_client:\n assert preset_client.is_connected\n\n preset_server.responses.append(b\"250 noop\")\n preset_server.drop_connection_event.set()\n\n try:\n await preset_client.noop()\n except SMTPServerDisconnected:\n pass\n\n assert not preset_client.is_connected","def test_protocolShutDown(self):\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return result\n\n resolver._connectedProtocol = FakeProtocol\n resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[0].transport.disconnected)\n result.callback(dns.Message())\n self.assertTrue(protocols[0].transport.disconnected)","async def test_handle_message_disconnected_one(\n subject: helpers.ModuleListener,\n mock_callback: AsyncMock,\n connections: List[models.ModuleConnection],\n modules_at_port: List[ModuleAtPort],\n) -> None:\n message = models.Message(status=\"disconnected\", connections=connections[:1])\n await subject.handle_message(message=message)\n mock_callback.assert_called_once_with([], modules_at_port[:1])","def test_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as err:\n server.sendall(b\"hello, world\")\n if platform == \"win32\":\n assert err.value.args[0] == ESHUTDOWN\n else:\n assert err.value.args[0] == EPIPE","def test_control(self, ping_fixture):\n engine = ping_fixture\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_unsubscribe_any_listener(self):\n with self.assertRaises(AssertionError):\n EVENT_MANAGER.unsubscribe()","def test_parse_message_success_disconnect(self):\n for test_case in self.success_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertEqual(expected, mock_disconnect)","async def test_endpoint_has_access_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await has_access_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","async def test_http2_wrong_event(mocker):\n mocker.patch(\"aiosonic.http2.Http2Handler.__init__\", lambda x: None)\n mocker.patch(\"aiosonic.http2.Http2Handler.h2conn\")\n\n handler = Http2Handler()\n\n async def coro():\n pass\n\n with pytest.raises(MissingEvent):\n await handler.handle_events([WrongEvent])","def test_protocolShutDownAfterFailure(self):\n class ExpectedException(Exception):\n pass\n\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return result\n\n resolver._connectedProtocol = FakeProtocol\n queryResult = resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[0].transport.disconnected)\n result.errback(failure.Failure(ExpectedException()))\n self.assertTrue(protocols[0].transport.disconnected)\n\n return self.assertFailure(queryResult, ExpectedException)","def test_read_disconnected(connection, reader, schedule, flush, loop):\n schedule(connection.connect(), connection.disconnect())\n flush()\n value = loop.run_until_complete(connection.read())\n assert not value\n assert not reader.used","def test_handle_calls(tchannel_pair):\n class _MyException(Exception):\n pass\n\n def my_handler(context, connection):\n raise _MyException()\n\n server, client = tchannel_pair\n client.ping()\n with pytest.raises(_MyException):\n server.handle_calls(my_handler)","async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\n leak_tracker.set_initial_object_list()\n\n await client.connect()\n assert client.connected\n dropper.reject_outgoing()\n\n while client.connected:\n await asyncio.sleep(1)\n\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\n dropper.restore_all()\n while not client.connected:\n await asyncio.sleep(1)\n\n leak_tracker.check_for_leaks()","def test_get_dispatched_events_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n dispatched = worker_helper.get_dispatched_events()\n self.assertEqual(dispatched, [])\n msg = msg_helper.make_ack()\n self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg)\n dispatched = worker_helper.get_dispatched_events()\n self.assertEqual(dispatched, [msg])","def connectionLost(reason):","def test_writeAfterDisconnect(self):\n reactor = self.buildReactor()\n\n finished = []\n\n serverConnectionLostDeferred = Deferred()\n protocol = lambda: ClosingLaterProtocol(serverConnectionLostDeferred)\n portDeferred = self.endpoints.server(reactor).listen(\n ServerFactory.forProtocol(protocol)\n )\n\n def listening(port):\n msg(\"Listening on {!r}\".format(port.getHost()))\n endpoint = self.endpoints.client(reactor, port.getHost())\n\n lostConnectionDeferred = Deferred()\n protocol = lambda: ClosingLaterProtocol(lostConnectionDeferred)\n client = endpoint.connect(ClientFactory.forProtocol(protocol))\n\n def write(proto):\n msg(\"About to write to {!r}\".format(proto))\n proto.transport.write(b\"x\")\n\n client.addCallbacks(write, lostConnectionDeferred.errback)\n\n def disconnected(proto):\n msg(\"{!r} disconnected\".format(proto))\n proto.transport.write(b\"some bytes to get lost\")\n proto.transport.writeSequence([b\"some\", b\"more\"])\n finished.append(True)\n\n lostConnectionDeferred.addCallback(disconnected)\n serverConnectionLostDeferred.addCallback(disconnected)\n return gatherResults([lostConnectionDeferred, serverConnectionLostDeferred])\n\n def onListen():\n portDeferred.addCallback(listening)\n portDeferred.addErrback(err)\n portDeferred.addCallback(lambda ignored: reactor.stop())\n\n needsRunningReactor(reactor, onListen)\n\n self.runReactor(reactor)\n self.assertEqual(finished, [True, True])","def test_keep_alive_cancelled(self):\n sleep(0.005) # Wait before a keep-alive message will be sent\n self.inverter.send(b\"\\x01\\x02\\x03\", b\"\") # Send something arbitrary\n self.sock.recv(4096) # Retrieve the sent message\n sleep(0.008) # Wait until just before the next keep-alive is supposed to happen\n # Check that no message was sent\n self.sock.setblocking(False)\n with self.assertRaises(BlockingIOError):\n self.sock.recv(4096)","def test_disconnect_loop_invalid_grant(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","def test_asyncio_component_404(event_loop):\n orig_loop = txaio.config.loop\n txaio.config.loop = event_loop\n\n class FakeTransport(object):\n def close(self):\n pass\n\n def write(self, data):\n pass\n\n fake_transport = FakeTransport()\n actual_protocol = [None] # set in a closure below\n\n def create_connection(protocol_factory=None, server_hostname=None, host=None, port=None, ssl=False):\n if actual_protocol[0] is None:\n protocol = protocol_factory()\n actual_protocol[0] = protocol\n protocol.connection_made(fake_transport)\n return txaio.create_future_success((fake_transport, protocol))\n else:\n return txaio.create_future_error(RuntimeError(\"second connection fails completely\"))\n\n with mock.patch.object(event_loop, 'create_connection', create_connection):\n event_loop.create_connection = create_connection\n\n comp = Component(\n transports=[\n {\n \"url\": \"ws://localhost:12/bogus\",\n \"max_retries\": 1,\n \"max_retry_delay\": 0.1,\n }\n ]\n )\n\n # if having trouble, try starting some logging (and use\n # \"py.test -s\" to get real-time output)\n # txaio.start_logging(level=\"debug\")\n f = comp.start(loop=event_loop)\n txaio.config.loop = event_loop\n\n # now that we've started connecting, we *should* be able\n # to connetion_lost our transport .. but we do a\n # call-later to ensure we're after the setup stuff in the\n # event-loop (because asyncio doesn't synchronously\n # process already-completed Futures like Twisted does)\n\n def nuke_transport():\n actual_protocol[0].connection_lost(None) # asyncio can call this with None\n txaio.call_later(0.1, nuke_transport)\n\n finished = txaio.create_future()\n\n def fail():\n finished.set_exception(AssertionError(\"timed out\"))\n txaio.config.loop = orig_loop\n txaio.call_later(1.0, fail)\n\n def done(f):\n try:\n f.result()\n finished.set_exception(AssertionError(\"should get an error\"))\n except RuntimeError as e:\n if 'Exhausted all transport connect attempts' not in str(e):\n finished.set_exception(AssertionError(\"wrong exception caught\"))\n finished.set_result(None)\n txaio.config.loop = orig_loop\n f.add_done_callback(done)\n return finished","def test_shutdown(self):\n server, client = loopback()\n assert not server.shutdown()\n assert server.get_shutdown() == SENT_SHUTDOWN\n with pytest.raises(ZeroReturnError):\n client.recv(1024)\n assert client.get_shutdown() == RECEIVED_SHUTDOWN\n client.shutdown()\n assert client.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\n with pytest.raises(ZeroReturnError):\n server.recv(1024)\n assert server.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)","async def test_disconnected_server_raises_on_data_write(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESS\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def on_disconnect(unused_client, unused_userdata, rc):\n print(f\"on_disconnect: {error_str(rc)}\")\n print()\n\n global connected\n connected = False","def test_disconnect(self):\n\n\t\twith EchoServer(bind_addr = ('', 12122)):\n\t\t\tyield reactor.schedule()\n\t\t\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\n\t\t\tyield client.connect()\n\n\t\t\tclient.close()","async def test_endpoint_shared_details_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await shared_details_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test__API_without_answer(self):\n self.mock_connection.state = MockConnection.NO_CONFIRMATIONS\n\n # timeout supposed to be here\n self.assertEqual(self.mutex.lock(), False) # acquire mutex","async def test_endpoint_delete_share_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await delete_share_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","async def test_server_shutdown(endpoint_error_handling):\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\n pytest.skip(\"Endpoint error handling is only supported for UCX >= 1.10\")\n\n async def server_node(ep):\n msg = np.empty(10 ** 6)\n with pytest.raises(ucp.exceptions.UCXCanceled):\n await asyncio.gather(ep.recv(msg), ep.close())\n\n async def client_node(port):\n ep = await ucp.create_endpoint(\n ucp.get_address(), port, endpoint_error_handling=endpoint_error_handling\n )\n msg = np.empty(10 ** 6)\n with pytest.raises(ucp.exceptions.UCXCanceled):\n await ep.recv(msg)\n\n listener = ucp.create_listener(\n server_node, endpoint_error_handling=endpoint_error_handling\n )\n await client_node(listener.port)","def testConnectionMade(self):\n d = self._getClientConnection()\n d.addCallback(lambda _: self.client.disconnect())\n return d","def test_clear_dispatched_events(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper()\n msg = msg_helper.make_ack()\n self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg)\n self.assertNotEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\n worker_helper.clear_dispatched_events('fooconn')\n self.assertEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])","def user_is_disconnected_from_all_devices():\n assert web_app.disconnect_from_device()","def test_already_connected(connection, events, writer, schedule, flush):\n schedule(connection.connect(), connection.connect())\n flush()\n assert not writer.closed\n assert events.triggered(\"CLIENT_CONNECT\")","async def test_client_shutdown(endpoint_error_handling):\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\n pytest.skip(\"Endpoint error handling is only supported for UCX >= 1.10\")\n\n async def client_node(port):\n ep = await ucp.create_endpoint(\n ucp.get_address(), port, endpoint_error_handling=endpoint_error_handling\n )\n msg = np.empty(10 ** 6)\n with pytest.raises(ucp.exceptions.UCXCanceled):\n await asyncio.gather(ep.recv(msg), ep.close())\n\n async def server_node(ep):\n msg = np.empty(10 ** 6)\n with pytest.raises(ucp.exceptions.UCXCanceled):\n await ep.recv(msg)\n\n listener = ucp.create_listener(\n server_node, endpoint_error_handling=endpoint_error_handling\n )\n await client_node(listener.port)","def test_connectionLostProtocolDeletion(self):\r\n self.pm.startService()\r\n self.pm.addProcess(\"foo\", [\"foo\"])\r\n self.assertIn(\"foo\", self.pm.protocols)\r\n self.pm.protocols[\"foo\"].transport.signalProcess(\"KILL\")\r\n self.reactor.advance(\r\n self.pm.protocols[\"foo\"].transport._terminationDelay)\r\n self.assertNotIn(\"foo\", self.pm.protocols)","def test_connection():\r\n try:\r\n connect()\r\n except:\r\n pass\r\n print ('Unable to connect.')\r\n else:\r\n main()","def test_keyboard_interrupt(self) -> None:\n try:\n self.test()\n except BaseException as error:\n self.logger.exception(error)\n traceback.print_exc()\n LocalSocket.send(\"Test failed\")\n raise\n else:\n LocalSocket.send(\"Test succeed\")\n finally:\n asyncio.run(asyncio.sleep(10))","async def test_handle_message_connected_empty(\n subject: helpers.ModuleListener, mock_callback: AsyncMock\n) -> None:\n message = models.Message(status=\"connected\", connections=[])\n await subject.handle_message(message=message)\n mock_callback.assert_called_once_with([], [])","def test_reactor_thread_disallowed(self):\n self.patch(threadable, \"isInIOThread\", lambda: True)\n d = Deferred()\n dr = EventualResult(d, None)\n self.assertRaises(RuntimeError, dr.wait, 0)","def test_shutdown_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as exc:\n server.shutdown()\n if platform == \"win32\":\n assert exc.value.args[0] == ESHUTDOWN\n else:\n assert exc.value.args[0] == EPIPE","def test_teardown(self):\n with pytest.raises(NotImplementedError):\n self.handler.teardown()","async def test_endpoint_edit_share_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await edit_share_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test_invalid_output(self):\n b1 = Block()\n self.configure_block(b1, {})\n b1.notify_signals([Signal()], \"invalid_output\")\n self.assert_num_signals_notified(1, b1, \"invalid_output\")","async def test_connect_error_with_no_server(event_loop):\n client = SMTP(hostname=\"127.0.0.1\", port=65534, loop=event_loop)\n\n with pytest.raises(SMTPConnectError):\n await client.connect(timeout=0.1)","def test_wait_for_dispatched_events_no_amount(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper()\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\n self.assertEqual(self.successResultOf(d), [])\n\n msg = msg_helper.make_ack()\n self._add_to_dispatched(worker_helper.broker, 'fooconn.event', msg)\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\n self.assertNoResult(d)\n yield worker_helper.broker.wait_delivery()\n self.assertEqual(self.successResultOf(d), [msg])","async def test_disconnected_server_raises_on_data_read(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESSAGE\\r\\n.\\r\\n\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def test_no_alerts(fd, formatter, event):\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\n ao.start()\n event.run_until_wait() # no print\n event.stop()\n assert fd.getvalue() == ''","def test_clientConnectionFailedStopsReactor(self):\n reactor = self.buildReactor()\n needsRunningReactor(reactor, lambda: self.connect(reactor, Stop(reactor)))\n self.runReactor(reactor)","def testReconnectionOnConnectionLost(self):\n d = self.testConnectionLost()\n d.addCallback(lambda _: self.factory.resume())\n d.addCallback(lambda _: self.client.connection.deferred)\n self._addRequest(d)\n return d","def test_shutdown(self):\n hook = SignalHook(self.test_extension, self.signal,\n self._on_signal_fired)\n hook.disable_hook()\n\n self.assertEqual(len(self._on_signal_fired.calls), 0)\n self.signal.send(self)\n self.assertEqual(len(self._on_signal_fired.calls), 0)","def slot_not_connected(self, addr):\n if self.next_connection(addr):\n self.connection_responded()\n else:\n print(addr, \": Reconnecting...\")","def test_connect_error():\n queue = RedisQueue('localhost')\n assert not queue.is_connected\n with pytest.raises(ConnectionError):\n queue.put('test')\n with pytest.raises(ConnectionError):\n queue.get()","def test_that_error_callback_is_not_invoked_on_no_error(self, request):\n error = False\n\n def on_error(_):\n nonlocal error\n error = True\n\n response = requests.Response()\n response.status_code = 200\n request.return_value = response\n r = rx_request('get', 'url')\n\n r.subscribe(on_error=on_error)\n\n self.assertFalse(error)","def test_pause_not_listening(testchannel):\n with testchannel.open():\n with pytest.raises(NotListeningError):\n testchannel.pause()","def test_disconnect_loop_auth_issue(self, disconnected_mock):\n self.create_org(status=CONNECTED)\n\n # no status change on the first task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\n disconnected_mock.assert_not_called()\n\n # org is disconnected on the 4th task call\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\n disconnected_mock.assert_called_once()","def test_bogus_message(self, caplog):\n class EmptyWebsocket:\n \"\"\"Lets us warn about websocket close-failure\"\"\"\n\n def __init__(self):\n self.close_reason = 'TEST'\n self.close_code = 666\n srvapp = VmaasServerApplication()\n srvapp.vmaas_websocket = EmptyWebsocket()\n\n with caplog.at_level(logging.INFO):\n srvapp._read_websocket_message(None) # pylint: disable=protected-access\n assert caplog.records[0].levelname == 'WARNING'\n assert caplog.record_tuples[0][2] == 'Connection to ws://vmaas_websocket:8082/ closed: TEST (666)'\n caplog.clear()\n\n with caplog.at_level(logging.INFO):\n srvapp._read_websocket_message('whatthehell?!?') # pylint: disable=protected-access\n assert not caplog.records\n caplog.clear()","def test_can_not_handle_brew_container_task_closed_event(self):\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_closed'))\n self.assertFalse(self.handler.can_handle(event))","def test_disconnectWhileProducing(self):\n reactor = self.buildReactor()\n\n # For some reason, pyobject/pygtk will not deliver the close\n # notification that should happen after the unregisterProducer call in\n # this test. The selectable is in the write notification set, but no\n # notification ever arrives. Probably for the same reason #5233 led\n # win32eventreactor to be broken.\n skippedReactors = [\"Glib2Reactor\", \"Gtk2Reactor\"]\n reactorClassName = reactor.__class__.__name__\n if reactorClassName in skippedReactors and platform.isWindows():\n raise SkipTest(\n \"A pygobject/pygtk bug disables this functionality \" \"on Windows.\"\n )\n\n class Producer:\n def resumeProducing(self):\n log.msg(\"Producer.resumeProducing\")\n\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\n\n finished = Deferred()\n finished.addErrback(log.err)\n finished.addCallback(lambda ign: reactor.stop())\n\n class ClientProtocol(Protocol):\n \"\"\"\n Protocol to connect, register a producer, try to lose the\n connection, unregister the producer, and wait for the connection to\n actually be lost.\n \"\"\"\n\n def connectionMade(self):\n log.msg(\"ClientProtocol.connectionMade\")\n self.transport.registerProducer(Producer(), False)\n self.transport.loseConnection()\n # Let the reactor tick over, in case synchronously calling\n # loseConnection and then unregisterProducer is the same as\n # synchronously calling unregisterProducer and then\n # loseConnection (as it is in several reactors).\n reactor.callLater(0, reactor.callLater, 0, self.unregister)\n\n def unregister(self):\n log.msg(\"ClientProtocol unregister\")\n self.transport.unregisterProducer()\n # This should all be pretty quick. Fail the test\n # if we don't get a connectionLost event really\n # soon.\n reactor.callLater(\n 1.0, finished.errback, Failure(Exception(\"Connection was not lost\"))\n )\n\n def connectionLost(self, reason):\n log.msg(\"ClientProtocol.connectionLost\")\n finished.callback(None)\n\n clientFactory = ClientFactory()\n clientFactory.protocol = ClientProtocol\n self.connect(reactor, clientFactory)\n self.runReactor(reactor)\n # If the test failed, we logged an error already and trial\n # will catch it.","async def test_endpoint_access_details_interface_error(self):\n with self.patch_handle_dropped_connection:\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\n await access_details_handler(self.mock_request)\n self.handle_dropped_connection_mock.assert_called_once()","def test_connectEvent(self):\n reactor = self.buildReactor()\n\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\n connected = []\n\n class CheckConnection(Protocol):\n def connectionMade(self):\n connected.append(self)\n reactor.stop()\n\n clientFactory = Stop(reactor)\n clientFactory.protocol = CheckConnection\n\n needsRunningReactor(reactor, lambda: self.connect(reactor, clientFactory))\n\n reactor.run()\n\n self.assertTrue(connected)","def test_protocolShutDownAfterTimeout(self):\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))),\n result]\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return results.pop(0)\n\n resolver._connectedProtocol = FakeProtocol\n resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[1].transport.disconnected)\n result.callback(dns.Message())\n self.assertTrue(protocols[1].transport.disconnected)","def assertSocketError(self, ws, code, reason):\n msg = yield ws.read_message()\n self.assertIsNone(msg)\n self.assertEqual(ws.close_code, 1001)\n self.assertEqual(ws.close_reason, \"goodbye\")","def test_exceptions_in_server_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n raise SentinelException()\n\n def client_callback(*args): # pragma: nocover\n pytest.fail(\"Should not be called\")\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_connect_not_called():\n config = {\"listeners\": \"localhost:8080\"}\n registry = Registry()\n registry.new(name=\"test\", backend=\"dummy\", **config)\n\n dummy = registry[\"test\"]\n dummy.publish(topic=\"mytopic\", message=\"howl1\")\n dummy.publish(topic=\"mytopic\", message=\"howl2\")\n dummy.publish(topic=\"mytopic\", message=\"howl3\")\n dummy._connect.assert_called_once()","def test_listen_error(self):\n listen_port = self.get_port()\n config = Qdrouterd.Config([\n ('router', {'mode': 'standalone', 'id': 'bad'}),\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\n ('listener', {'port': listen_port, 'http':True})])\n r = Qdrouterd(name=\"expect_fail\", config=config, wait=False);\n self.assertEqual(1, r.wait())","def test_unexpected_EOF(self):\n server_conn, client_conn = loopback()\n client_conn.sock_shutdown(SHUT_RDWR)\n with pytest.raises(SysCallError) as err:\n server_conn.recv(1024)\n if platform == \"win32\":\n assert err.value.args == (10054, \"WSAECONNRESET\")\n else:\n assert err.value.args == (-1, \"Unexpected EOF\")","def testTerminateRace(self):\n yield self.connect(self.get_body_node(connect=True))\n\n def log_observer(event):\n self.failIf(event['isError'], event)\n\n log.addObserver(log_observer)\n\n # Simultaneously cause a stream error (server->client closed) and send a terminate\n # from the client to the server. Both sides are closing the connection at once.\n # Make sure the connection closes cleanly without logging any errors (\"Unhandled\n # Error\"), and the client receives a terminate in response.\n try:\n self.server_protocol.triggerStreamError()\n yield self.proxy.send(self.get_body_node(type='terminate'))\n except httpb_client.HTTPBNetworkTerminated as e:\n self.assertEqual(e.body_tag.getAttribute('condition', None), 'remote-stream-error')\n finally:\n log.removeObserver(log_observer)","def test_is_connected__not_connection(self):\n self.switch.connection = None\n self.switch.is_active = MagicMock()\n self.switch.is_active.return_value = True\n\n self.assertFalse(self.switch.is_connected())","def test_plugin_connected_hook(node_factory):\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\n l1.rpc.reject(l3.info['id'])\n\n l2.connect(l1)\n l1.daemon.wait_for_log(r\"{} is allowed\".format(l2.info['id']))\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\n\n l3.connect(l1)\n l1.daemon.wait_for_log(r\"{} is in reject list\".format(l3.info['id']))\n\n # FIXME: this error occurs *after* connection, so we connect then drop.\n l3.daemon.wait_for_log(r\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\"\n .format(l1.info['id']))\n l3.daemon.wait_for_log(r\"You are in reject list\")\n\n def check_disconnect():\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\n return peers == [] or not peers[0]['connected']\n\n wait_for(check_disconnect)","async def test_availability_when_connection_lost(\n hass: HomeAssistant, mqtt_mock_entry: MqttMockHAClientGenerator\n) -> None:\n await help_test_availability_when_connection_lost(\n hass, mqtt_mock_entry, select.DOMAIN\n )","def on_disconnect(unused_client, unused_userdata, rc):\n\tprint('on_disconnect', error_str(rc))\n\n\t# Since a disconnect occurred, the next loop iteration will wait with\n\t# exponential backoff.\n\tglobal should_backoff\n\tshould_backoff = True"],"string":"[\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_event_handler_can_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_disconnect\\n if ctx.is_pre_ping:\\n ctx.is_disconnect = False\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\\n\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n ctx.is_disconnect = True\\n\\n conn = engine.connect()\\n # no error\\n conn.close()\",\n \"def test_run_without_message(connection, events, loop):\\n loop.run_until_complete(connection.run())\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_already_disconnected(connection, events, schedule, flush):\\n schedule(connection.connect(),\\n connection.disconnect(),\\n connection.disconnect())\\n flush()\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_disconnect_before_connect(connection, events, schedule, flush):\\n schedule(connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert not events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert not events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_invalid_disconnect(self):\\n mediator = Mediator()\\n try:\\n mediator.disconnect(\\\"foo\\\", self.dog.set_sound)\\n mediator.disconnect(\\\"bar\\\", self.cat.set_sound)\\n except:\\n raise AssertionError()\",\n \"def test_disconnect_multiple(self):\\n self.inverter.disconnect()\\n self.inverter.disconnect() # Should not raise exception\",\n \"def test_disconnect(writer, patch_connection, events, connection,\\n schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert writer.closed\\n assert connection.writer is None\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def inner_test(param: enums.DisconnectReason):\\n pass\",\n \"def test_dispatch_event_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n broker = self.setup_broker(worker_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n msg = msg_helper.make_ack()\\n yield worker_helper.dispatch_event(msg)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])\",\n \"def test_parse_message_failure_disconnect(self, mock_disconnect):\\n for test_case in self.failure_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertNotEqual(expected, mock_disconnect)\",\n \"def test_verify_state_of_a_device_when_disconnected_from_the_device():\",\n \"def test_clear_dispatched_events_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg)\\n self.assertNotEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\\n worker_helper.clear_dispatched_events()\\n self.assertEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\",\n \"def test_disconnect_closed(self):\\n self.sock.close()\\n self.inverter.sock.close()\\n self.inverter.sock_file.close()\\n self.inverter.disconnect() # Should not raise exception\",\n \"async def test_timeout_disconnect():\\n communicator = WebsocketCommunicator(ErrorWebsocketApp(), \\\"/testws/\\\")\\n # Test connection\\n connected, subprotocol = await communicator.connect()\\n assert connected\\n assert subprotocol is None\\n # Test sending text (will error internally)\\n await communicator.send_to(text_data=\\\"hello\\\")\\n with pytest.raises(asyncio.TimeoutError):\\n await communicator.receive_from()\\n # Close out\\n await communicator.disconnect()\",\n \"async def test_disconnect(self):\\n await self.webhook_connection.connect()\\n assert self.webhook_connection.is_connected is True\\n\\n await self.webhook_connection.disconnect()\\n assert self.webhook_connection.is_connected is False\",\n \"def test_not_implemented(self):\\n\\n test_handler = EventHandler(self.mock_interruption_event)\\n\\n with self.assertRaises(NotImplementedError):\\n test_handler.handle()\",\n \"def test_send_disconnected(connection, writer, schedule, flush):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n connection.send(\\\"test\\\")\\n assert not writer.used\",\n \"async def test_event_handler_asserts_if_called_off_event_loop(self):\\n event_loop = asyncio.get_running_loop()\\n session = _create_test_session(event_loop)\\n\\n # Pretend we're calling this function from a thread with another event_loop.\\n with patch(\\n \\\"streamlit.runtime.app_session.asyncio.get_running_loop\\\",\\n return_value=MagicMock(),\\n ):\\n with self.assertRaises(AssertionError):\\n session._handle_scriptrunner_event_on_event_loop(\\n sender=MagicMock(), event=ScriptRunnerEvent.SCRIPT_STARTED\\n )\",\n \"async def test_handle_message_disconnected_empty(\\n subject: helpers.ModuleListener, mock_callback: AsyncMock\\n) -> None:\\n message = models.Message(status=\\\"disconnected\\\", connections=[])\\n await subject.handle_message(message=message)\\n mock_callback.assert_called_once_with([], [])\",\n \"def testConnectionLost(self):\\n d = self.testSimpleRequest()\\n d.addCallback(lambda _: self.factory.crash())\\n d.addCallback(lambda _: self.client.check_rate_limit())\\n d.addTimeout(0.01, reactor)\\n self.assertFailure(d, ConnectionClosed)\\n return d\",\n \"def test_wait_for_dispatched_events_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n d = worker_helper.wait_for_dispatched_events(1)\\n self.assertEqual(d.called, False)\\n msg = msg_helper.make_ack()\\n yield self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg, kick=True)\\n dispatched = success_result_of(d)\\n self.assertEqual(dispatched, [msg])\",\n \"def test_disconnect_from_client_side(\\n start_result_q_publisher, start_result_q_subscriber\\n):\\n\\n result_pub = start_result_q_publisher()\\n f = result_pub.publish(b\\\"Hello test_disconnect_from_client_side 1\\\")\\n assert f.result(timeout=1) is None\\n\\n result_pub.stop()\\n\\n try_assert(lambda: not result_pub.is_alive(), \\\"Verify test setup\\\")\\n with pytest.raises(ValueError):\\n result_pub.publish(b\\\"Hello test_disconnect_from_client_side 2\\\")\",\n \"async def test_listener_del(endpoint_error_handling):\\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\\n pytest.skip(\\\"Endpoint error handling is only supported for UCX >= 1.10\\\")\\n\\n async def server_node(ep):\\n await ep.send(np.arange(100, dtype=np.int64))\\n await ep.send(np.arange(100, dtype=np.int64))\\n\\n listener = ucp.create_listener(\\n server_node, endpoint_error_handling=endpoint_error_handling\\n )\\n ep = await ucp.create_endpoint(\\n ucp.get_address(),\\n listener.port,\\n endpoint_error_handling=endpoint_error_handling,\\n )\\n msg = np.empty(100, dtype=np.int64)\\n await ep.recv(msg)\\n assert listener.closed() is False\\n del listener\\n await ep.recv(msg)\",\n \"async def test_endpoint_gave_access_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await gave_access_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test_idleClientDoesDisconnect(self):\\n c = Clock()\\n # Hook up our server protocol\\n transport = StringTransportWithDisconnection()\\n transport.protocol = self.server\\n self.server.callLater = c.callLater\\n self.server.makeConnection(transport)\\n\\n # Make sure we can notice when the connection goes away\\n lost = []\\n connLost = self.server.connectionLost\\n self.server.connectionLost = lambda reason: (lost.append(None), connLost(reason))[1]\\n\\n # 2/3rds of the idle timeout elapses...\\n c.pump([0.0] + [self.server.timeOut / 3.0] * 2)\\n self.assertFalse(lost, lost)\\n\\n # Now some more\\n c.pump([0.0, self.server.timeOut / 2.0])\\n self.assertTrue(lost)\",\n \"def test_invalid_signal(self):\\n mediator = Mediator()\\n\\n try:\\n mediator.signal(\\\"foo\\\")\\n except:\\n raise AssertionError()\",\n \"async def test_listener_close(endpoint_error_handling):\\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\\n pytest.skip(\\\"Endpoint error handling is only supported for UCX >= 1.10\\\")\\n\\n async def client_node(listener):\\n ep = await ucp.create_endpoint(\\n ucp.get_address(),\\n listener.port,\\n endpoint_error_handling=endpoint_error_handling,\\n )\\n msg = np.empty(100, dtype=np.int64)\\n await ep.recv(msg)\\n await ep.recv(msg)\\n assert listener.closed() is False\\n listener.close()\\n assert listener.closed() is True\\n\\n async def server_node(ep):\\n await ep.send(np.arange(100, dtype=np.int64))\\n await ep.send(np.arange(100, dtype=np.int64))\\n\\n listener = ucp.create_listener(\\n server_node, endpoint_error_handling=endpoint_error_handling\\n )\\n await client_node(listener)\",\n \"def test_disconnect(self):\\n self.inverter.disconnect()\\n sleep(0.02)\",\n \"def test_parse_message_failure_connect(self):\\n for test_case in self.failure_test_params_wrong_connect:\\n expected = test_case[KEY_EXPECTED]\\n mock_connect = app.on_connect()\\n\\n self.assertNotEqual(expected, mock_connect)\",\n \"async def test_context_manager_disconnect_handling(preset_server, event_loop):\\n preset_client = SMTP(\\n hostname=preset_server.hostname, port=preset_server.port, loop=event_loop\\n )\\n\\n async with preset_client:\\n assert preset_client.is_connected\\n\\n preset_server.responses.append(b\\\"250 noop\\\")\\n preset_server.drop_connection_event.set()\\n\\n try:\\n await preset_client.noop()\\n except SMTPServerDisconnected:\\n pass\\n\\n assert not preset_client.is_connected\",\n \"def test_protocolShutDown(self):\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return result\\n\\n resolver._connectedProtocol = FakeProtocol\\n resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[0].transport.disconnected)\\n result.callback(dns.Message())\\n self.assertTrue(protocols[0].transport.disconnected)\",\n \"async def test_handle_message_disconnected_one(\\n subject: helpers.ModuleListener,\\n mock_callback: AsyncMock,\\n connections: List[models.ModuleConnection],\\n modules_at_port: List[ModuleAtPort],\\n) -> None:\\n message = models.Message(status=\\\"disconnected\\\", connections=connections[:1])\\n await subject.handle_message(message=message)\\n mock_callback.assert_called_once_with([], modules_at_port[:1])\",\n \"def test_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as err:\\n server.sendall(b\\\"hello, world\\\")\\n if platform == \\\"win32\\\":\\n assert err.value.args[0] == ESHUTDOWN\\n else:\\n assert err.value.args[0] == EPIPE\",\n \"def test_control(self, ping_fixture):\\n engine = ping_fixture\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_unsubscribe_any_listener(self):\\n with self.assertRaises(AssertionError):\\n EVENT_MANAGER.unsubscribe()\",\n \"def test_parse_message_success_disconnect(self):\\n for test_case in self.success_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertEqual(expected, mock_disconnect)\",\n \"async def test_endpoint_has_access_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await has_access_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"async def test_http2_wrong_event(mocker):\\n mocker.patch(\\\"aiosonic.http2.Http2Handler.__init__\\\", lambda x: None)\\n mocker.patch(\\\"aiosonic.http2.Http2Handler.h2conn\\\")\\n\\n handler = Http2Handler()\\n\\n async def coro():\\n pass\\n\\n with pytest.raises(MissingEvent):\\n await handler.handle_events([WrongEvent])\",\n \"def test_protocolShutDownAfterFailure(self):\\n class ExpectedException(Exception):\\n pass\\n\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return result\\n\\n resolver._connectedProtocol = FakeProtocol\\n queryResult = resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[0].transport.disconnected)\\n result.errback(failure.Failure(ExpectedException()))\\n self.assertTrue(protocols[0].transport.disconnected)\\n\\n return self.assertFailure(queryResult, ExpectedException)\",\n \"def test_read_disconnected(connection, reader, schedule, flush, loop):\\n schedule(connection.connect(), connection.disconnect())\\n flush()\\n value = loop.run_until_complete(connection.read())\\n assert not value\\n assert not reader.used\",\n \"def test_handle_calls(tchannel_pair):\\n class _MyException(Exception):\\n pass\\n\\n def my_handler(context, connection):\\n raise _MyException()\\n\\n server, client = tchannel_pair\\n client.ping()\\n with pytest.raises(_MyException):\\n server.handle_calls(my_handler)\",\n \"async def test_disconnect_on_reject_outgoing(self, client, dropper, leak_tracker):\\n leak_tracker.set_initial_object_list()\\n\\n await client.connect()\\n assert client.connected\\n dropper.reject_outgoing()\\n\\n while client.connected:\\n await asyncio.sleep(1)\\n\\n # we've passed the test. Now wait to reconnect before we check for leaks. Otherwise we\\n # have a pending ConnectOperation floating around and this would get tagged as a leak.\\n dropper.restore_all()\\n while not client.connected:\\n await asyncio.sleep(1)\\n\\n leak_tracker.check_for_leaks()\",\n \"def test_get_dispatched_events_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n dispatched = worker_helper.get_dispatched_events()\\n self.assertEqual(dispatched, [])\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg)\\n dispatched = worker_helper.get_dispatched_events()\\n self.assertEqual(dispatched, [msg])\",\n \"def connectionLost(reason):\",\n \"def test_writeAfterDisconnect(self):\\n reactor = self.buildReactor()\\n\\n finished = []\\n\\n serverConnectionLostDeferred = Deferred()\\n protocol = lambda: ClosingLaterProtocol(serverConnectionLostDeferred)\\n portDeferred = self.endpoints.server(reactor).listen(\\n ServerFactory.forProtocol(protocol)\\n )\\n\\n def listening(port):\\n msg(\\\"Listening on {!r}\\\".format(port.getHost()))\\n endpoint = self.endpoints.client(reactor, port.getHost())\\n\\n lostConnectionDeferred = Deferred()\\n protocol = lambda: ClosingLaterProtocol(lostConnectionDeferred)\\n client = endpoint.connect(ClientFactory.forProtocol(protocol))\\n\\n def write(proto):\\n msg(\\\"About to write to {!r}\\\".format(proto))\\n proto.transport.write(b\\\"x\\\")\\n\\n client.addCallbacks(write, lostConnectionDeferred.errback)\\n\\n def disconnected(proto):\\n msg(\\\"{!r} disconnected\\\".format(proto))\\n proto.transport.write(b\\\"some bytes to get lost\\\")\\n proto.transport.writeSequence([b\\\"some\\\", b\\\"more\\\"])\\n finished.append(True)\\n\\n lostConnectionDeferred.addCallback(disconnected)\\n serverConnectionLostDeferred.addCallback(disconnected)\\n return gatherResults([lostConnectionDeferred, serverConnectionLostDeferred])\\n\\n def onListen():\\n portDeferred.addCallback(listening)\\n portDeferred.addErrback(err)\\n portDeferred.addCallback(lambda ignored: reactor.stop())\\n\\n needsRunningReactor(reactor, onListen)\\n\\n self.runReactor(reactor)\\n self.assertEqual(finished, [True, True])\",\n \"def test_keep_alive_cancelled(self):\\n sleep(0.005) # Wait before a keep-alive message will be sent\\n self.inverter.send(b\\\"\\\\x01\\\\x02\\\\x03\\\", b\\\"\\\") # Send something arbitrary\\n self.sock.recv(4096) # Retrieve the sent message\\n sleep(0.008) # Wait until just before the next keep-alive is supposed to happen\\n # Check that no message was sent\\n self.sock.setblocking(False)\\n with self.assertRaises(BlockingIOError):\\n self.sock.recv(4096)\",\n \"def test_disconnect_loop_invalid_grant(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"def test_asyncio_component_404(event_loop):\\n orig_loop = txaio.config.loop\\n txaio.config.loop = event_loop\\n\\n class FakeTransport(object):\\n def close(self):\\n pass\\n\\n def write(self, data):\\n pass\\n\\n fake_transport = FakeTransport()\\n actual_protocol = [None] # set in a closure below\\n\\n def create_connection(protocol_factory=None, server_hostname=None, host=None, port=None, ssl=False):\\n if actual_protocol[0] is None:\\n protocol = protocol_factory()\\n actual_protocol[0] = protocol\\n protocol.connection_made(fake_transport)\\n return txaio.create_future_success((fake_transport, protocol))\\n else:\\n return txaio.create_future_error(RuntimeError(\\\"second connection fails completely\\\"))\\n\\n with mock.patch.object(event_loop, 'create_connection', create_connection):\\n event_loop.create_connection = create_connection\\n\\n comp = Component(\\n transports=[\\n {\\n \\\"url\\\": \\\"ws://localhost:12/bogus\\\",\\n \\\"max_retries\\\": 1,\\n \\\"max_retry_delay\\\": 0.1,\\n }\\n ]\\n )\\n\\n # if having trouble, try starting some logging (and use\\n # \\\"py.test -s\\\" to get real-time output)\\n # txaio.start_logging(level=\\\"debug\\\")\\n f = comp.start(loop=event_loop)\\n txaio.config.loop = event_loop\\n\\n # now that we've started connecting, we *should* be able\\n # to connetion_lost our transport .. but we do a\\n # call-later to ensure we're after the setup stuff in the\\n # event-loop (because asyncio doesn't synchronously\\n # process already-completed Futures like Twisted does)\\n\\n def nuke_transport():\\n actual_protocol[0].connection_lost(None) # asyncio can call this with None\\n txaio.call_later(0.1, nuke_transport)\\n\\n finished = txaio.create_future()\\n\\n def fail():\\n finished.set_exception(AssertionError(\\\"timed out\\\"))\\n txaio.config.loop = orig_loop\\n txaio.call_later(1.0, fail)\\n\\n def done(f):\\n try:\\n f.result()\\n finished.set_exception(AssertionError(\\\"should get an error\\\"))\\n except RuntimeError as e:\\n if 'Exhausted all transport connect attempts' not in str(e):\\n finished.set_exception(AssertionError(\\\"wrong exception caught\\\"))\\n finished.set_result(None)\\n txaio.config.loop = orig_loop\\n f.add_done_callback(done)\\n return finished\",\n \"def test_shutdown(self):\\n server, client = loopback()\\n assert not server.shutdown()\\n assert server.get_shutdown() == SENT_SHUTDOWN\\n with pytest.raises(ZeroReturnError):\\n client.recv(1024)\\n assert client.get_shutdown() == RECEIVED_SHUTDOWN\\n client.shutdown()\\n assert client.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\\n with pytest.raises(ZeroReturnError):\\n server.recv(1024)\\n assert server.get_shutdown() == (SENT_SHUTDOWN | RECEIVED_SHUTDOWN)\",\n \"async def test_disconnected_server_raises_on_data_write(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESS\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def on_disconnect(unused_client, unused_userdata, rc):\\n print(f\\\"on_disconnect: {error_str(rc)}\\\")\\n print()\\n\\n global connected\\n connected = False\",\n \"def test_disconnect(self):\\n\\n\\t\\twith EchoServer(bind_addr = ('', 12122)):\\n\\t\\t\\tyield reactor.schedule()\\n\\t\\t\\tclient = tcp.TCPConnection(remote_addr = ('localhost', 12122))\\n\\t\\t\\tyield client.connect()\\n\\n\\t\\t\\tclient.close()\",\n \"async def test_endpoint_shared_details_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await shared_details_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test__API_without_answer(self):\\n self.mock_connection.state = MockConnection.NO_CONFIRMATIONS\\n\\n # timeout supposed to be here\\n self.assertEqual(self.mutex.lock(), False) # acquire mutex\",\n \"async def test_endpoint_delete_share_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await delete_share_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"async def test_server_shutdown(endpoint_error_handling):\\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\\n pytest.skip(\\\"Endpoint error handling is only supported for UCX >= 1.10\\\")\\n\\n async def server_node(ep):\\n msg = np.empty(10 ** 6)\\n with pytest.raises(ucp.exceptions.UCXCanceled):\\n await asyncio.gather(ep.recv(msg), ep.close())\\n\\n async def client_node(port):\\n ep = await ucp.create_endpoint(\\n ucp.get_address(), port, endpoint_error_handling=endpoint_error_handling\\n )\\n msg = np.empty(10 ** 6)\\n with pytest.raises(ucp.exceptions.UCXCanceled):\\n await ep.recv(msg)\\n\\n listener = ucp.create_listener(\\n server_node, endpoint_error_handling=endpoint_error_handling\\n )\\n await client_node(listener.port)\",\n \"def testConnectionMade(self):\\n d = self._getClientConnection()\\n d.addCallback(lambda _: self.client.disconnect())\\n return d\",\n \"def test_clear_dispatched_events(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper()\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg)\\n self.assertNotEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\\n worker_helper.clear_dispatched_events('fooconn')\\n self.assertEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\",\n \"def user_is_disconnected_from_all_devices():\\n assert web_app.disconnect_from_device()\",\n \"def test_already_connected(connection, events, writer, schedule, flush):\\n schedule(connection.connect(), connection.connect())\\n flush()\\n assert not writer.closed\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\",\n \"async def test_client_shutdown(endpoint_error_handling):\\n if ucp.get_ucx_version() < (1, 10, 0) and endpoint_error_handling is True:\\n pytest.skip(\\\"Endpoint error handling is only supported for UCX >= 1.10\\\")\\n\\n async def client_node(port):\\n ep = await ucp.create_endpoint(\\n ucp.get_address(), port, endpoint_error_handling=endpoint_error_handling\\n )\\n msg = np.empty(10 ** 6)\\n with pytest.raises(ucp.exceptions.UCXCanceled):\\n await asyncio.gather(ep.recv(msg), ep.close())\\n\\n async def server_node(ep):\\n msg = np.empty(10 ** 6)\\n with pytest.raises(ucp.exceptions.UCXCanceled):\\n await ep.recv(msg)\\n\\n listener = ucp.create_listener(\\n server_node, endpoint_error_handling=endpoint_error_handling\\n )\\n await client_node(listener.port)\",\n \"def test_connectionLostProtocolDeletion(self):\\r\\n self.pm.startService()\\r\\n self.pm.addProcess(\\\"foo\\\", [\\\"foo\\\"])\\r\\n self.assertIn(\\\"foo\\\", self.pm.protocols)\\r\\n self.pm.protocols[\\\"foo\\\"].transport.signalProcess(\\\"KILL\\\")\\r\\n self.reactor.advance(\\r\\n self.pm.protocols[\\\"foo\\\"].transport._terminationDelay)\\r\\n self.assertNotIn(\\\"foo\\\", self.pm.protocols)\",\n \"def test_connection():\\r\\n try:\\r\\n connect()\\r\\n except:\\r\\n pass\\r\\n print ('Unable to connect.')\\r\\n else:\\r\\n main()\",\n \"def test_keyboard_interrupt(self) -> None:\\n try:\\n self.test()\\n except BaseException as error:\\n self.logger.exception(error)\\n traceback.print_exc()\\n LocalSocket.send(\\\"Test failed\\\")\\n raise\\n else:\\n LocalSocket.send(\\\"Test succeed\\\")\\n finally:\\n asyncio.run(asyncio.sleep(10))\",\n \"async def test_handle_message_connected_empty(\\n subject: helpers.ModuleListener, mock_callback: AsyncMock\\n) -> None:\\n message = models.Message(status=\\\"connected\\\", connections=[])\\n await subject.handle_message(message=message)\\n mock_callback.assert_called_once_with([], [])\",\n \"def test_reactor_thread_disallowed(self):\\n self.patch(threadable, \\\"isInIOThread\\\", lambda: True)\\n d = Deferred()\\n dr = EventualResult(d, None)\\n self.assertRaises(RuntimeError, dr.wait, 0)\",\n \"def test_shutdown_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as exc:\\n server.shutdown()\\n if platform == \\\"win32\\\":\\n assert exc.value.args[0] == ESHUTDOWN\\n else:\\n assert exc.value.args[0] == EPIPE\",\n \"def test_teardown(self):\\n with pytest.raises(NotImplementedError):\\n self.handler.teardown()\",\n \"async def test_endpoint_edit_share_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await edit_share_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test_invalid_output(self):\\n b1 = Block()\\n self.configure_block(b1, {})\\n b1.notify_signals([Signal()], \\\"invalid_output\\\")\\n self.assert_num_signals_notified(1, b1, \\\"invalid_output\\\")\",\n \"async def test_connect_error_with_no_server(event_loop):\\n client = SMTP(hostname=\\\"127.0.0.1\\\", port=65534, loop=event_loop)\\n\\n with pytest.raises(SMTPConnectError):\\n await client.connect(timeout=0.1)\",\n \"def test_wait_for_dispatched_events_no_amount(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper()\\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\\n self.assertEqual(self.successResultOf(d), [])\\n\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(worker_helper.broker, 'fooconn.event', msg)\\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\\n self.assertNoResult(d)\\n yield worker_helper.broker.wait_delivery()\\n self.assertEqual(self.successResultOf(d), [msg])\",\n \"async def test_disconnected_server_raises_on_data_read(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESSAGE\\\\r\\\\n.\\\\r\\\\n\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def test_no_alerts(fd, formatter, event):\\n ao = AlertObserver(3, fd=fd, formatter=formatter, event=event)\\n ao.start()\\n event.run_until_wait() # no print\\n event.stop()\\n assert fd.getvalue() == ''\",\n \"def test_clientConnectionFailedStopsReactor(self):\\n reactor = self.buildReactor()\\n needsRunningReactor(reactor, lambda: self.connect(reactor, Stop(reactor)))\\n self.runReactor(reactor)\",\n \"def testReconnectionOnConnectionLost(self):\\n d = self.testConnectionLost()\\n d.addCallback(lambda _: self.factory.resume())\\n d.addCallback(lambda _: self.client.connection.deferred)\\n self._addRequest(d)\\n return d\",\n \"def test_shutdown(self):\\n hook = SignalHook(self.test_extension, self.signal,\\n self._on_signal_fired)\\n hook.disable_hook()\\n\\n self.assertEqual(len(self._on_signal_fired.calls), 0)\\n self.signal.send(self)\\n self.assertEqual(len(self._on_signal_fired.calls), 0)\",\n \"def slot_not_connected(self, addr):\\n if self.next_connection(addr):\\n self.connection_responded()\\n else:\\n print(addr, \\\": Reconnecting...\\\")\",\n \"def test_connect_error():\\n queue = RedisQueue('localhost')\\n assert not queue.is_connected\\n with pytest.raises(ConnectionError):\\n queue.put('test')\\n with pytest.raises(ConnectionError):\\n queue.get()\",\n \"def test_that_error_callback_is_not_invoked_on_no_error(self, request):\\n error = False\\n\\n def on_error(_):\\n nonlocal error\\n error = True\\n\\n response = requests.Response()\\n response.status_code = 200\\n request.return_value = response\\n r = rx_request('get', 'url')\\n\\n r.subscribe(on_error=on_error)\\n\\n self.assertFalse(error)\",\n \"def test_pause_not_listening(testchannel):\\n with testchannel.open():\\n with pytest.raises(NotListeningError):\\n testchannel.pause()\",\n \"def test_disconnect_loop_auth_issue(self, disconnected_mock):\\n self.create_org(status=CONNECTED)\\n\\n # no status change on the first task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 1})\\n disconnected_mock.assert_not_called()\\n\\n # org is disconnected on the 4th task call\\n self.app.post('/adapter/qbo/test/update', headers={'X-AppEngine-TaskExecutionCount': 4})\\n disconnected_mock.assert_called_once()\",\n \"def test_bogus_message(self, caplog):\\n class EmptyWebsocket:\\n \\\"\\\"\\\"Lets us warn about websocket close-failure\\\"\\\"\\\"\\n\\n def __init__(self):\\n self.close_reason = 'TEST'\\n self.close_code = 666\\n srvapp = VmaasServerApplication()\\n srvapp.vmaas_websocket = EmptyWebsocket()\\n\\n with caplog.at_level(logging.INFO):\\n srvapp._read_websocket_message(None) # pylint: disable=protected-access\\n assert caplog.records[0].levelname == 'WARNING'\\n assert caplog.record_tuples[0][2] == 'Connection to ws://vmaas_websocket:8082/ closed: TEST (666)'\\n caplog.clear()\\n\\n with caplog.at_level(logging.INFO):\\n srvapp._read_websocket_message('whatthehell?!?') # pylint: disable=protected-access\\n assert not caplog.records\\n caplog.clear()\",\n \"def test_can_not_handle_brew_container_task_closed_event(self):\\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_closed'))\\n self.assertFalse(self.handler.can_handle(event))\",\n \"def test_disconnectWhileProducing(self):\\n reactor = self.buildReactor()\\n\\n # For some reason, pyobject/pygtk will not deliver the close\\n # notification that should happen after the unregisterProducer call in\\n # this test. The selectable is in the write notification set, but no\\n # notification ever arrives. Probably for the same reason #5233 led\\n # win32eventreactor to be broken.\\n skippedReactors = [\\\"Glib2Reactor\\\", \\\"Gtk2Reactor\\\"]\\n reactorClassName = reactor.__class__.__name__\\n if reactorClassName in skippedReactors and platform.isWindows():\\n raise SkipTest(\\n \\\"A pygobject/pygtk bug disables this functionality \\\" \\\"on Windows.\\\"\\n )\\n\\n class Producer:\\n def resumeProducing(self):\\n log.msg(\\\"Producer.resumeProducing\\\")\\n\\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\\n\\n finished = Deferred()\\n finished.addErrback(log.err)\\n finished.addCallback(lambda ign: reactor.stop())\\n\\n class ClientProtocol(Protocol):\\n \\\"\\\"\\\"\\n Protocol to connect, register a producer, try to lose the\\n connection, unregister the producer, and wait for the connection to\\n actually be lost.\\n \\\"\\\"\\\"\\n\\n def connectionMade(self):\\n log.msg(\\\"ClientProtocol.connectionMade\\\")\\n self.transport.registerProducer(Producer(), False)\\n self.transport.loseConnection()\\n # Let the reactor tick over, in case synchronously calling\\n # loseConnection and then unregisterProducer is the same as\\n # synchronously calling unregisterProducer and then\\n # loseConnection (as it is in several reactors).\\n reactor.callLater(0, reactor.callLater, 0, self.unregister)\\n\\n def unregister(self):\\n log.msg(\\\"ClientProtocol unregister\\\")\\n self.transport.unregisterProducer()\\n # This should all be pretty quick. Fail the test\\n # if we don't get a connectionLost event really\\n # soon.\\n reactor.callLater(\\n 1.0, finished.errback, Failure(Exception(\\\"Connection was not lost\\\"))\\n )\\n\\n def connectionLost(self, reason):\\n log.msg(\\\"ClientProtocol.connectionLost\\\")\\n finished.callback(None)\\n\\n clientFactory = ClientFactory()\\n clientFactory.protocol = ClientProtocol\\n self.connect(reactor, clientFactory)\\n self.runReactor(reactor)\\n # If the test failed, we logged an error already and trial\\n # will catch it.\",\n \"async def test_endpoint_access_details_interface_error(self):\\n with self.patch_handle_dropped_connection:\\n with self.assertRaises(aiohttp.web.HTTPServiceUnavailable):\\n await access_details_handler(self.mock_request)\\n self.handle_dropped_connection_mock.assert_called_once()\",\n \"def test_connectEvent(self):\\n reactor = self.buildReactor()\\n\\n self.listen(reactor, ServerFactory.forProtocol(Protocol))\\n connected = []\\n\\n class CheckConnection(Protocol):\\n def connectionMade(self):\\n connected.append(self)\\n reactor.stop()\\n\\n clientFactory = Stop(reactor)\\n clientFactory.protocol = CheckConnection\\n\\n needsRunningReactor(reactor, lambda: self.connect(reactor, clientFactory))\\n\\n reactor.run()\\n\\n self.assertTrue(connected)\",\n \"def test_protocolShutDownAfterTimeout(self):\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n results = [defer.fail(failure.Failure(DNSQueryTimeoutError(None))),\\n result]\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return results.pop(0)\\n\\n resolver._connectedProtocol = FakeProtocol\\n resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[1].transport.disconnected)\\n result.callback(dns.Message())\\n self.assertTrue(protocols[1].transport.disconnected)\",\n \"def assertSocketError(self, ws, code, reason):\\n msg = yield ws.read_message()\\n self.assertIsNone(msg)\\n self.assertEqual(ws.close_code, 1001)\\n self.assertEqual(ws.close_reason, \\\"goodbye\\\")\",\n \"def test_exceptions_in_server_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n raise SentinelException()\\n\\n def client_callback(*args): # pragma: nocover\\n pytest.fail(\\\"Should not be called\\\")\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_connect_not_called():\\n config = {\\\"listeners\\\": \\\"localhost:8080\\\"}\\n registry = Registry()\\n registry.new(name=\\\"test\\\", backend=\\\"dummy\\\", **config)\\n\\n dummy = registry[\\\"test\\\"]\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl1\\\")\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl2\\\")\\n dummy.publish(topic=\\\"mytopic\\\", message=\\\"howl3\\\")\\n dummy._connect.assert_called_once()\",\n \"def test_listen_error(self):\\n listen_port = self.get_port()\\n config = Qdrouterd.Config([\\n ('router', {'mode': 'standalone', 'id': 'bad'}),\\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\\n ('listener', {'port': listen_port, 'http':True})])\\n r = Qdrouterd(name=\\\"expect_fail\\\", config=config, wait=False);\\n self.assertEqual(1, r.wait())\",\n \"def test_unexpected_EOF(self):\\n server_conn, client_conn = loopback()\\n client_conn.sock_shutdown(SHUT_RDWR)\\n with pytest.raises(SysCallError) as err:\\n server_conn.recv(1024)\\n if platform == \\\"win32\\\":\\n assert err.value.args == (10054, \\\"WSAECONNRESET\\\")\\n else:\\n assert err.value.args == (-1, \\\"Unexpected EOF\\\")\",\n \"def testTerminateRace(self):\\n yield self.connect(self.get_body_node(connect=True))\\n\\n def log_observer(event):\\n self.failIf(event['isError'], event)\\n\\n log.addObserver(log_observer)\\n\\n # Simultaneously cause a stream error (server->client closed) and send a terminate\\n # from the client to the server. Both sides are closing the connection at once.\\n # Make sure the connection closes cleanly without logging any errors (\\\"Unhandled\\n # Error\\\"), and the client receives a terminate in response.\\n try:\\n self.server_protocol.triggerStreamError()\\n yield self.proxy.send(self.get_body_node(type='terminate'))\\n except httpb_client.HTTPBNetworkTerminated as e:\\n self.assertEqual(e.body_tag.getAttribute('condition', None), 'remote-stream-error')\\n finally:\\n log.removeObserver(log_observer)\",\n \"def test_is_connected__not_connection(self):\\n self.switch.connection = None\\n self.switch.is_active = MagicMock()\\n self.switch.is_active.return_value = True\\n\\n self.assertFalse(self.switch.is_connected())\",\n \"def test_plugin_connected_hook(node_factory):\\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\\n l1.rpc.reject(l3.info['id'])\\n\\n l2.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is allowed\\\".format(l2.info['id']))\\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\\n\\n l3.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is in reject list\\\".format(l3.info['id']))\\n\\n # FIXME: this error occurs *after* connection, so we connect then drop.\\n l3.daemon.wait_for_log(r\\\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\\\"\\n .format(l1.info['id']))\\n l3.daemon.wait_for_log(r\\\"You are in reject list\\\")\\n\\n def check_disconnect():\\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\\n return peers == [] or not peers[0]['connected']\\n\\n wait_for(check_disconnect)\",\n \"async def test_availability_when_connection_lost(\\n hass: HomeAssistant, mqtt_mock_entry: MqttMockHAClientGenerator\\n) -> None:\\n await help_test_availability_when_connection_lost(\\n hass, mqtt_mock_entry, select.DOMAIN\\n )\",\n \"def on_disconnect(unused_client, unused_userdata, rc):\\n\\tprint('on_disconnect', error_str(rc))\\n\\n\\t# Since a disconnect occurred, the next loop iteration will wait with\\n\\t# exponential backoff.\\n\\tglobal should_backoff\\n\\tshould_backoff = True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78867626","0.76576835","0.73965603","0.7263293","0.7216937","0.7042568","0.6785579","0.65975875","0.6531375","0.6502572","0.6493144","0.64641625","0.64185786","0.64083093","0.6385069","0.6377654","0.6374116","0.63512623","0.6334448","0.63215125","0.62944496","0.6285397","0.62744385","0.62678254","0.62572354","0.62501526","0.62110126","0.62035954","0.6186632","0.6179398","0.61347824","0.6125326","0.61100185","0.61080784","0.609965","0.60994995","0.60869515","0.6081133","0.60780126","0.6055555","0.6052383","0.6039649","0.6019513","0.6018616","0.60177404","0.6008216","0.60023266","0.5992613","0.59827435","0.5966872","0.59574884","0.5949503","0.59380406","0.59354734","0.5934084","0.5932724","0.59277856","0.591649","0.59023255","0.5895642","0.58920944","0.5888467","0.58883995","0.58792114","0.58729863","0.5872563","0.5872229","0.5862465","0.58606493","0.58557844","0.5851286","0.5848993","0.5844253","0.58423716","0.58362836","0.58350575","0.58317393","0.58291364","0.58284646","0.5822084","0.5816262","0.5814686","0.5801225","0.57924104","0.57877105","0.57810086","0.5778729","0.5775491","0.57709646","0.57665086","0.5761937","0.5748774","0.5735192","0.5733883","0.5731183","0.5725116","0.57244635","0.5723306","0.5721897","0.5719682"],"string":"[\n \"0.78867626\",\n \"0.76576835\",\n \"0.73965603\",\n \"0.7263293\",\n \"0.7216937\",\n \"0.7042568\",\n \"0.6785579\",\n \"0.65975875\",\n \"0.6531375\",\n \"0.6502572\",\n \"0.6493144\",\n \"0.64641625\",\n \"0.64185786\",\n \"0.64083093\",\n \"0.6385069\",\n \"0.6377654\",\n \"0.6374116\",\n \"0.63512623\",\n \"0.6334448\",\n \"0.63215125\",\n \"0.62944496\",\n \"0.6285397\",\n \"0.62744385\",\n \"0.62678254\",\n \"0.62572354\",\n \"0.62501526\",\n \"0.62110126\",\n \"0.62035954\",\n \"0.6186632\",\n \"0.6179398\",\n \"0.61347824\",\n \"0.6125326\",\n \"0.61100185\",\n \"0.61080784\",\n \"0.609965\",\n \"0.60994995\",\n \"0.60869515\",\n \"0.6081133\",\n \"0.60780126\",\n \"0.6055555\",\n \"0.6052383\",\n \"0.6039649\",\n \"0.6019513\",\n \"0.6018616\",\n \"0.60177404\",\n \"0.6008216\",\n \"0.60023266\",\n \"0.5992613\",\n \"0.59827435\",\n \"0.5966872\",\n \"0.59574884\",\n \"0.5949503\",\n \"0.59380406\",\n \"0.59354734\",\n \"0.5934084\",\n \"0.5932724\",\n \"0.59277856\",\n \"0.591649\",\n \"0.59023255\",\n \"0.5895642\",\n \"0.58920944\",\n \"0.5888467\",\n \"0.58883995\",\n \"0.58792114\",\n \"0.58729863\",\n \"0.5872563\",\n \"0.5872229\",\n \"0.5862465\",\n \"0.58606493\",\n \"0.58557844\",\n \"0.5851286\",\n \"0.5848993\",\n \"0.5844253\",\n \"0.58423716\",\n \"0.58362836\",\n \"0.58350575\",\n \"0.58317393\",\n \"0.58291364\",\n \"0.58284646\",\n \"0.5822084\",\n \"0.5816262\",\n \"0.5814686\",\n \"0.5801225\",\n \"0.57924104\",\n \"0.57877105\",\n \"0.57810086\",\n \"0.5778729\",\n \"0.5775491\",\n \"0.57709646\",\n \"0.57665086\",\n \"0.5761937\",\n \"0.5748774\",\n \"0.5735192\",\n \"0.5733883\",\n \"0.5731183\",\n \"0.5725116\",\n \"0.57244635\",\n \"0.5723306\",\n \"0.5721897\",\n \"0.5719682\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7935945"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84669,"cells":{"query":{"kind":"string","value":"test that an event hook can receive a fatal error and convert it to be a disconnect error during preping"},"document":{"kind":"string","value":"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()"},"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 test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def on_init_fail(self, event_time, message):\n pass","def test_exception_raised_no_dlq():\n\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\n\n @proc.handle_for(always)\n def crash(message, ctx):\n raise RuntimeError(\"bad bytes!\")\n\n with proc.test_client() as test_client:\n blank_message = missive.RawMessage(b\"\")\n with pytest.raises(RuntimeError):\n test_client.send(blank_message)","def test_sandbox_errors_false(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=False)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.assertRaises(Exception, self.signal.send, self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def state_failsafe_do(cfg, app, win, events):","def whenException(self, channel, call):","def _cb_ignore_listen_exception(self, exception, server):\n if isinstance(exception, ssl.SSLError):\n # A client which couldn’t verify the server tried to connect, continue but log the event\n if exception.errqueue[-1][0] == ssl.ERR_TLSV1_ALERT_UNKNOWN_CA:\n #print(\"Ignoring ERR_TLSV1_ALERT_UNKNOWN_CA from client %s\" %\n # (’unknown’ if not hasattr(exception, ’peer’) else str(exception.peer)))\n return True\n # ... and more ...\n return False","def fatal(self, *args, **kwargs):","def onConnectError(self, fetcher, error): #$NON-NLS-1$\r","def test_exception_raised_with_a_dlq():\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\n dlq: missive.DLQ = {}\n proc.set_dlq(dlq)\n\n @proc.handle_for(always)\n def crash(message, ctx):\n raise RuntimeError(\"bad bytes!\")\n\n with proc.test_client() as test_client:\n blank_message = missive.RawMessage(b\"\")\n test_client.send(blank_message)\n assert dlq == {blank_message.message_id: (blank_message, \"bad bytes!\")}\n assert blank_message in test_client.acked","def test_send_event_raises():\n send_event('pytest-reportportal', '5.0.5')","def test_exceptions_in_server_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n raise SentinelException()\n\n def client_callback(*args): # pragma: nocover\n pytest.fail(\"Should not be called\")\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_cond_with_uncaught_error(env):\n def explode(env, delay):\n yield env.timeout(delay)\n raise ValueError(f'Onoes, failed after {delay}!')\n\n def process(env):\n yield env.timeout(1) | env.process(explode(env, 2))\n\n env.process(process(env))\n try:\n env.run()\n assert False, 'There should have been an exception.'\n except ValueError:\n pass\n assert env.now == 2","def test_exception(self):\n\n sink = TObserver(immediate_continue=0)\n self.obs.observe(init_observer_info(sink))\n ack1 = self.left.on_next_list([select_completed])\n\n self.right.on_error(self.exception)\n\n self.assertIsInstance(self.measure_state(self.obs), ControlledZipStates.Stopped)\n self.assertEqual(self.exception, sink.exception)","async def test_connection_error(hass: HomeAssistant, conn_error) -> None:\n\n result = await hass.config_entries.flow.async_init(\n DOMAIN, context={\"source\": config_entries.SOURCE_USER}\n )\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input=DEMO_USER_INPUT\n )\n assert result[\"type\"] == data_entry_flow.FlowResultType.FORM\n assert result[\"errors\"] == {\"base\": \"cannot_connect\"}","def test_sandbox_errors_true(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=True)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.signal.send(self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def test_has_receivers(error_report_mock):\n\n app_crash()\n error_report_mock.assert_not_called()\n\n signal('panic').connect(triage)\n app_crash()\n error_report_mock.assert_called_with()","def test_decode_failure(self):\n\n def handle(event):\n def test():\n pass\n\n return 0x0000, test\n\n self.ae = ae = AE()\n ae.add_requested_context(\n ModalityPerformedProcedureStepNotification, ExplicitVRLittleEndian\n )\n ae.add_supported_context(ModalityPerformedProcedureStepNotification)\n\n handlers = [(evt.EVT_N_EVENT_REPORT, handle)]\n scp = ae.start_server((\"localhost\", 11112), evt_handlers=handlers, block=False)\n\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n assoc = ae.associate(\"localhost\", 11112)\n\n class DummyReply:\n def getvalue(self):\n def test():\n pass\n\n return test\n\n class DummyMessage:\n is_valid_response = True\n EventReply = DummyReply()\n Status = 0x0000\n STATUS_OPTIONAL_KEYWORDS = []\n\n class DummyDIMSE:\n msg_queue = queue.Queue()\n gotten = False\n\n def send_msg(*args, **kwargs):\n return\n\n def get_msg(self, *args, **kwargs):\n if not self.gotten:\n self.gotten = True\n return 1, DummyMessage()\n return None, None\n\n assoc._reactor_checkpoint.clear()\n while not assoc._is_paused:\n time.sleep(0.01)\n assoc.dimse = DummyDIMSE()\n assert assoc.is_established\n\n # Event Information\n ds = Dataset()\n ds.PatientName = \"Test^test\"\n status, ds = assoc.send_n_event_report(\n ds,\n 1,\n ModalityPerformedProcedureStepNotification,\n \"1.2.840.10008.5.1.1.40.1\",\n )\n\n assert status.Status == 0x0110\n assert ds is None\n\n assoc.release()\n scp.shutdown()","async def test_on_connect_failed(hass: HomeAssistant, side_effect, error) -> None:\n flow_result = await hass.config_entries.flow.async_init(\n DOMAIN,\n context={\"source\": SOURCE_USER, \"show_advanced_options\": True},\n )\n\n with PATCH_GET_HOST, patch(\n \"homeassistant.components.asuswrt.bridge.AsusWrtLegacy\"\n ) as asus_wrt:\n asus_wrt.return_value.connection.async_connect = AsyncMock(\n side_effect=side_effect\n )\n asus_wrt.return_value.async_get_nvram = AsyncMock(return_value={})\n asus_wrt.return_value.is_connected = False\n\n result = await hass.config_entries.flow.async_configure(\n flow_result[\"flow_id\"], user_input=CONFIG_DATA\n )\n assert result[\"type\"] == data_entry_flow.FlowResultType.FORM\n assert result[\"errors\"] == {\"base\": error}","def procFail(proc):\n\tif 'a' in proc.config._notify.when['pipeline']:\n\t\tlogger.debug('Notifying process fails')\n\t\tEMAIL.send('proc', proc, 'abort')","def test_can_not_handle_brew_container_task_failed_event(self):\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\n self.assertFalse(self.handler.can_handle(event))","async def test_setup_failed_error(hass: HomeAssistant, ufp: MockUFPFixture) -> None:\n\n ufp.api.get_nvr = AsyncMock(side_effect=NvrError)\n\n await hass.config_entries.async_setup(ufp.entry.entry_id)\n await hass.async_block_till_done()\n assert ufp.entry.state == ConfigEntryState.SETUP_RETRY\n assert not ufp.api.update.called","def test_signal_interruption(self):\n process = Popen(\n [STRATIS_CLI, \"pool\", \"create\",\n p_n(), DISKS[0]],\n stdout=PIPE,\n stderr=PIPE,\n close_fds=True,\n env=os.environ)\n time.sleep(0.05)\n process.send_signal(2)\n result = process.communicate()\n stdout_text = \"\"\n stderr_text = \"\"\n if result[0]:\n stdout_text = bytes(result[0]).decode(\"utf-8\")\n if result[1]:\n stderr_text = bytes(result[1]).decode(\"utf-8\")\n\n self.assertTrue(\"Traceback\" not in stdout_text)\n self.assertTrue(\"Traceback\" not in stderr_text)\n self.assertNotEqual(process.returncode, 0)","def test_fail_must_login(self):\n guest_obj = self._check_init()\n msg = 'You need to login first'\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.hotplug(vols=[dict()])\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.install_packages([])\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.push_file('source_url', 'target_path')\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)","def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:","def test_silent_write_errors():\n\n tracker = pawprint.Tracker(db=None, table=None)\n\n try:\n tracker.write(event=\"This will fail silently.\")\n except Exception:\n pytest.fail(\"Failed to fail silently.\")","def onleaveerror(self, event):\n #print(self.config)\n #try:\n # self.mqttclient.publish(self.config['MQTT']['TOPICBASE'] + '/fsm/state', e.src + '->' + e.dst)\n # self.mqttclient.disconnect()\n # self.network.disconnect()\n #except:\n # pass\n print('onleaveerror; event: %s, %s->%s' % (event.event, event.src, event.dst))","def test_error_bubbles_up(self):\n\n def fail(box):\n box.fail(ValueError(\"oh dear\"))\n\n self.assertThat(\n lambda: sync_perform(func_dispatcher, Effect(fail)),\n raises(ValueError(\"oh dear\")),\n )","async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\n config_entry = MockConfigEntry(\n domain=DOMAIN,\n unique_id=MAC,\n data={CONF_HOST: HOST, KEY_MAC: MAC},\n )\n config_entry.add_to_hass(hass)\n\n mock_daikin.factory.side_effect = ClientConnectionError\n await hass.config_entries.async_setup(config_entry.entry_id)\n await hass.async_block_till_done()\n\n assert config_entry.state == ConfigEntryState.SETUP_RETRY","def test_not_running(): # pragma: windows\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)","def test_verify_state_of_a_device_when_disconnected_from_the_device():","def OnError(self, error):\r\n\t\tLogErr(error)\r\n#\t\tself.Shutdown()\r\n\t\tself.onError()","async def test_warn_when_cannot_connect(opp, caplog):\n with patch.dict(os.environ, MOCK_ENVIRON), patch(\n \"openpeerpower.components.oppio.OppIO.is_connected\",\n return_value=None,\n ):\n result = await async_setup_component(opp, \"oppio\", {})\n assert result\n\n assert opp.components.oppio.is_oppio()\n assert \"Not connected with Opp.io / system too busy!\" in caplog.text","def test_rsp_failure(self):\n\n def handle(event):\n return 0x0112, None\n\n self.ae = ae = AE()\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n ae.network_timeout = 5\n ae.add_supported_context(ProceduralEventLogging)\n scp = ae.start_server(\n (\"localhost\", 11112), block=False, evt_handlers=[(evt.EVT_N_ACTION, handle)]\n )\n\n ae.add_requested_context(ProceduralEventLogging)\n assoc = ae.associate(\"localhost\", 11112)\n assert assoc.is_established\n\n ds = Dataset()\n ds.PatientName = \"Test^test\"\n status, ds = assoc.send_n_action(\n ds, 1, ProceduralEventLogging, \"1.2.840.10008.5.1.1.40.1\"\n )\n assert status.Status == 0x0112\n assert ds is None\n assoc.release()\n assert assoc.is_released\n\n scp.shutdown()","def onError(self, connection:MQTTConnection, rc:int) -> bool:\n\t\treturn True","def error(self, *args):\n\n self.log(\"ERROR:\", args)\n if not self.transport.connected:\n Timer(5, connect(self.host, self.port)).register(self)","def connectionLost(reason):","async def on_error(self, event: str, error: Exception, *args, **kwargs):\n print(f\"Ignoring exception in {event}\", file=sys.stderr)\n traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)","def test_failure_result(self):\n dr = EventualResult(fail(RuntimeError()), None)\n self.assertRaises(RuntimeError, dr.wait, 0.1)","async def test_child_crash_propagation():\n looper_cancelled = False\n\n async def looper():\n nonlocal looper_cancelled\n try:\n while True:\n await asyncio.sleep(0)\n except asyncio.CancelledError:\n looper_cancelled = True\n\n error = ValueError('crashed')\n\n async def crasher():\n raise error\n\n with pytest.raises(ValueError) as excinfo:\n async with Nursery() as nursery:\n nursery.start_soon(looper())\n nursery.start_soon(crasher())\n\n assert looper_cancelled\n assert excinfo.value is error","def connectFailed(self, reason):\n\t\tself._tunnelReadyDeferred.errback(reason)","def unknown_event(self, event):\r\n pass","def test_exceptions_in_client_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n return self.sample_ocsp_data\n\n def client_callback(*args):\n raise SentinelException()\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","async def test_startup_errors_should_halt_ready():\n network = Network()\n network.set_config(url=\"http://nowhere.at.all.localdomain:6865/\", connect_timeout=1)\n\n client = network.aio_party(\"SillyParty\")\n\n # place the ready() call BEFORE the run\n f = ensure_future(wait_for(client.ready(), 2))\n\n try:\n await network.aio_run(keep_open=False)\n except Exception:\n pass\n\n try:\n await f\n raise AssertionError(\n \"client.ready() should not have ended because there is nothing to connect to\"\n )\n except asyncio.TimeoutError:\n raise AssertionError(\n \"client.ready() did not abort with an appropriate exception and was killed because \"\n \"it was taking too long\"\n )\n except CancelledError:\n LOG.info(\"Successfully terminated because ready() was cancelled.\")","def test_unexpected_EOF(self):\n server_conn, client_conn = loopback()\n client_conn.sock_shutdown(SHUT_RDWR)\n with pytest.raises(SysCallError) as err:\n server_conn.recv(1024)\n if platform == \"win32\":\n assert err.value.args == (10054, \"WSAECONNRESET\")\n else:\n assert err.value.args == (-1, \"Unexpected EOF\")","def test_exception_with_callback(self):\n test_utils.generate_test_config_file()\n\n exception_callback = mock.Mock()\n\n client = PowerTrackClient(_dummy_callback, exception_callback,\n config_file_path=config_file)\n client.connect()\n client.disconnect()\n self.assertTrue(exception_callback.called)\n actual_exinfo = exception_callback.call_args[0][0]\n actual_ex = actual_exinfo[1]\n self.assertIsInstance(actual_ex, Exception)\n self.assertEqual(actual_ex.message, \"This is a test exception\")","def test_scp_callback_exception(self):\n self.scp = DummyVerificationSCP()\n def on_c_echo(context, info):\n raise ValueError\n self.scp.ae.on_c_echo = on_c_echo\n self.scp.start()\n\n ae = AE()\n ae.add_requested_context(VerificationSOPClass)\n assoc = ae.associate('localhost', 11112)\n assert assoc.is_established\n rsp = assoc.send_c_echo()\n assert rsp.Status == 0x0000\n assoc.release()\n self.scp.stop()","def test_error(self, mock_validate_session):\n mock_validate_session.return_value = False\n with pytest.raises(SystemExit) as ctx:\n celery_command.worker(Namespace(queues=1, concurrency=1))\n assert str(ctx.value) == \"Worker exiting, database connection precheck failed.\"","def testRemoteError(self):\n\n def _testStreamError(res):\n self.assertEqual(True, isinstance(res.value, httpb_client.HTTPBNetworkTerminated))\n\n self.assertEqual(True, res.value.body_tag.hasAttribute('condition'), 'No attribute condition')\n # This is not a stream error because we sent invalid xml\n self.assertEqual(res.value.body_tag['condition'], 'remote-stream-error')\n self.assertEqual(True, len(res.value.elements)>0)\n # The XML should exactly match the error XML sent by triggerStreamError().\n self.assertEqual(True,xpath.XPathQuery(\"/error\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/policy-violation\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/arbitrary-extension\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/text[text() = 'Error text']\").matches(res.value.elements[0]))\n\n\n\n def _failStreamError(res):\n self.fail('A stream error needs to be returned')\n\n def _testSessionCreate(res):\n self.sid = res[0]['sid']\n # this xml is valid, just for testing\n # the point is to wait for a stream error\n d = self.send('<fdsfd/>')\n d.addCallback(_failStreamError)\n d.addErrback(_testStreamError)\n self.server_protocol.triggerStreamError()\n\n return d\n\n BOSH_XML = \"\"\"<body content='text/xml; charset=utf-8'\n hold='1'\n rid='%(rid)i'\n to='localhost'\n route='xmpp:127.0.0.1:%(server_port)i'\n ver='1.6'\n wait='60'\n ack='1'\n xml:lang='en'\n xmlns='http://jabber.org/protocol/httpbind'/>\n \"\"\"% { \"rid\": self.rid, \"server_port\": self.server_port }\n\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\n\n return d","def fatal_error(message, new_raise=None):\n if not hadFatalErrors:\n mess = ['natlinkconfigfunctions failed because of fatal error:',\n '', message, '',\n 'So if Dragon is running, close it and then rerun this program (in elevated mode).']\n mess = '\\n'.join(mess)\n print(mess)\n print(\"\\n\\n*** See also the messageBox, and close it\")\n windowsMessageBox(mess)\n if message not in hadFatalErrors:\n hadFatalErrors.append(message)\n if new_raise:\n raise new_raise","def test_listen_error(self):\n listen_port = self.get_port()\n config = Qdrouterd.Config([\n ('router', {'mode': 'standalone', 'id': 'bad'}),\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\n ('listener', {'port': listen_port, 'http':True})])\n r = Qdrouterd(name=\"expect_fail\", config=config, wait=False);\n self.assertEqual(1, r.wait())","async def test_button_connection_error(\n hass: HomeAssistant,\n mock_lametric: MagicMock,\n) -> None:\n mock_lametric.app_next.side_effect = LaMetricConnectionError\n\n with pytest.raises(\n HomeAssistantError, match=\"Error communicating with the LaMetric device\"\n ):\n await hass.services.async_call(\n BUTTON_DOMAIN,\n SERVICE_PRESS,\n {ATTR_ENTITY_ID: \"button.frenck_s_lametric_next_app\"},\n blocking=True,\n )\n await hass.async_block_till_done()\n\n state = hass.states.get(\"button.frenck_s_lametric_next_app\")\n assert state\n assert state.state == STATE_UNAVAILABLE","def onentererror(self, event):\n print('onentererror; event: %s, %s->%s' % (event.event, event.src, event.dst))","def test_parse_message_failure_connect(self):\n for test_case in self.failure_test_params_wrong_connect:\n expected = test_case[KEY_EXPECTED]\n mock_connect = app.on_connect()\n\n self.assertNotEqual(expected, mock_connect)","def test_exceptions():\r\n # test that trying to connect_ to a non existent app fails\r\n try:\r\n app = application.Application()\r\n app.connect(path=r\"No process with this please\")\r\n assert False\r\n except application.ProcessNotFoundError:\r\n print('ProcessNotFoundError has been raised. OK.')\r\n\r\n # test that trying to connect_ to a non existent app fails\r\n try:\r\n app = application.Application()\r\n app.start(cmd_line = r\"No process with this please\")\r\n assert False\r\n except application.AppStartError:\r\n print('AppStartError has been raised. OK.')","def test_pause_not_listening(testchannel):\n with testchannel.open():\n with pytest.raises(NotListeningError):\n testchannel.pause()","def handle_err(self):\n pass","def test_that_error_callback_is_not_invoked_on_no_error(self, request):\n error = False\n\n def on_error(_):\n nonlocal error\n error = True\n\n response = requests.Response()\n response.status_code = 200\n request.return_value = response\n r = rx_request('get', 'url')\n\n r.subscribe(on_error=on_error)\n\n self.assertFalse(error)","def test_shutdown_wrong_args(self):\n connection = Connection(Context(SSLv23_METHOD), None)\n with pytest.raises(TypeError):\n connection.set_shutdown(None)","def test_handle_flag_error(self):\n pass","def serious_error(self, e):\n pass","def test_nonsilent_write_errors(error_logger):\n\n tracker = pawprint.Tracker(db=\"postgresql:///fail\", logger=error_logger)\n\n with pytest.raises(Exception):\n tracker.write()\n with pytest.raises(Exception):\n tracker.write(event=\"going_to_fail\")\n\n with open(\"pawprint.log\", mode=\"r\") as f:\n logs = f.readlines()\n print(logs[3])\n\n assert len(logs) == 6\n assert logs[0].startswith(\"pawprint: pawprint failed to write.\")\n assert \"Table: None. Query: INSERT INTO None () VALUES ();\" in logs[0]\n assert \"Query: INSERT INTO None (event) VALUES ('going_to_fail')\" in logs[3]\n\n os.remove(\"pawprint.log\")","def failIfNotConnected(self, err):\n if (self.connected or self.disconnected or\n not hasattr(self, \"connector\")):\n return\n\n self.connector.connectionFailed(failure.Failure(err))\n del self.connector\n self.connectionFailedDefer.callback(1)","def testFeaturesError(self):\n\n def _testError(res):\n self.assertEqual(True,res[1][0].name=='challenge','Did not get correct challenge stanza')\n\n def _testSessionCreate(res):\n self.sid = res[0]['sid']\n # this xml is valid, just for testing\n # the point is to wait for a stream error\n self.assertEqual(True,res[1][0].name=='features','Did not get initial features')\n\n d = self.send(\"<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='DIGEST-MD5'/>\")\n d.addCallback(_testError)\n reactor.callLater(1.1, self.server_protocol.triggerChallenge)\n return d\n\n BOSH_XML = \"\"\"<body content='text/xml; charset=utf-8'\n hold='1'\n rid='%(rid)i'\n to='localhost'\n route='xmpp:127.0.0.1:%(server_port)i'\n ver='1.6'\n wait='15'\n ack='1'\n xml:lang='en'\n xmlns='http://jabber.org/protocol/httpbind'/>\n \"\"\"% { \"rid\": self.rid, \"server_port\": self.server_port }\n self.server_factory.protocol.delay_features = 3\n\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\n # NOTE : to trigger this bug there needs to be 0 waiting requests.\n\n return d","def unexpected_error(self, exception):","def _fail(self, exception):\n self.monitor_loop.stop()\n self._maintained.errback(exception)","def test_original_failure_not_error(self):\n dr = EventualResult(succeed(3), None)\n self.assertIdentical(dr.original_failure(), None)","def errConnectionLost(self):\n self.logger('stderr closed by process %d' % self._pid)","def test_startconnector_with_noretry_on_con_failure(self):\n\n yield self.connect('127.0.0.1', self.pbPort)\n\n localConfig = copy.copy(self.defaultConfig)\n localConfig.reconnectOnConnectionFailure = False\n yield self.add(localConfig)\n yield self.start(localConfig.id)\n\n # It takes a moment to stop the service after a connection failure\n while True:\n ssRet = yield self.service_status(localConfig.id)\n if ssRet != 1:\n break;\n else:\n time.sleep(1)\n\n self.assertEqual(0, ssRet)\n\n yield self.stop(localConfig.id)","async def test_flow_link_cannot_connect(hass: HomeAssistant) -> None:\n disc_bridge = get_discovered_bridge()\n with patch(\n \"homeassistant.components.hue.config_flow.discover_nupnp\",\n return_value=[disc_bridge],\n ):\n result = await hass.config_entries.flow.async_init(\n const.DOMAIN, context={\"source\": config_entries.SOURCE_USER}\n )\n\n with patch.object(config_flow, \"create_app_key\", side_effect=CannotConnect):\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input={\"id\": disc_bridge.id}\n )\n\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input={}\n )\n\n assert result[\"type\"] == \"abort\"\n assert result[\"reason\"] == \"cannot_connect\"","def test_loginException(self):\n\n class UnexpectedException(Exception):\n \"\"\"\n An unexpected exception.\n \"\"\"\n\n def raisesUnexpectedException(user, passwd):\n raise UnexpectedException(\"Whoops\")\n\n self.server.authenticateLogin = raisesUnexpectedException\n\n def login():\n return self.client.login(b'testuser', b'password-test')\n\n d1 = self.connected.addCallback(strip(login))\n\n d1.addErrback(self.assertClientFailureMessage, b\"Server error: Whoops\")\n\n @d1.addCallback\n def assertErrorLogged(_):\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\n\n d1.addErrback(self._ebGeneral)\n d1.addBoth(self._cbStopClient)\n\n d2 = self.loopback()\n d = defer.gatherResults([d1, d2])\n return d.addCallback(self._cbTestFailedLogin)","def failure_callback(self):\n error_filename = self.run_dir / \"eplusout.err\"\n if error_filename.exists():\n with open(error_filename, \"r\") as stderr:\n stderr_r = stderr.read()\n self.exception = EnergyPlusProcessError(\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\n )\n self.cleanup_callback()","def on_failure(self):\n pass","async def test_setup_failed_connect(\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\n) -> None:\n respx.get(\"http://localhost\").mock(\n side_effect=httpx.RequestError(\"server offline\", request=MagicMock())\n )\n assert await async_setup_component(\n hass,\n SENSOR_DOMAIN,\n {\n SENSOR_DOMAIN: {\n \"platform\": DOMAIN,\n \"resource\": \"http://localhost\",\n \"method\": \"GET\",\n }\n },\n )\n await hass.async_block_till_done()\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\n assert \"server offline\" in caplog.text","def instantiateShootErrback():\n d = defer.Deferred()\n try:\n 1/0\n except:\n d.errback()\n d.addErrback(lambda x: None)","def test_singleStopErrback(self):\n class ExpectedException(Exception):\n pass\n\n def main(reactor):\n reactor.callLater(1, reactor.stop)\n finished = defer.Deferred()\n reactor.addSystemEventTrigger(\n 'during', 'shutdown', finished.errback, ExpectedException())\n return finished\n r = _FakeReactor()\n exitError = self.assertRaises(\n SystemExit, task.react, main, _reactor=r)\n\n self.assertEqual(1, exitError.code)\n\n self.assertEqual(r.seconds(), 1)\n errors = self.flushLoggedErrors(ExpectedException)\n self.assertEqual(len(errors), 1)","def test_ddp_invalid_comm_hook_init(self):\n process_group = self._get_process_group()\n\n model = DistributedDataParallel(\n ModuleForDdpCommHook(), process_group=process_group\n )\n\n with self.assertRaisesRegex(TypeError, \"Communication hook must be callable.\"):\n model.register_comm_hook(state=None, hook=1)\n\n with self.assertRaisesRegex(\n ValueError, \"bucket annotation should be dist.GradBucket.\"\n ):\n\n def comm_hook(\n state: object, bucket: int\n ) -> torch.futures.Future[torch.Tensor]:\n return torch.futures.Future()\n\n model.register_comm_hook(state=None, hook=comm_hook)","def on_error(self, event: ThreadResult):\n if self._on_error is not None:\n self._on_error(event.data)","def test_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as err:\n server.sendall(b\"hello, world\")\n if platform == \"win32\":\n assert err.value.args[0] == ESHUTDOWN\n else:\n assert err.value.args[0] == EPIPE","def test_init(self):\n nt.assert_raises(Exception, CisInterface.CisOutput, 'error')","def test_invalid_event(bot):\n expect_error(edit, InputError, bot.username, 1, False, None, None)","def unhandled_error(self, error):\n # TODO(mpetazzoni): ws4py >= 0.3.5 only?\n _logger.debug('WebSocket error: %s; will reconnect.', error)","def test_broken_error_descriptor(self):\r\n with self.assertRaises(TestException):\r\n module = self.descriptor._xmodule","def testUndefinedPlaybackRaisesException(self):\n\t\tx = BaseAction('x')\n\t\ttry:\n\t\t\tpass\n\t\texcept PlayackException, e:\n\t\t\tpass","async def test_unhandled_exception_breaks_loop(\n decoy: Decoy,\n state_store: StateStore,\n command_executor: CommandExecutor,\n subject: QueueWorker,\n) -> None:\n decoy.when(await command_executor.execute(command_id=\"command-id-1\")).then_raise(\n RuntimeError(\"oh no\")\n )\n\n subject.start()\n\n with pytest.raises(RuntimeError, match=\"oh no\"):\n await subject.join()","def test_invalid_signal(self):\n mediator = Mediator()\n\n try:\n mediator.signal(\"foo\")\n except:\n raise AssertionError()","def test_error_handler_that_raises_errors(self, dp):\n handler_raise_error = MessageHandler(Filters.all, self.callback_raise_error)\n handler_increase_count = MessageHandler(Filters.all, self.callback_increase_count)\n error = TelegramError('Unauthorized.')\n\n dp.add_error_handler(self.error_handler_raise_error)\n\n # From errors caused by handlers\n dp.add_handler(handler_raise_error)\n dp.update_queue.put(self.message_update)\n sleep(.1)\n\n # From errors in the update_queue\n dp.remove_handler(handler_raise_error)\n dp.add_handler(handler_increase_count)\n dp.update_queue.put(error)\n dp.update_queue.put(self.message_update)\n sleep(.1)\n\n assert self.count == 1","def test_notificationCausesException(self):\n\t\tloggedErrors = []\n\t\tdef logError(message, failure):\n\t\t\tloggedErrors.append((message, failure))\n\n\t\tdef bodyReceived(body, isQuestion):\n\t\t\traise ValueError(\"bodyReceived did something wrong\")\n\n\t\tsent = ListLog()\n\t\tdef sendQANFrame(frame):\n\t\t\tsent.append(frame)\n\n\t\th = QANHelper(bodyReceived, logError, sendQANFrame, None)\n\t\th.handleQANFrame(Notification(\"You've got more mail\"))\n\n\t\tself.assertEqual(\"Peer's Notification caused uncaught exception\", loggedErrors[0][0])\n\t\tself.assertIsInstance(loggedErrors[0][1], failure.Failure)\n\n\t\tself.assertEqual([], sent.getNew())","async def test_setup_fails_non_root(\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\n) -> None:\n\n assert await async_setup_component(\n hass,\n DOMAIN,\n {},\n )\n await hass.async_block_till_done()\n\n with patch(\"os.geteuid\", return_value=10), patch(\n \"homeassistant.components.dhcp._verify_l2socket_setup\",\n side_effect=Scapy_Exception,\n ), patch(\"homeassistant.components.dhcp.DiscoverHosts.async_discover\"):\n hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)\n await hass.async_block_till_done()\n hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)\n await hass.async_block_till_done()\n\n assert \"Cannot watch for dhcp packets without root or CAP_NET_RAW\" in caplog.text","def die_screaming(instr):\n LOG.error(instr)\n sys.exit(1)","def die_screaming(instr):\n LOG.error(instr)\n sys.exit(1)","def main():\n cause_a_bunch_of_exceptions_to_happen()","def connection_failed(self, connection, error):\n assert False","async def test_connection_error(\n hass: HomeAssistant, init_integration, mock_auth, mock_config_entry\n) -> None:\n\n install = AsyncMock()\n install.arm = AsyncMock(return_value=False)\n install.arm_partially = AsyncMock(return_value=True)\n install.disarm = AsyncMock(return_value=True)\n install.status = Status.ARMED\n\n with patch(\"pyprosegur.installation.Installation.retrieve\", return_value=install):\n await hass.async_block_till_done()\n\n with patch(\n \"pyprosegur.installation.Installation.retrieve\", side_effect=ConnectionError\n ):\n await entity_component.async_update_entity(hass, PROSEGUR_ALARM_ENTITY)\n\n state = hass.states.get(PROSEGUR_ALARM_ENTITY)\n assert state.state == STATE_UNAVAILABLE","def IntrumentFailHook(self):\n #Restart iserver\n #If failed to restart\n #\treturn fail\n pass","def _err_emited(self, *args):\n\t\tdebug(\"OnEventDeferred : err event catched\")\n\t\tself.errback(*args)\n\t\tself._clean()","def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False","def state_failsafe_validate(cfg, app, win, events):"],"string":"[\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_event_handler_can_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_disconnect\\n if ctx.is_pre_ping:\\n ctx.is_disconnect = False\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def on_init_fail(self, event_time, message):\\n pass\",\n \"def test_exception_raised_no_dlq():\\n\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n with pytest.raises(RuntimeError):\\n test_client.send(blank_message)\",\n \"def test_sandbox_errors_false(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=False)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.assertRaises(Exception, self.signal.send, self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def state_failsafe_do(cfg, app, win, events):\",\n \"def whenException(self, channel, call):\",\n \"def _cb_ignore_listen_exception(self, exception, server):\\n if isinstance(exception, ssl.SSLError):\\n # A client which couldn’t verify the server tried to connect, continue but log the event\\n if exception.errqueue[-1][0] == ssl.ERR_TLSV1_ALERT_UNKNOWN_CA:\\n #print(\\\"Ignoring ERR_TLSV1_ALERT_UNKNOWN_CA from client %s\\\" %\\n # (’unknown’ if not hasattr(exception, ’peer’) else str(exception.peer)))\\n return True\\n # ... and more ...\\n return False\",\n \"def fatal(self, *args, **kwargs):\",\n \"def onConnectError(self, fetcher, error): #$NON-NLS-1$\\r\",\n \"def test_exception_raised_with_a_dlq():\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n dlq: missive.DLQ = {}\\n proc.set_dlq(dlq)\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n test_client.send(blank_message)\\n assert dlq == {blank_message.message_id: (blank_message, \\\"bad bytes!\\\")}\\n assert blank_message in test_client.acked\",\n \"def test_send_event_raises():\\n send_event('pytest-reportportal', '5.0.5')\",\n \"def test_exceptions_in_server_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n raise SentinelException()\\n\\n def client_callback(*args): # pragma: nocover\\n pytest.fail(\\\"Should not be called\\\")\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_cond_with_uncaught_error(env):\\n def explode(env, delay):\\n yield env.timeout(delay)\\n raise ValueError(f'Onoes, failed after {delay}!')\\n\\n def process(env):\\n yield env.timeout(1) | env.process(explode(env, 2))\\n\\n env.process(process(env))\\n try:\\n env.run()\\n assert False, 'There should have been an exception.'\\n except ValueError:\\n pass\\n assert env.now == 2\",\n \"def test_exception(self):\\n\\n sink = TObserver(immediate_continue=0)\\n self.obs.observe(init_observer_info(sink))\\n ack1 = self.left.on_next_list([select_completed])\\n\\n self.right.on_error(self.exception)\\n\\n self.assertIsInstance(self.measure_state(self.obs), ControlledZipStates.Stopped)\\n self.assertEqual(self.exception, sink.exception)\",\n \"async def test_connection_error(hass: HomeAssistant, conn_error) -> None:\\n\\n result = await hass.config_entries.flow.async_init(\\n DOMAIN, context={\\\"source\\\": config_entries.SOURCE_USER}\\n )\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input=DEMO_USER_INPUT\\n )\\n assert result[\\\"type\\\"] == data_entry_flow.FlowResultType.FORM\\n assert result[\\\"errors\\\"] == {\\\"base\\\": \\\"cannot_connect\\\"}\",\n \"def test_sandbox_errors_true(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=True)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.signal.send(self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def test_has_receivers(error_report_mock):\\n\\n app_crash()\\n error_report_mock.assert_not_called()\\n\\n signal('panic').connect(triage)\\n app_crash()\\n error_report_mock.assert_called_with()\",\n \"def test_decode_failure(self):\\n\\n def handle(event):\\n def test():\\n pass\\n\\n return 0x0000, test\\n\\n self.ae = ae = AE()\\n ae.add_requested_context(\\n ModalityPerformedProcedureStepNotification, ExplicitVRLittleEndian\\n )\\n ae.add_supported_context(ModalityPerformedProcedureStepNotification)\\n\\n handlers = [(evt.EVT_N_EVENT_REPORT, handle)]\\n scp = ae.start_server((\\\"localhost\\\", 11112), evt_handlers=handlers, block=False)\\n\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n\\n class DummyReply:\\n def getvalue(self):\\n def test():\\n pass\\n\\n return test\\n\\n class DummyMessage:\\n is_valid_response = True\\n EventReply = DummyReply()\\n Status = 0x0000\\n STATUS_OPTIONAL_KEYWORDS = []\\n\\n class DummyDIMSE:\\n msg_queue = queue.Queue()\\n gotten = False\\n\\n def send_msg(*args, **kwargs):\\n return\\n\\n def get_msg(self, *args, **kwargs):\\n if not self.gotten:\\n self.gotten = True\\n return 1, DummyMessage()\\n return None, None\\n\\n assoc._reactor_checkpoint.clear()\\n while not assoc._is_paused:\\n time.sleep(0.01)\\n assoc.dimse = DummyDIMSE()\\n assert assoc.is_established\\n\\n # Event Information\\n ds = Dataset()\\n ds.PatientName = \\\"Test^test\\\"\\n status, ds = assoc.send_n_event_report(\\n ds,\\n 1,\\n ModalityPerformedProcedureStepNotification,\\n \\\"1.2.840.10008.5.1.1.40.1\\\",\\n )\\n\\n assert status.Status == 0x0110\\n assert ds is None\\n\\n assoc.release()\\n scp.shutdown()\",\n \"async def test_on_connect_failed(hass: HomeAssistant, side_effect, error) -> None:\\n flow_result = await hass.config_entries.flow.async_init(\\n DOMAIN,\\n context={\\\"source\\\": SOURCE_USER, \\\"show_advanced_options\\\": True},\\n )\\n\\n with PATCH_GET_HOST, patch(\\n \\\"homeassistant.components.asuswrt.bridge.AsusWrtLegacy\\\"\\n ) as asus_wrt:\\n asus_wrt.return_value.connection.async_connect = AsyncMock(\\n side_effect=side_effect\\n )\\n asus_wrt.return_value.async_get_nvram = AsyncMock(return_value={})\\n asus_wrt.return_value.is_connected = False\\n\\n result = await hass.config_entries.flow.async_configure(\\n flow_result[\\\"flow_id\\\"], user_input=CONFIG_DATA\\n )\\n assert result[\\\"type\\\"] == data_entry_flow.FlowResultType.FORM\\n assert result[\\\"errors\\\"] == {\\\"base\\\": error}\",\n \"def procFail(proc):\\n\\tif 'a' in proc.config._notify.when['pipeline']:\\n\\t\\tlogger.debug('Notifying process fails')\\n\\t\\tEMAIL.send('proc', proc, 'abort')\",\n \"def test_can_not_handle_brew_container_task_failed_event(self):\\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\\n self.assertFalse(self.handler.can_handle(event))\",\n \"async def test_setup_failed_error(hass: HomeAssistant, ufp: MockUFPFixture) -> None:\\n\\n ufp.api.get_nvr = AsyncMock(side_effect=NvrError)\\n\\n await hass.config_entries.async_setup(ufp.entry.entry_id)\\n await hass.async_block_till_done()\\n assert ufp.entry.state == ConfigEntryState.SETUP_RETRY\\n assert not ufp.api.update.called\",\n \"def test_signal_interruption(self):\\n process = Popen(\\n [STRATIS_CLI, \\\"pool\\\", \\\"create\\\",\\n p_n(), DISKS[0]],\\n stdout=PIPE,\\n stderr=PIPE,\\n close_fds=True,\\n env=os.environ)\\n time.sleep(0.05)\\n process.send_signal(2)\\n result = process.communicate()\\n stdout_text = \\\"\\\"\\n stderr_text = \\\"\\\"\\n if result[0]:\\n stdout_text = bytes(result[0]).decode(\\\"utf-8\\\")\\n if result[1]:\\n stderr_text = bytes(result[1]).decode(\\\"utf-8\\\")\\n\\n self.assertTrue(\\\"Traceback\\\" not in stdout_text)\\n self.assertTrue(\\\"Traceback\\\" not in stderr_text)\\n self.assertNotEqual(process.returncode, 0)\",\n \"def test_fail_must_login(self):\\n guest_obj = self._check_init()\\n msg = 'You need to login first'\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.hotplug(vols=[dict()])\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.install_packages([])\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.push_file('source_url', 'target_path')\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)\",\n \"def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:\",\n \"def test_silent_write_errors():\\n\\n tracker = pawprint.Tracker(db=None, table=None)\\n\\n try:\\n tracker.write(event=\\\"This will fail silently.\\\")\\n except Exception:\\n pytest.fail(\\\"Failed to fail silently.\\\")\",\n \"def onleaveerror(self, event):\\n #print(self.config)\\n #try:\\n # self.mqttclient.publish(self.config['MQTT']['TOPICBASE'] + '/fsm/state', e.src + '->' + e.dst)\\n # self.mqttclient.disconnect()\\n # self.network.disconnect()\\n #except:\\n # pass\\n print('onleaveerror; event: %s, %s->%s' % (event.event, event.src, event.dst))\",\n \"def test_error_bubbles_up(self):\\n\\n def fail(box):\\n box.fail(ValueError(\\\"oh dear\\\"))\\n\\n self.assertThat(\\n lambda: sync_perform(func_dispatcher, Effect(fail)),\\n raises(ValueError(\\\"oh dear\\\")),\\n )\",\n \"async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\\n config_entry = MockConfigEntry(\\n domain=DOMAIN,\\n unique_id=MAC,\\n data={CONF_HOST: HOST, KEY_MAC: MAC},\\n )\\n config_entry.add_to_hass(hass)\\n\\n mock_daikin.factory.side_effect = ClientConnectionError\\n await hass.config_entries.async_setup(config_entry.entry_id)\\n await hass.async_block_till_done()\\n\\n assert config_entry.state == ConfigEntryState.SETUP_RETRY\",\n \"def test_not_running(): # pragma: windows\\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)\",\n \"def test_verify_state_of_a_device_when_disconnected_from_the_device():\",\n \"def OnError(self, error):\\r\\n\\t\\tLogErr(error)\\r\\n#\\t\\tself.Shutdown()\\r\\n\\t\\tself.onError()\",\n \"async def test_warn_when_cannot_connect(opp, caplog):\\n with patch.dict(os.environ, MOCK_ENVIRON), patch(\\n \\\"openpeerpower.components.oppio.OppIO.is_connected\\\",\\n return_value=None,\\n ):\\n result = await async_setup_component(opp, \\\"oppio\\\", {})\\n assert result\\n\\n assert opp.components.oppio.is_oppio()\\n assert \\\"Not connected with Opp.io / system too busy!\\\" in caplog.text\",\n \"def test_rsp_failure(self):\\n\\n def handle(event):\\n return 0x0112, None\\n\\n self.ae = ae = AE()\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n ae.network_timeout = 5\\n ae.add_supported_context(ProceduralEventLogging)\\n scp = ae.start_server(\\n (\\\"localhost\\\", 11112), block=False, evt_handlers=[(evt.EVT_N_ACTION, handle)]\\n )\\n\\n ae.add_requested_context(ProceduralEventLogging)\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n assert assoc.is_established\\n\\n ds = Dataset()\\n ds.PatientName = \\\"Test^test\\\"\\n status, ds = assoc.send_n_action(\\n ds, 1, ProceduralEventLogging, \\\"1.2.840.10008.5.1.1.40.1\\\"\\n )\\n assert status.Status == 0x0112\\n assert ds is None\\n assoc.release()\\n assert assoc.is_released\\n\\n scp.shutdown()\",\n \"def onError(self, connection:MQTTConnection, rc:int) -> bool:\\n\\t\\treturn True\",\n \"def error(self, *args):\\n\\n self.log(\\\"ERROR:\\\", args)\\n if not self.transport.connected:\\n Timer(5, connect(self.host, self.port)).register(self)\",\n \"def connectionLost(reason):\",\n \"async def on_error(self, event: str, error: Exception, *args, **kwargs):\\n print(f\\\"Ignoring exception in {event}\\\", file=sys.stderr)\\n traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)\",\n \"def test_failure_result(self):\\n dr = EventualResult(fail(RuntimeError()), None)\\n self.assertRaises(RuntimeError, dr.wait, 0.1)\",\n \"async def test_child_crash_propagation():\\n looper_cancelled = False\\n\\n async def looper():\\n nonlocal looper_cancelled\\n try:\\n while True:\\n await asyncio.sleep(0)\\n except asyncio.CancelledError:\\n looper_cancelled = True\\n\\n error = ValueError('crashed')\\n\\n async def crasher():\\n raise error\\n\\n with pytest.raises(ValueError) as excinfo:\\n async with Nursery() as nursery:\\n nursery.start_soon(looper())\\n nursery.start_soon(crasher())\\n\\n assert looper_cancelled\\n assert excinfo.value is error\",\n \"def connectFailed(self, reason):\\n\\t\\tself._tunnelReadyDeferred.errback(reason)\",\n \"def unknown_event(self, event):\\r\\n pass\",\n \"def test_exceptions_in_client_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n return self.sample_ocsp_data\\n\\n def client_callback(*args):\\n raise SentinelException()\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"async def test_startup_errors_should_halt_ready():\\n network = Network()\\n network.set_config(url=\\\"http://nowhere.at.all.localdomain:6865/\\\", connect_timeout=1)\\n\\n client = network.aio_party(\\\"SillyParty\\\")\\n\\n # place the ready() call BEFORE the run\\n f = ensure_future(wait_for(client.ready(), 2))\\n\\n try:\\n await network.aio_run(keep_open=False)\\n except Exception:\\n pass\\n\\n try:\\n await f\\n raise AssertionError(\\n \\\"client.ready() should not have ended because there is nothing to connect to\\\"\\n )\\n except asyncio.TimeoutError:\\n raise AssertionError(\\n \\\"client.ready() did not abort with an appropriate exception and was killed because \\\"\\n \\\"it was taking too long\\\"\\n )\\n except CancelledError:\\n LOG.info(\\\"Successfully terminated because ready() was cancelled.\\\")\",\n \"def test_unexpected_EOF(self):\\n server_conn, client_conn = loopback()\\n client_conn.sock_shutdown(SHUT_RDWR)\\n with pytest.raises(SysCallError) as err:\\n server_conn.recv(1024)\\n if platform == \\\"win32\\\":\\n assert err.value.args == (10054, \\\"WSAECONNRESET\\\")\\n else:\\n assert err.value.args == (-1, \\\"Unexpected EOF\\\")\",\n \"def test_exception_with_callback(self):\\n test_utils.generate_test_config_file()\\n\\n exception_callback = mock.Mock()\\n\\n client = PowerTrackClient(_dummy_callback, exception_callback,\\n config_file_path=config_file)\\n client.connect()\\n client.disconnect()\\n self.assertTrue(exception_callback.called)\\n actual_exinfo = exception_callback.call_args[0][0]\\n actual_ex = actual_exinfo[1]\\n self.assertIsInstance(actual_ex, Exception)\\n self.assertEqual(actual_ex.message, \\\"This is a test exception\\\")\",\n \"def test_scp_callback_exception(self):\\n self.scp = DummyVerificationSCP()\\n def on_c_echo(context, info):\\n raise ValueError\\n self.scp.ae.on_c_echo = on_c_echo\\n self.scp.start()\\n\\n ae = AE()\\n ae.add_requested_context(VerificationSOPClass)\\n assoc = ae.associate('localhost', 11112)\\n assert assoc.is_established\\n rsp = assoc.send_c_echo()\\n assert rsp.Status == 0x0000\\n assoc.release()\\n self.scp.stop()\",\n \"def test_error(self, mock_validate_session):\\n mock_validate_session.return_value = False\\n with pytest.raises(SystemExit) as ctx:\\n celery_command.worker(Namespace(queues=1, concurrency=1))\\n assert str(ctx.value) == \\\"Worker exiting, database connection precheck failed.\\\"\",\n \"def testRemoteError(self):\\n\\n def _testStreamError(res):\\n self.assertEqual(True, isinstance(res.value, httpb_client.HTTPBNetworkTerminated))\\n\\n self.assertEqual(True, res.value.body_tag.hasAttribute('condition'), 'No attribute condition')\\n # This is not a stream error because we sent invalid xml\\n self.assertEqual(res.value.body_tag['condition'], 'remote-stream-error')\\n self.assertEqual(True, len(res.value.elements)>0)\\n # The XML should exactly match the error XML sent by triggerStreamError().\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/policy-violation\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/arbitrary-extension\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/text[text() = 'Error text']\\\").matches(res.value.elements[0]))\\n\\n\\n\\n def _failStreamError(res):\\n self.fail('A stream error needs to be returned')\\n\\n def _testSessionCreate(res):\\n self.sid = res[0]['sid']\\n # this xml is valid, just for testing\\n # the point is to wait for a stream error\\n d = self.send('<fdsfd/>')\\n d.addCallback(_failStreamError)\\n d.addErrback(_testStreamError)\\n self.server_protocol.triggerStreamError()\\n\\n return d\\n\\n BOSH_XML = \\\"\\\"\\\"<body content='text/xml; charset=utf-8'\\n hold='1'\\n rid='%(rid)i'\\n to='localhost'\\n route='xmpp:127.0.0.1:%(server_port)i'\\n ver='1.6'\\n wait='60'\\n ack='1'\\n xml:lang='en'\\n xmlns='http://jabber.org/protocol/httpbind'/>\\n \\\"\\\"\\\"% { \\\"rid\\\": self.rid, \\\"server_port\\\": self.server_port }\\n\\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\\n\\n return d\",\n \"def fatal_error(message, new_raise=None):\\n if not hadFatalErrors:\\n mess = ['natlinkconfigfunctions failed because of fatal error:',\\n '', message, '',\\n 'So if Dragon is running, close it and then rerun this program (in elevated mode).']\\n mess = '\\\\n'.join(mess)\\n print(mess)\\n print(\\\"\\\\n\\\\n*** See also the messageBox, and close it\\\")\\n windowsMessageBox(mess)\\n if message not in hadFatalErrors:\\n hadFatalErrors.append(message)\\n if new_raise:\\n raise new_raise\",\n \"def test_listen_error(self):\\n listen_port = self.get_port()\\n config = Qdrouterd.Config([\\n ('router', {'mode': 'standalone', 'id': 'bad'}),\\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\\n ('listener', {'port': listen_port, 'http':True})])\\n r = Qdrouterd(name=\\\"expect_fail\\\", config=config, wait=False);\\n self.assertEqual(1, r.wait())\",\n \"async def test_button_connection_error(\\n hass: HomeAssistant,\\n mock_lametric: MagicMock,\\n) -> None:\\n mock_lametric.app_next.side_effect = LaMetricConnectionError\\n\\n with pytest.raises(\\n HomeAssistantError, match=\\\"Error communicating with the LaMetric device\\\"\\n ):\\n await hass.services.async_call(\\n BUTTON_DOMAIN,\\n SERVICE_PRESS,\\n {ATTR_ENTITY_ID: \\\"button.frenck_s_lametric_next_app\\\"},\\n blocking=True,\\n )\\n await hass.async_block_till_done()\\n\\n state = hass.states.get(\\\"button.frenck_s_lametric_next_app\\\")\\n assert state\\n assert state.state == STATE_UNAVAILABLE\",\n \"def onentererror(self, event):\\n print('onentererror; event: %s, %s->%s' % (event.event, event.src, event.dst))\",\n \"def test_parse_message_failure_connect(self):\\n for test_case in self.failure_test_params_wrong_connect:\\n expected = test_case[KEY_EXPECTED]\\n mock_connect = app.on_connect()\\n\\n self.assertNotEqual(expected, mock_connect)\",\n \"def test_exceptions():\\r\\n # test that trying to connect_ to a non existent app fails\\r\\n try:\\r\\n app = application.Application()\\r\\n app.connect(path=r\\\"No process with this please\\\")\\r\\n assert False\\r\\n except application.ProcessNotFoundError:\\r\\n print('ProcessNotFoundError has been raised. OK.')\\r\\n\\r\\n # test that trying to connect_ to a non existent app fails\\r\\n try:\\r\\n app = application.Application()\\r\\n app.start(cmd_line = r\\\"No process with this please\\\")\\r\\n assert False\\r\\n except application.AppStartError:\\r\\n print('AppStartError has been raised. OK.')\",\n \"def test_pause_not_listening(testchannel):\\n with testchannel.open():\\n with pytest.raises(NotListeningError):\\n testchannel.pause()\",\n \"def handle_err(self):\\n pass\",\n \"def test_that_error_callback_is_not_invoked_on_no_error(self, request):\\n error = False\\n\\n def on_error(_):\\n nonlocal error\\n error = True\\n\\n response = requests.Response()\\n response.status_code = 200\\n request.return_value = response\\n r = rx_request('get', 'url')\\n\\n r.subscribe(on_error=on_error)\\n\\n self.assertFalse(error)\",\n \"def test_shutdown_wrong_args(self):\\n connection = Connection(Context(SSLv23_METHOD), None)\\n with pytest.raises(TypeError):\\n connection.set_shutdown(None)\",\n \"def test_handle_flag_error(self):\\n pass\",\n \"def serious_error(self, e):\\n pass\",\n \"def test_nonsilent_write_errors(error_logger):\\n\\n tracker = pawprint.Tracker(db=\\\"postgresql:///fail\\\", logger=error_logger)\\n\\n with pytest.raises(Exception):\\n tracker.write()\\n with pytest.raises(Exception):\\n tracker.write(event=\\\"going_to_fail\\\")\\n\\n with open(\\\"pawprint.log\\\", mode=\\\"r\\\") as f:\\n logs = f.readlines()\\n print(logs[3])\\n\\n assert len(logs) == 6\\n assert logs[0].startswith(\\\"pawprint: pawprint failed to write.\\\")\\n assert \\\"Table: None. Query: INSERT INTO None () VALUES ();\\\" in logs[0]\\n assert \\\"Query: INSERT INTO None (event) VALUES ('going_to_fail')\\\" in logs[3]\\n\\n os.remove(\\\"pawprint.log\\\")\",\n \"def failIfNotConnected(self, err):\\n if (self.connected or self.disconnected or\\n not hasattr(self, \\\"connector\\\")):\\n return\\n\\n self.connector.connectionFailed(failure.Failure(err))\\n del self.connector\\n self.connectionFailedDefer.callback(1)\",\n \"def testFeaturesError(self):\\n\\n def _testError(res):\\n self.assertEqual(True,res[1][0].name=='challenge','Did not get correct challenge stanza')\\n\\n def _testSessionCreate(res):\\n self.sid = res[0]['sid']\\n # this xml is valid, just for testing\\n # the point is to wait for a stream error\\n self.assertEqual(True,res[1][0].name=='features','Did not get initial features')\\n\\n d = self.send(\\\"<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='DIGEST-MD5'/>\\\")\\n d.addCallback(_testError)\\n reactor.callLater(1.1, self.server_protocol.triggerChallenge)\\n return d\\n\\n BOSH_XML = \\\"\\\"\\\"<body content='text/xml; charset=utf-8'\\n hold='1'\\n rid='%(rid)i'\\n to='localhost'\\n route='xmpp:127.0.0.1:%(server_port)i'\\n ver='1.6'\\n wait='15'\\n ack='1'\\n xml:lang='en'\\n xmlns='http://jabber.org/protocol/httpbind'/>\\n \\\"\\\"\\\"% { \\\"rid\\\": self.rid, \\\"server_port\\\": self.server_port }\\n self.server_factory.protocol.delay_features = 3\\n\\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\\n # NOTE : to trigger this bug there needs to be 0 waiting requests.\\n\\n return d\",\n \"def unexpected_error(self, exception):\",\n \"def _fail(self, exception):\\n self.monitor_loop.stop()\\n self._maintained.errback(exception)\",\n \"def test_original_failure_not_error(self):\\n dr = EventualResult(succeed(3), None)\\n self.assertIdentical(dr.original_failure(), None)\",\n \"def errConnectionLost(self):\\n self.logger('stderr closed by process %d' % self._pid)\",\n \"def test_startconnector_with_noretry_on_con_failure(self):\\n\\n yield self.connect('127.0.0.1', self.pbPort)\\n\\n localConfig = copy.copy(self.defaultConfig)\\n localConfig.reconnectOnConnectionFailure = False\\n yield self.add(localConfig)\\n yield self.start(localConfig.id)\\n\\n # It takes a moment to stop the service after a connection failure\\n while True:\\n ssRet = yield self.service_status(localConfig.id)\\n if ssRet != 1:\\n break;\\n else:\\n time.sleep(1)\\n\\n self.assertEqual(0, ssRet)\\n\\n yield self.stop(localConfig.id)\",\n \"async def test_flow_link_cannot_connect(hass: HomeAssistant) -> None:\\n disc_bridge = get_discovered_bridge()\\n with patch(\\n \\\"homeassistant.components.hue.config_flow.discover_nupnp\\\",\\n return_value=[disc_bridge],\\n ):\\n result = await hass.config_entries.flow.async_init(\\n const.DOMAIN, context={\\\"source\\\": config_entries.SOURCE_USER}\\n )\\n\\n with patch.object(config_flow, \\\"create_app_key\\\", side_effect=CannotConnect):\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input={\\\"id\\\": disc_bridge.id}\\n )\\n\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input={}\\n )\\n\\n assert result[\\\"type\\\"] == \\\"abort\\\"\\n assert result[\\\"reason\\\"] == \\\"cannot_connect\\\"\",\n \"def test_loginException(self):\\n\\n class UnexpectedException(Exception):\\n \\\"\\\"\\\"\\n An unexpected exception.\\n \\\"\\\"\\\"\\n\\n def raisesUnexpectedException(user, passwd):\\n raise UnexpectedException(\\\"Whoops\\\")\\n\\n self.server.authenticateLogin = raisesUnexpectedException\\n\\n def login():\\n return self.client.login(b'testuser', b'password-test')\\n\\n d1 = self.connected.addCallback(strip(login))\\n\\n d1.addErrback(self.assertClientFailureMessage, b\\\"Server error: Whoops\\\")\\n\\n @d1.addCallback\\n def assertErrorLogged(_):\\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\\n\\n d1.addErrback(self._ebGeneral)\\n d1.addBoth(self._cbStopClient)\\n\\n d2 = self.loopback()\\n d = defer.gatherResults([d1, d2])\\n return d.addCallback(self._cbTestFailedLogin)\",\n \"def failure_callback(self):\\n error_filename = self.run_dir / \\\"eplusout.err\\\"\\n if error_filename.exists():\\n with open(error_filename, \\\"r\\\") as stderr:\\n stderr_r = stderr.read()\\n self.exception = EnergyPlusProcessError(\\n cmd=self.cmd, stderr=stderr_r, idf=self.idf\\n )\\n self.cleanup_callback()\",\n \"def on_failure(self):\\n pass\",\n \"async def test_setup_failed_connect(\\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\\n) -> None:\\n respx.get(\\\"http://localhost\\\").mock(\\n side_effect=httpx.RequestError(\\\"server offline\\\", request=MagicMock())\\n )\\n assert await async_setup_component(\\n hass,\\n SENSOR_DOMAIN,\\n {\\n SENSOR_DOMAIN: {\\n \\\"platform\\\": DOMAIN,\\n \\\"resource\\\": \\\"http://localhost\\\",\\n \\\"method\\\": \\\"GET\\\",\\n }\\n },\\n )\\n await hass.async_block_till_done()\\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\\n assert \\\"server offline\\\" in caplog.text\",\n \"def instantiateShootErrback():\\n d = defer.Deferred()\\n try:\\n 1/0\\n except:\\n d.errback()\\n d.addErrback(lambda x: None)\",\n \"def test_singleStopErrback(self):\\n class ExpectedException(Exception):\\n pass\\n\\n def main(reactor):\\n reactor.callLater(1, reactor.stop)\\n finished = defer.Deferred()\\n reactor.addSystemEventTrigger(\\n 'during', 'shutdown', finished.errback, ExpectedException())\\n return finished\\n r = _FakeReactor()\\n exitError = self.assertRaises(\\n SystemExit, task.react, main, _reactor=r)\\n\\n self.assertEqual(1, exitError.code)\\n\\n self.assertEqual(r.seconds(), 1)\\n errors = self.flushLoggedErrors(ExpectedException)\\n self.assertEqual(len(errors), 1)\",\n \"def test_ddp_invalid_comm_hook_init(self):\\n process_group = self._get_process_group()\\n\\n model = DistributedDataParallel(\\n ModuleForDdpCommHook(), process_group=process_group\\n )\\n\\n with self.assertRaisesRegex(TypeError, \\\"Communication hook must be callable.\\\"):\\n model.register_comm_hook(state=None, hook=1)\\n\\n with self.assertRaisesRegex(\\n ValueError, \\\"bucket annotation should be dist.GradBucket.\\\"\\n ):\\n\\n def comm_hook(\\n state: object, bucket: int\\n ) -> torch.futures.Future[torch.Tensor]:\\n return torch.futures.Future()\\n\\n model.register_comm_hook(state=None, hook=comm_hook)\",\n \"def on_error(self, event: ThreadResult):\\n if self._on_error is not None:\\n self._on_error(event.data)\",\n \"def test_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as err:\\n server.sendall(b\\\"hello, world\\\")\\n if platform == \\\"win32\\\":\\n assert err.value.args[0] == ESHUTDOWN\\n else:\\n assert err.value.args[0] == EPIPE\",\n \"def test_init(self):\\n nt.assert_raises(Exception, CisInterface.CisOutput, 'error')\",\n \"def test_invalid_event(bot):\\n expect_error(edit, InputError, bot.username, 1, False, None, None)\",\n \"def unhandled_error(self, error):\\n # TODO(mpetazzoni): ws4py >= 0.3.5 only?\\n _logger.debug('WebSocket error: %s; will reconnect.', error)\",\n \"def test_broken_error_descriptor(self):\\r\\n with self.assertRaises(TestException):\\r\\n module = self.descriptor._xmodule\",\n \"def testUndefinedPlaybackRaisesException(self):\\n\\t\\tx = BaseAction('x')\\n\\t\\ttry:\\n\\t\\t\\tpass\\n\\t\\texcept PlayackException, e:\\n\\t\\t\\tpass\",\n \"async def test_unhandled_exception_breaks_loop(\\n decoy: Decoy,\\n state_store: StateStore,\\n command_executor: CommandExecutor,\\n subject: QueueWorker,\\n) -> None:\\n decoy.when(await command_executor.execute(command_id=\\\"command-id-1\\\")).then_raise(\\n RuntimeError(\\\"oh no\\\")\\n )\\n\\n subject.start()\\n\\n with pytest.raises(RuntimeError, match=\\\"oh no\\\"):\\n await subject.join()\",\n \"def test_invalid_signal(self):\\n mediator = Mediator()\\n\\n try:\\n mediator.signal(\\\"foo\\\")\\n except:\\n raise AssertionError()\",\n \"def test_error_handler_that_raises_errors(self, dp):\\n handler_raise_error = MessageHandler(Filters.all, self.callback_raise_error)\\n handler_increase_count = MessageHandler(Filters.all, self.callback_increase_count)\\n error = TelegramError('Unauthorized.')\\n\\n dp.add_error_handler(self.error_handler_raise_error)\\n\\n # From errors caused by handlers\\n dp.add_handler(handler_raise_error)\\n dp.update_queue.put(self.message_update)\\n sleep(.1)\\n\\n # From errors in the update_queue\\n dp.remove_handler(handler_raise_error)\\n dp.add_handler(handler_increase_count)\\n dp.update_queue.put(error)\\n dp.update_queue.put(self.message_update)\\n sleep(.1)\\n\\n assert self.count == 1\",\n \"def test_notificationCausesException(self):\\n\\t\\tloggedErrors = []\\n\\t\\tdef logError(message, failure):\\n\\t\\t\\tloggedErrors.append((message, failure))\\n\\n\\t\\tdef bodyReceived(body, isQuestion):\\n\\t\\t\\traise ValueError(\\\"bodyReceived did something wrong\\\")\\n\\n\\t\\tsent = ListLog()\\n\\t\\tdef sendQANFrame(frame):\\n\\t\\t\\tsent.append(frame)\\n\\n\\t\\th = QANHelper(bodyReceived, logError, sendQANFrame, None)\\n\\t\\th.handleQANFrame(Notification(\\\"You've got more mail\\\"))\\n\\n\\t\\tself.assertEqual(\\\"Peer's Notification caused uncaught exception\\\", loggedErrors[0][0])\\n\\t\\tself.assertIsInstance(loggedErrors[0][1], failure.Failure)\\n\\n\\t\\tself.assertEqual([], sent.getNew())\",\n \"async def test_setup_fails_non_root(\\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\\n) -> None:\\n\\n assert await async_setup_component(\\n hass,\\n DOMAIN,\\n {},\\n )\\n await hass.async_block_till_done()\\n\\n with patch(\\\"os.geteuid\\\", return_value=10), patch(\\n \\\"homeassistant.components.dhcp._verify_l2socket_setup\\\",\\n side_effect=Scapy_Exception,\\n ), patch(\\\"homeassistant.components.dhcp.DiscoverHosts.async_discover\\\"):\\n hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)\\n await hass.async_block_till_done()\\n hass.bus.async_fire(EVENT_HOMEASSISTANT_STOP)\\n await hass.async_block_till_done()\\n\\n assert \\\"Cannot watch for dhcp packets without root or CAP_NET_RAW\\\" in caplog.text\",\n \"def die_screaming(instr):\\n LOG.error(instr)\\n sys.exit(1)\",\n \"def die_screaming(instr):\\n LOG.error(instr)\\n sys.exit(1)\",\n \"def main():\\n cause_a_bunch_of_exceptions_to_happen()\",\n \"def connection_failed(self, connection, error):\\n assert False\",\n \"async def test_connection_error(\\n hass: HomeAssistant, init_integration, mock_auth, mock_config_entry\\n) -> None:\\n\\n install = AsyncMock()\\n install.arm = AsyncMock(return_value=False)\\n install.arm_partially = AsyncMock(return_value=True)\\n install.disarm = AsyncMock(return_value=True)\\n install.status = Status.ARMED\\n\\n with patch(\\\"pyprosegur.installation.Installation.retrieve\\\", return_value=install):\\n await hass.async_block_till_done()\\n\\n with patch(\\n \\\"pyprosegur.installation.Installation.retrieve\\\", side_effect=ConnectionError\\n ):\\n await entity_component.async_update_entity(hass, PROSEGUR_ALARM_ENTITY)\\n\\n state = hass.states.get(PROSEGUR_ALARM_ENTITY)\\n assert state.state == STATE_UNAVAILABLE\",\n \"def IntrumentFailHook(self):\\n #Restart iserver\\n #If failed to restart\\n #\\treturn fail\\n pass\",\n \"def _err_emited(self, *args):\\n\\t\\tdebug(\\\"OnEventDeferred : err event catched\\\")\\n\\t\\tself.errback(*args)\\n\\t\\tself._clean()\",\n \"def _connect_failed(self):\\n\\t\\tself.root.stdout.write(\\\"Error: Connection Failed!\\\\n\\\")\\n\\t\\tself.client = False\",\n \"def state_failsafe_validate(cfg, app, win, events):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70234233","0.6971551","0.66948354","0.6495688","0.61916995","0.61216474","0.6121415","0.59488285","0.5900851","0.5878428","0.5877062","0.58651876","0.58647805","0.586168","0.58307934","0.58160025","0.5814683","0.579428","0.5790778","0.5782339","0.57807255","0.57798123","0.5759103","0.57395226","0.57229036","0.57081556","0.5700173","0.5681591","0.5673147","0.5671071","0.56694144","0.5667142","0.5666124","0.5665314","0.56600386","0.56567955","0.5648218","0.564698","0.5645265","0.5644199","0.56425303","0.5642134","0.5640347","0.56326014","0.5630308","0.56205016","0.56008923","0.55991966","0.5588264","0.5571939","0.5570977","0.5570603","0.55703735","0.55691314","0.55682355","0.55566424","0.5555718","0.55544","0.55480427","0.5545274","0.5544143","0.5542426","0.5542098","0.5536772","0.5532746","0.55155444","0.5515527","0.5512664","0.55125403","0.5511137","0.55069697","0.5505792","0.5505655","0.55046576","0.5503395","0.5502702","0.5501013","0.5496851","0.54906917","0.5488837","0.5476057","0.5475739","0.5475142","0.5474112","0.5472567","0.5469314","0.54565054","0.54532284","0.54506797","0.5450478","0.54479116","0.5443337","0.5443337","0.54431367","0.5441381","0.54403144","0.54341847","0.5429742","0.5428964","0.54289335"],"string":"[\n \"0.70234233\",\n \"0.6971551\",\n \"0.66948354\",\n \"0.6495688\",\n \"0.61916995\",\n \"0.61216474\",\n \"0.6121415\",\n \"0.59488285\",\n \"0.5900851\",\n \"0.5878428\",\n \"0.5877062\",\n \"0.58651876\",\n \"0.58647805\",\n \"0.586168\",\n \"0.58307934\",\n \"0.58160025\",\n \"0.5814683\",\n \"0.579428\",\n \"0.5790778\",\n \"0.5782339\",\n \"0.57807255\",\n \"0.57798123\",\n \"0.5759103\",\n \"0.57395226\",\n \"0.57229036\",\n \"0.57081556\",\n \"0.5700173\",\n \"0.5681591\",\n \"0.5673147\",\n \"0.5671071\",\n \"0.56694144\",\n \"0.5667142\",\n \"0.5666124\",\n \"0.5665314\",\n \"0.56600386\",\n \"0.56567955\",\n \"0.5648218\",\n \"0.564698\",\n \"0.5645265\",\n \"0.5644199\",\n \"0.56425303\",\n \"0.5642134\",\n \"0.5640347\",\n \"0.56326014\",\n \"0.5630308\",\n \"0.56205016\",\n \"0.56008923\",\n \"0.55991966\",\n \"0.5588264\",\n \"0.5571939\",\n \"0.5570977\",\n \"0.5570603\",\n \"0.55703735\",\n \"0.55691314\",\n \"0.55682355\",\n \"0.55566424\",\n \"0.5555718\",\n \"0.55544\",\n \"0.55480427\",\n \"0.5545274\",\n \"0.5544143\",\n \"0.5542426\",\n \"0.5542098\",\n \"0.5536772\",\n \"0.5532746\",\n \"0.55155444\",\n \"0.5515527\",\n \"0.5512664\",\n \"0.55125403\",\n \"0.5511137\",\n \"0.55069697\",\n \"0.5505792\",\n \"0.5505655\",\n \"0.55046576\",\n \"0.5503395\",\n \"0.5502702\",\n \"0.5501013\",\n \"0.5496851\",\n \"0.54906917\",\n \"0.5488837\",\n \"0.5476057\",\n \"0.5475739\",\n \"0.5475142\",\n \"0.5474112\",\n \"0.5472567\",\n \"0.5469314\",\n \"0.54565054\",\n \"0.54532284\",\n \"0.54506797\",\n \"0.5450478\",\n \"0.54479116\",\n \"0.5443337\",\n \"0.5443337\",\n \"0.54431367\",\n \"0.5441381\",\n \"0.54403144\",\n \"0.54341847\",\n \"0.5429742\",\n \"0.5428964\",\n \"0.54289335\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6286811"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":84670,"cells":{"query":{"kind":"string","value":"test that an event hook can receive a disconnect error and convert it to be a fatal error during preping"},"document":{"kind":"string","value":"def test_event_handler_can_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_disconnect\n if ctx.is_pre_ping:\n ctx.is_disconnect = False\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()"},"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 test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_disconnect\n\n conn = engine.connect()\n conn.close()","def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled disconnect situation\"\n ):\n engine.connect()","def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\n\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n ctx.is_disconnect = True\n\n conn = engine.connect()\n # no error\n conn.close()","def on_init_fail(self, event_time, message):\n pass","def test_verify_state_of_a_device_when_disconnected_from_the_device():","def onConnectError(self, fetcher, error): #$NON-NLS-1$\r","def connectionLost(reason):","def state_failsafe_do(cfg, app, win, events):","async def test_on_connect_failed(hass: HomeAssistant, side_effect, error) -> None:\n flow_result = await hass.config_entries.flow.async_init(\n DOMAIN,\n context={\"source\": SOURCE_USER, \"show_advanced_options\": True},\n )\n\n with PATCH_GET_HOST, patch(\n \"homeassistant.components.asuswrt.bridge.AsusWrtLegacy\"\n ) as asus_wrt:\n asus_wrt.return_value.connection.async_connect = AsyncMock(\n side_effect=side_effect\n )\n asus_wrt.return_value.async_get_nvram = AsyncMock(return_value={})\n asus_wrt.return_value.is_connected = False\n\n result = await hass.config_entries.flow.async_configure(\n flow_result[\"flow_id\"], user_input=CONFIG_DATA\n )\n assert result[\"type\"] == data_entry_flow.FlowResultType.FORM\n assert result[\"errors\"] == {\"base\": error}","def _cb_ignore_listen_exception(self, exception, server):\n if isinstance(exception, ssl.SSLError):\n # A client which couldn’t verify the server tried to connect, continue but log the event\n if exception.errqueue[-1][0] == ssl.ERR_TLSV1_ALERT_UNKNOWN_CA:\n #print(\"Ignoring ERR_TLSV1_ALERT_UNKNOWN_CA from client %s\" %\n # (’unknown’ if not hasattr(exception, ’peer’) else str(exception.peer)))\n return True\n # ... and more ...\n return False","def whenException(self, channel, call):","def test_parse_message_failure_connect(self):\n for test_case in self.failure_test_params_wrong_connect:\n expected = test_case[KEY_EXPECTED]\n mock_connect = app.on_connect()\n\n self.assertNotEqual(expected, mock_connect)","async def test_connection_error(hass: HomeAssistant, conn_error) -> None:\n\n result = await hass.config_entries.flow.async_init(\n DOMAIN, context={\"source\": config_entries.SOURCE_USER}\n )\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input=DEMO_USER_INPUT\n )\n assert result[\"type\"] == data_entry_flow.FlowResultType.FORM\n assert result[\"errors\"] == {\"base\": \"cannot_connect\"}","def connectFailed(self, reason):\n\t\tself._tunnelReadyDeferred.errback(reason)","async def test_warn_when_cannot_connect(opp, caplog):\n with patch.dict(os.environ, MOCK_ENVIRON), patch(\n \"openpeerpower.components.oppio.OppIO.is_connected\",\n return_value=None,\n ):\n result = await async_setup_component(opp, \"oppio\", {})\n assert result\n\n assert opp.components.oppio.is_oppio()\n assert \"Not connected with Opp.io / system too busy!\" in caplog.text","def test_exception_raised_no_dlq():\n\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\n\n @proc.handle_for(always)\n def crash(message, ctx):\n raise RuntimeError(\"bad bytes!\")\n\n with proc.test_client() as test_client:\n blank_message = missive.RawMessage(b\"\")\n with pytest.raises(RuntimeError):\n test_client.send(blank_message)","def test_parse_message_failure_disconnect(self, mock_disconnect):\n for test_case in self.failure_test_params_disconnect:\n expected = test_case[KEY_EXPECTED]\n mock_disconnect = app.on_disconnect()\n self.assertNotEqual(expected, mock_disconnect)","async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\n config_entry = MockConfigEntry(\n domain=DOMAIN,\n unique_id=MAC,\n data={CONF_HOST: HOST, KEY_MAC: MAC},\n )\n config_entry.add_to_hass(hass)\n\n mock_daikin.factory.side_effect = ClientConnectionError\n await hass.config_entries.async_setup(config_entry.entry_id)\n await hass.async_block_till_done()\n\n assert config_entry.state == ConfigEntryState.SETUP_RETRY","def test_sandbox_errors_false(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=False)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.assertRaises(Exception, self.signal.send, self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def test_disconnect_before_connect(connection, events, schedule, flush):\n schedule(connection.disconnect())\n flush()\n assert not connection.connected\n assert not events.triggered(\"CLIENT_CONNECT\")\n assert not events.triggered(\"CLIENT_DISCONNECT\")","def test_already_disconnected(connection, events, schedule, flush):\n schedule(connection.connect(),\n connection.disconnect(),\n connection.disconnect())\n flush()\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def onleaveerror(self, event):\n #print(self.config)\n #try:\n # self.mqttclient.publish(self.config['MQTT']['TOPICBASE'] + '/fsm/state', e.src + '->' + e.dst)\n # self.mqttclient.disconnect()\n # self.network.disconnect()\n #except:\n # pass\n print('onleaveerror; event: %s, %s->%s' % (event.event, event.src, event.dst))","def onError(self, connection:MQTTConnection, rc:int) -> bool:\n\t\treturn True","def test_exceptions_in_server_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n raise SentinelException()\n\n def client_callback(*args): # pragma: nocover\n pytest.fail(\"Should not be called\")\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def test_exception(self):\n\n sink = TObserver(immediate_continue=0)\n self.obs.observe(init_observer_info(sink))\n ack1 = self.left.on_next_list([select_completed])\n\n self.right.on_error(self.exception)\n\n self.assertIsInstance(self.measure_state(self.obs), ControlledZipStates.Stopped)\n self.assertEqual(self.exception, sink.exception)","def test_invalid_disconnect(self):\n mediator = Mediator()\n try:\n mediator.disconnect(\"foo\", self.dog.set_sound)\n mediator.disconnect(\"bar\", self.cat.set_sound)\n except:\n raise AssertionError()","def failIfNotConnected(self, err):\n if (self.connected or self.disconnected or\n not hasattr(self, \"connector\")):\n return\n\n self.connector.connectionFailed(failure.Failure(err))\n del self.connector\n self.connectionFailedDefer.callback(1)","def test_decode_failure(self):\n\n def handle(event):\n def test():\n pass\n\n return 0x0000, test\n\n self.ae = ae = AE()\n ae.add_requested_context(\n ModalityPerformedProcedureStepNotification, ExplicitVRLittleEndian\n )\n ae.add_supported_context(ModalityPerformedProcedureStepNotification)\n\n handlers = [(evt.EVT_N_EVENT_REPORT, handle)]\n scp = ae.start_server((\"localhost\", 11112), evt_handlers=handlers, block=False)\n\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n assoc = ae.associate(\"localhost\", 11112)\n\n class DummyReply:\n def getvalue(self):\n def test():\n pass\n\n return test\n\n class DummyMessage:\n is_valid_response = True\n EventReply = DummyReply()\n Status = 0x0000\n STATUS_OPTIONAL_KEYWORDS = []\n\n class DummyDIMSE:\n msg_queue = queue.Queue()\n gotten = False\n\n def send_msg(*args, **kwargs):\n return\n\n def get_msg(self, *args, **kwargs):\n if not self.gotten:\n self.gotten = True\n return 1, DummyMessage()\n return None, None\n\n assoc._reactor_checkpoint.clear()\n while not assoc._is_paused:\n time.sleep(0.01)\n assoc.dimse = DummyDIMSE()\n assert assoc.is_established\n\n # Event Information\n ds = Dataset()\n ds.PatientName = \"Test^test\"\n status, ds = assoc.send_n_event_report(\n ds,\n 1,\n ModalityPerformedProcedureStepNotification,\n \"1.2.840.10008.5.1.1.40.1\",\n )\n\n assert status.Status == 0x0110\n assert ds is None\n\n assoc.release()\n scp.shutdown()","async def test_setup_failed_connect(\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\n) -> None:\n respx.get(\"http://localhost\").mock(\n side_effect=httpx.RequestError(\"server offline\", request=MagicMock())\n )\n assert await async_setup_component(\n hass,\n SENSOR_DOMAIN,\n {\n SENSOR_DOMAIN: {\n \"platform\": DOMAIN,\n \"resource\": \"http://localhost\",\n \"method\": \"GET\",\n }\n },\n )\n await hass.async_block_till_done()\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\n assert \"server offline\" in caplog.text","def test_protocolShutDownAfterFailure(self):\n class ExpectedException(Exception):\n pass\n\n resolver = client.Resolver(servers=[('example.com', 53)])\n protocols = []\n result = defer.Deferred()\n\n class FakeProtocol(object):\n def __init__(self):\n self.transport = StubPort()\n\n def query(self, address, query, timeout=10, id=None):\n protocols.append(self)\n return result\n\n resolver._connectedProtocol = FakeProtocol\n queryResult = resolver.query(dns.Query('foo.example.com'))\n\n self.assertFalse(protocols[0].transport.disconnected)\n result.errback(failure.Failure(ExpectedException()))\n self.assertTrue(protocols[0].transport.disconnected)\n\n return self.assertFailure(queryResult, ExpectedException)","def test_disconnect_multiple(self):\n self.inverter.disconnect()\n self.inverter.disconnect() # Should not raise exception","def inner_test(param: enums.DisconnectReason):\n pass","def errConnectionLost(self):\n self.logger('stderr closed by process %d' % self._pid)","def test_startconnector_with_noretry_on_con_failure(self):\n\n yield self.connect('127.0.0.1', self.pbPort)\n\n localConfig = copy.copy(self.defaultConfig)\n localConfig.reconnectOnConnectionFailure = False\n yield self.add(localConfig)\n yield self.start(localConfig.id)\n\n # It takes a moment to stop the service after a connection failure\n while True:\n ssRet = yield self.service_status(localConfig.id)\n if ssRet != 1:\n break;\n else:\n time.sleep(1)\n\n self.assertEqual(0, ssRet)\n\n yield self.stop(localConfig.id)","def test_shutdown_wrong_args(self):\n connection = Connection(Context(SSLv23_METHOD), None)\n with pytest.raises(TypeError):\n connection.set_shutdown(None)","def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:","def test_send_event_raises():\n send_event('pytest-reportportal', '5.0.5')","def connection_failed(self, connection, error):\n assert False","def test_has_receivers(error_report_mock):\n\n app_crash()\n error_report_mock.assert_not_called()\n\n signal('panic').connect(triage)\n app_crash()\n error_report_mock.assert_called_with()","def testFeaturesError(self):\n\n def _testError(res):\n self.assertEqual(True,res[1][0].name=='challenge','Did not get correct challenge stanza')\n\n def _testSessionCreate(res):\n self.sid = res[0]['sid']\n # this xml is valid, just for testing\n # the point is to wait for a stream error\n self.assertEqual(True,res[1][0].name=='features','Did not get initial features')\n\n d = self.send(\"<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='DIGEST-MD5'/>\")\n d.addCallback(_testError)\n reactor.callLater(1.1, self.server_protocol.triggerChallenge)\n return d\n\n BOSH_XML = \"\"\"<body content='text/xml; charset=utf-8'\n hold='1'\n rid='%(rid)i'\n to='localhost'\n route='xmpp:127.0.0.1:%(server_port)i'\n ver='1.6'\n wait='15'\n ack='1'\n xml:lang='en'\n xmlns='http://jabber.org/protocol/httpbind'/>\n \"\"\"% { \"rid\": self.rid, \"server_port\": self.server_port }\n self.server_factory.protocol.delay_features = 3\n\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\n # NOTE : to trigger this bug there needs to be 0 waiting requests.\n\n return d","async def test_flow_link_cannot_connect(hass: HomeAssistant) -> None:\n disc_bridge = get_discovered_bridge()\n with patch(\n \"homeassistant.components.hue.config_flow.discover_nupnp\",\n return_value=[disc_bridge],\n ):\n result = await hass.config_entries.flow.async_init(\n const.DOMAIN, context={\"source\": config_entries.SOURCE_USER}\n )\n\n with patch.object(config_flow, \"create_app_key\", side_effect=CannotConnect):\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input={\"id\": disc_bridge.id}\n )\n\n result = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"], user_input={}\n )\n\n assert result[\"type\"] == \"abort\"\n assert result[\"reason\"] == \"cannot_connect\"","def test_unexpected_EOF(self):\n server_conn, client_conn = loopback()\n client_conn.sock_shutdown(SHUT_RDWR)\n with pytest.raises(SysCallError) as err:\n server_conn.recv(1024)\n if platform == \"win32\":\n assert err.value.args == (10054, \"WSAECONNRESET\")\n else:\n assert err.value.args == (-1, \"Unexpected EOF\")","def test_plugin_connected_hook(node_factory):\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\n l1.rpc.reject(l3.info['id'])\n\n l2.connect(l1)\n l1.daemon.wait_for_log(r\"{} is allowed\".format(l2.info['id']))\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\n\n l3.connect(l1)\n l1.daemon.wait_for_log(r\"{} is in reject list\".format(l3.info['id']))\n\n # FIXME: this error occurs *after* connection, so we connect then drop.\n l3.daemon.wait_for_log(r\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\"\n .format(l1.info['id']))\n l3.daemon.wait_for_log(r\"You are in reject list\")\n\n def check_disconnect():\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\n return peers == [] or not peers[0]['connected']\n\n wait_for(check_disconnect)","async def test_connection_error(\n hass: HomeAssistant, init_integration, mock_auth, mock_config_entry\n) -> None:\n\n install = AsyncMock()\n install.arm = AsyncMock(return_value=False)\n install.arm_partially = AsyncMock(return_value=True)\n install.disarm = AsyncMock(return_value=True)\n install.status = Status.ARMED\n\n with patch(\"pyprosegur.installation.Installation.retrieve\", return_value=install):\n await hass.async_block_till_done()\n\n with patch(\n \"pyprosegur.installation.Installation.retrieve\", side_effect=ConnectionError\n ):\n await entity_component.async_update_entity(hass, PROSEGUR_ALARM_ENTITY)\n\n state = hass.states.get(PROSEGUR_ALARM_ENTITY)\n assert state.state == STATE_UNAVAILABLE","def test_exception_with_callback(self):\n test_utils.generate_test_config_file()\n\n exception_callback = mock.Mock()\n\n client = PowerTrackClient(_dummy_callback, exception_callback,\n config_file_path=config_file)\n client.connect()\n client.disconnect()\n self.assertTrue(exception_callback.called)\n actual_exinfo = exception_callback.call_args[0][0]\n actual_ex = actual_exinfo[1]\n self.assertIsInstance(actual_ex, Exception)\n self.assertEqual(actual_ex.message, \"This is a test exception\")","async def test_button_connection_error(\n hass: HomeAssistant,\n mock_lametric: MagicMock,\n) -> None:\n mock_lametric.app_next.side_effect = LaMetricConnectionError\n\n with pytest.raises(\n HomeAssistantError, match=\"Error communicating with the LaMetric device\"\n ):\n await hass.services.async_call(\n BUTTON_DOMAIN,\n SERVICE_PRESS,\n {ATTR_ENTITY_ID: \"button.frenck_s_lametric_next_app\"},\n blocking=True,\n )\n await hass.async_block_till_done()\n\n state = hass.states.get(\"button.frenck_s_lametric_next_app\")\n assert state\n assert state.state == STATE_UNAVAILABLE","def error(self, *args):\n\n self.log(\"ERROR:\", args)\n if not self.transport.connected:\n Timer(5, connect(self.host, self.port)).register(self)","def testConnectionLost(self):\n d = self.testSimpleRequest()\n d.addCallback(lambda _: self.factory.crash())\n d.addCallback(lambda _: self.client.check_rate_limit())\n d.addTimeout(0.01, reactor)\n self.assertFailure(d, ConnectionClosed)\n return d","def test_exception_raised_with_a_dlq():\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\n dlq: missive.DLQ = {}\n proc.set_dlq(dlq)\n\n @proc.handle_for(always)\n def crash(message, ctx):\n raise RuntimeError(\"bad bytes!\")\n\n with proc.test_client() as test_client:\n blank_message = missive.RawMessage(b\"\")\n test_client.send(blank_message)\n assert dlq == {blank_message.message_id: (blank_message, \"bad bytes!\")}\n assert blank_message in test_client.acked","def test_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as err:\n server.sendall(b\"hello, world\")\n if platform == \"win32\":\n assert err.value.args[0] == ESHUTDOWN\n else:\n assert err.value.args[0] == EPIPE","def testRemoteError(self):\n\n def _testStreamError(res):\n self.assertEqual(True, isinstance(res.value, httpb_client.HTTPBNetworkTerminated))\n\n self.assertEqual(True, res.value.body_tag.hasAttribute('condition'), 'No attribute condition')\n # This is not a stream error because we sent invalid xml\n self.assertEqual(res.value.body_tag['condition'], 'remote-stream-error')\n self.assertEqual(True, len(res.value.elements)>0)\n # The XML should exactly match the error XML sent by triggerStreamError().\n self.assertEqual(True,xpath.XPathQuery(\"/error\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/policy-violation\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/arbitrary-extension\").matches(res.value.elements[0]))\n self.assertEqual(True,xpath.XPathQuery(\"/error/text[text() = 'Error text']\").matches(res.value.elements[0]))\n\n\n\n def _failStreamError(res):\n self.fail('A stream error needs to be returned')\n\n def _testSessionCreate(res):\n self.sid = res[0]['sid']\n # this xml is valid, just for testing\n # the point is to wait for a stream error\n d = self.send('<fdsfd/>')\n d.addCallback(_failStreamError)\n d.addErrback(_testStreamError)\n self.server_protocol.triggerStreamError()\n\n return d\n\n BOSH_XML = \"\"\"<body content='text/xml; charset=utf-8'\n hold='1'\n rid='%(rid)i'\n to='localhost'\n route='xmpp:127.0.0.1:%(server_port)i'\n ver='1.6'\n wait='60'\n ack='1'\n xml:lang='en'\n xmlns='http://jabber.org/protocol/httpbind'/>\n \"\"\"% { \"rid\": self.rid, \"server_port\": self.server_port }\n\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\n\n return d","def _connect_failed(self):\n\t\tself.root.stdout.write(\"Error: Connection Failed!\\n\")\n\t\tself.client = False","def test_listen_error(self):\n listen_port = self.get_port()\n config = Qdrouterd.Config([\n ('router', {'mode': 'standalone', 'id': 'bad'}),\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\n ('listener', {'port': listen_port, 'http':True})])\n r = Qdrouterd(name=\"expect_fail\", config=config, wait=False);\n self.assertEqual(1, r.wait())","def test_exceptions_in_client_bubble_up(self):\n\n class SentinelException(Exception):\n pass\n\n def server_callback(*args):\n return self.sample_ocsp_data\n\n def client_callback(*args):\n raise SentinelException()\n\n client = self._client_connection(callback=client_callback, data=None)\n server = self._server_connection(callback=server_callback, data=None)\n\n with pytest.raises(SentinelException):\n handshake_in_memory(client, server)","def unhandled_error(self, error):\n # TODO(mpetazzoni): ws4py >= 0.3.5 only?\n _logger.debug('WebSocket error: %s; will reconnect.', error)","def test_not_running(): # pragma: windows\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)","def test_rsp_failure(self):\n\n def handle(event):\n return 0x0112, None\n\n self.ae = ae = AE()\n ae.acse_timeout = 5\n ae.dimse_timeout = 5\n ae.network_timeout = 5\n ae.add_supported_context(ProceduralEventLogging)\n scp = ae.start_server(\n (\"localhost\", 11112), block=False, evt_handlers=[(evt.EVT_N_ACTION, handle)]\n )\n\n ae.add_requested_context(ProceduralEventLogging)\n assoc = ae.associate(\"localhost\", 11112)\n assert assoc.is_established\n\n ds = Dataset()\n ds.PatientName = \"Test^test\"\n status, ds = assoc.send_n_action(\n ds, 1, ProceduralEventLogging, \"1.2.840.10008.5.1.1.40.1\"\n )\n assert status.Status == 0x0112\n assert ds is None\n assoc.release()\n assert assoc.is_released\n\n scp.shutdown()","def on_disconnect(unused_client, unused_userdata, rc):\n print(f\"on_disconnect: {error_str(rc)}\")\n print()\n\n global connected\n connected = False","async def test_setup_failed_error(hass: HomeAssistant, ufp: MockUFPFixture) -> None:\n\n ufp.api.get_nvr = AsyncMock(side_effect=NvrError)\n\n await hass.config_entries.async_setup(ufp.entry.entry_id)\n await hass.async_block_till_done()\n assert ufp.entry.state == ConfigEntryState.SETUP_RETRY\n assert not ufp.api.update.called","async def test_discovered_by_dhcp_connection_fails(\n hass: HomeAssistant, source, data\n) -> None:\n with patch(\n \"homeassistant.components.wiz.wizlight.getBulbConfig\",\n side_effect=WizLightTimeOutError,\n ):\n result = await hass.config_entries.flow.async_init(\n DOMAIN, context={\"source\": source}, data=data\n )\n await hass.async_block_till_done()\n\n assert result[\"type\"] == FlowResultType.ABORT\n assert result[\"reason\"] == \"cannot_connect\"","def test_signal_interruption(self):\n process = Popen(\n [STRATIS_CLI, \"pool\", \"create\",\n p_n(), DISKS[0]],\n stdout=PIPE,\n stderr=PIPE,\n close_fds=True,\n env=os.environ)\n time.sleep(0.05)\n process.send_signal(2)\n result = process.communicate()\n stdout_text = \"\"\n stderr_text = \"\"\n if result[0]:\n stdout_text = bytes(result[0]).decode(\"utf-8\")\n if result[1]:\n stderr_text = bytes(result[1]).decode(\"utf-8\")\n\n self.assertTrue(\"Traceback\" not in stdout_text)\n self.assertTrue(\"Traceback\" not in stderr_text)\n self.assertNotEqual(process.returncode, 0)","def test_pause_not_listening(testchannel):\n with testchannel.open():\n with pytest.raises(NotListeningError):\n testchannel.pause()","async def test_child_crash_propagation():\n looper_cancelled = False\n\n async def looper():\n nonlocal looper_cancelled\n try:\n while True:\n await asyncio.sleep(0)\n except asyncio.CancelledError:\n looper_cancelled = True\n\n error = ValueError('crashed')\n\n async def crasher():\n raise error\n\n with pytest.raises(ValueError) as excinfo:\n async with Nursery() as nursery:\n nursery.start_soon(looper())\n nursery.start_soon(crasher())\n\n assert looper_cancelled\n assert excinfo.value is error","def connection_lost(self, exc: Optional[Exception]) -> None:\n if exc:\n logger.critical(f\"udp bridge lost its connection {exc}\")\n else:\n logger.info(\"udp connection stopped\")","async def test_startup_errors_should_halt_ready():\n network = Network()\n network.set_config(url=\"http://nowhere.at.all.localdomain:6865/\", connect_timeout=1)\n\n client = network.aio_party(\"SillyParty\")\n\n # place the ready() call BEFORE the run\n f = ensure_future(wait_for(client.ready(), 2))\n\n try:\n await network.aio_run(keep_open=False)\n except Exception:\n pass\n\n try:\n await f\n raise AssertionError(\n \"client.ready() should not have ended because there is nothing to connect to\"\n )\n except asyncio.TimeoutError:\n raise AssertionError(\n \"client.ready() did not abort with an appropriate exception and was killed because \"\n \"it was taking too long\"\n )\n except CancelledError:\n LOG.info(\"Successfully terminated because ready() was cancelled.\")","def test_shutdown_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as exc:\n server.shutdown()\n if platform == \"win32\":\n assert exc.value.args[0] == ESHUTDOWN\n else:\n assert exc.value.args[0] == EPIPE","def test_can_not_handle_brew_container_task_failed_event(self):\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\n self.assertFalse(self.handler.can_handle(event))","def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\n\n engine = ping_fixture_all_errs_disconnect\n\n conn = engine.connect()\n conn.close()","def _connectPrepError(self, failure, authenticator):\r\n authenticator.cancel()\r\n return failure","async def test_discovery_cannot_connect(hass: HomeAssistant) -> None:\n\n result = await hass.config_entries.flow.async_init(\n DOMAIN, context={\"source\": config_entries.SOURCE_ZEROCONF}, data=TEST_DISCOVERY\n )\n\n with patch(\n \"homeassistant.components.volumio.config_flow.Volumio.get_system_info\",\n side_effect=CannotConnectError,\n ):\n result2 = await hass.config_entries.flow.async_configure(\n result[\"flow_id\"],\n user_input={},\n )\n\n assert result2[\"type\"] == \"abort\"\n assert result2[\"reason\"] == \"cannot_connect\"","def test_that_error_callback_is_not_invoked_on_no_error(self, request):\n error = False\n\n def on_error(_):\n nonlocal error\n error = True\n\n response = requests.Response()\n response.status_code = 200\n request.return_value = response\n r = rx_request('get', 'url')\n\n r.subscribe(on_error=on_error)\n\n self.assertFalse(error)","def test_error(self, mock_validate_session):\n mock_validate_session.return_value = False\n with pytest.raises(SystemExit) as ctx:\n celery_command.worker(Namespace(queues=1, concurrency=1))\n assert str(ctx.value) == \"Worker exiting, database connection precheck failed.\"","def on_connection_error(self):\n log.error(\"Stream connection has errored or timed out\")","def on_connection_open_error(self, _unused_connection, err):\n # LOGGER.error('Connection open failed: %s', err)\n self.reconnect()","async def test_disconnected_server_raises_on_data_write(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESS\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def test_connect_error():\n queue = RedisQueue('localhost')\n assert not queue.is_connected\n with pytest.raises(ConnectionError):\n queue.put('test')\n with pytest.raises(ConnectionError):\n queue.get()","def unknown_event(self, event):\r\n pass","def test_loginException(self):\n\n class UnexpectedException(Exception):\n \"\"\"\n An unexpected exception.\n \"\"\"\n\n def raisesUnexpectedException(user, passwd):\n raise UnexpectedException(\"Whoops\")\n\n self.server.authenticateLogin = raisesUnexpectedException\n\n def login():\n return self.client.login(b'testuser', b'password-test')\n\n d1 = self.connected.addCallback(strip(login))\n\n d1.addErrback(self.assertClientFailureMessage, b\"Server error: Whoops\")\n\n @d1.addCallback\n def assertErrorLogged(_):\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\n\n d1.addErrback(self._ebGeneral)\n d1.addBoth(self._cbStopClient)\n\n d2 = self.loopback()\n d = defer.gatherResults([d1, d2])\n return d.addCallback(self._cbTestFailedLogin)","def test_original_failure_not_error(self):\n dr = EventualResult(succeed(3), None)\n self.assertIdentical(dr.original_failure(), None)","def state_failsafe_validate(cfg, app, win, events):","def onentererror(self, event):\n print('onentererror; event: %s, %s->%s' % (event.event, event.src, event.dst))","def test_sandbox_errors_true(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\n sandbox_errors=True)\n\n self.assertEqual(len(self._on_signal_exception.calls), 0)\n self.signal.send(self)\n self.assertEqual(len(self._on_signal_exception.calls), 1)","def test_scp_callback_exception(self):\n self.scp = DummyVerificationSCP()\n def on_c_echo(context, info):\n raise ValueError\n self.scp.ae.on_c_echo = on_c_echo\n self.scp.start()\n\n ae = AE()\n ae.add_requested_context(VerificationSOPClass)\n assoc = ae.associate('localhost', 11112)\n assert assoc.is_established\n rsp = assoc.send_c_echo()\n assert rsp.Status == 0x0000\n assoc.release()\n self.scp.stop()","def _on_catastrophic_disconnect(self, channel_id: str) -> None:\n logger.error(f\"Channel {channel_id} called on_catastrophic_disconnect\")\n\n live_run = self.get_live_run()\n live_run.force_shutdown = True","async def test_options_flow_network_failure(hass):\n\n entry = await setup_platform(hass)\n\n with patch(\n \"aussiebb.asyncio.AussieBB.get_services\", side_effect=ClientConnectionError()\n ):\n\n result1 = await hass.config_entries.options.async_init(entry.entry_id)\n assert result1[\"type\"] == RESULT_TYPE_ABORT\n assert result1[\"reason\"] == \"cannot_connect\"","def test_error_bubbles_up(self):\n\n def fail(box):\n box.fail(ValueError(\"oh dear\"))\n\n self.assertThat(\n lambda: sync_perform(func_dispatcher, Effect(fail)),\n raises(ValueError(\"oh dear\")),\n )","def on_disconnect(unused_client, unused_userdata, rc):\n\tprint('on_disconnect', error_str(rc))\n\n\t# Since a disconnect occurred, the next loop iteration will wait with\n\t# exponential backoff.\n\tglobal should_backoff\n\tshould_backoff = True","def connection_lost(self, exc):\n pass","def test_run_without_message(connection, events, loop):\n loop.run_until_complete(connection.run())\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")","def test_cond_with_uncaught_error(env):\n def explode(env, delay):\n yield env.timeout(delay)\n raise ValueError(f'Onoes, failed after {delay}!')\n\n def process(env):\n yield env.timeout(1) | env.process(explode(env, 2))\n\n env.process(process(env))\n try:\n env.run()\n assert False, 'There should have been an exception.'\n except ValueError:\n pass\n assert env.now == 2","def test_disconnect_from_client_side(\n start_result_q_publisher, start_result_q_subscriber\n):\n\n result_pub = start_result_q_publisher()\n f = result_pub.publish(b\"Hello test_disconnect_from_client_side 1\")\n assert f.result(timeout=1) is None\n\n result_pub.stop()\n\n try_assert(lambda: not result_pub.is_alive(), \"Verify test setup\")\n with pytest.raises(ValueError):\n result_pub.publish(b\"Hello test_disconnect_from_client_side 2\")","def test_invalid_signal(self):\n mediator = Mediator()\n\n try:\n mediator.signal(\"foo\")\n except:\n raise AssertionError()","async def test_disconnected_server_raises_on_data_read(preset_client):\n await preset_client.connect()\n\n preset_client.server.responses.append(b\"250 Hello there\")\n await preset_client.ehlo()\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.mail(\"sender@example.com\")\n\n preset_client.server.responses.append(b\"250 ok\")\n await preset_client.rcpt(\"recipient@example.com\")\n\n preset_client.server.responses.append(b\"354 lets go\")\n preset_client.server.drop_connection_after_request = b\"A MESSAGE\\r\\n.\\r\\n\"\n\n with pytest.raises(SMTPServerDisconnected):\n await preset_client.data(\"A MESSAGE\")\n\n # Verify that the connection was closed\n assert not preset_client._connect_lock.locked()\n assert preset_client.protocol is None\n assert preset_client.transport is None","def clientConnectionFailed(self, connector, reason):\n\n print(\"Connection failed\") # client console notification\n reactor.callFromThread(reactor.stop) # reactor shutdown","def exit_failure():\n\tglobal state\n\tglobal c1, c2\n\tglobal a1, a2\n\n\t# Tell clients to close connections\n\tc1.send(\"CLOSE\")\n\tc2.send(\"CLOSE\")\n\n\tprint \"EXIT FAILURE\"\n\tstate += 1 # increment state to 10","def test_fail_must_login(self):\n guest_obj = self._check_init()\n msg = 'You need to login first'\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.hotplug(vols=[dict()])\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.install_packages([])\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\n with self.assertRaisesRegex(RuntimeError, msg):\n guest_obj.push_file('source_url', 'target_path')\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)","def test_failure_result(self):\n dr = EventualResult(fail(RuntimeError()), None)\n self.assertRaises(RuntimeError, dr.wait, 0.1)","def test_silent_write_errors():\n\n tracker = pawprint.Tracker(db=None, table=None)\n\n try:\n tracker.write(event=\"This will fail silently.\")\n except Exception:\n pytest.fail(\"Failed to fail silently.\")","def test_shutdown(self):\n server = self._server(None)\n server.bio_shutdown()\n with pytest.raises(Error) as err:\n server.recv(1024)\n # We don't want WantReadError or ZeroReturnError or anything - it's a\n # handshake failure.\n assert type(err.value) in [Error, SysCallError]","async def test_flow_ssdp_bad_discovery(opp, aioclient_mock):\n result = await opp.config_entries.flow.async_init(\n DECONZ_DOMAIN,\n data={ATTR_UPNP_MANUFACTURER_URL: \"other\"},\n context={\"source\": SOURCE_SSDP},\n )\n\n assert result[\"type\"] == RESULT_TYPE_ABORT\n assert result[\"reason\"] == \"not_deconz_bridge\""],"string":"[\n \"def test_event_handler_didnt_downgrade_disconnect(\\n self, ping_fixture_all_errs_disconnect\\n ):\\n engine = ping_fixture_all_errs_disconnect\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n assert ctx.is_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert not ctx.is_disconnect\\n\\n with expect_raises_message(\\n exc.DBAPIError, \\\"unhandled disconnect situation\\\"\\n ):\\n engine.connect()\",\n \"def test_event_handler_can_upgrade_disconnect(self, ping_fixture):\\n\\n engine = ping_fixture\\n\\n @event.listens_for(engine, \\\"handle_error\\\")\\n def setup_disconnect(ctx):\\n assert ctx.is_pre_ping\\n ctx.is_disconnect = True\\n\\n conn = engine.connect()\\n # no error\\n conn.close()\",\n \"def on_init_fail(self, event_time, message):\\n pass\",\n \"def test_verify_state_of_a_device_when_disconnected_from_the_device():\",\n \"def onConnectError(self, fetcher, error): #$NON-NLS-1$\\r\",\n \"def connectionLost(reason):\",\n \"def state_failsafe_do(cfg, app, win, events):\",\n \"async def test_on_connect_failed(hass: HomeAssistant, side_effect, error) -> None:\\n flow_result = await hass.config_entries.flow.async_init(\\n DOMAIN,\\n context={\\\"source\\\": SOURCE_USER, \\\"show_advanced_options\\\": True},\\n )\\n\\n with PATCH_GET_HOST, patch(\\n \\\"homeassistant.components.asuswrt.bridge.AsusWrtLegacy\\\"\\n ) as asus_wrt:\\n asus_wrt.return_value.connection.async_connect = AsyncMock(\\n side_effect=side_effect\\n )\\n asus_wrt.return_value.async_get_nvram = AsyncMock(return_value={})\\n asus_wrt.return_value.is_connected = False\\n\\n result = await hass.config_entries.flow.async_configure(\\n flow_result[\\\"flow_id\\\"], user_input=CONFIG_DATA\\n )\\n assert result[\\\"type\\\"] == data_entry_flow.FlowResultType.FORM\\n assert result[\\\"errors\\\"] == {\\\"base\\\": error}\",\n \"def _cb_ignore_listen_exception(self, exception, server):\\n if isinstance(exception, ssl.SSLError):\\n # A client which couldn’t verify the server tried to connect, continue but log the event\\n if exception.errqueue[-1][0] == ssl.ERR_TLSV1_ALERT_UNKNOWN_CA:\\n #print(\\\"Ignoring ERR_TLSV1_ALERT_UNKNOWN_CA from client %s\\\" %\\n # (’unknown’ if not hasattr(exception, ’peer’) else str(exception.peer)))\\n return True\\n # ... and more ...\\n return False\",\n \"def whenException(self, channel, call):\",\n \"def test_parse_message_failure_connect(self):\\n for test_case in self.failure_test_params_wrong_connect:\\n expected = test_case[KEY_EXPECTED]\\n mock_connect = app.on_connect()\\n\\n self.assertNotEqual(expected, mock_connect)\",\n \"async def test_connection_error(hass: HomeAssistant, conn_error) -> None:\\n\\n result = await hass.config_entries.flow.async_init(\\n DOMAIN, context={\\\"source\\\": config_entries.SOURCE_USER}\\n )\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input=DEMO_USER_INPUT\\n )\\n assert result[\\\"type\\\"] == data_entry_flow.FlowResultType.FORM\\n assert result[\\\"errors\\\"] == {\\\"base\\\": \\\"cannot_connect\\\"}\",\n \"def connectFailed(self, reason):\\n\\t\\tself._tunnelReadyDeferred.errback(reason)\",\n \"async def test_warn_when_cannot_connect(opp, caplog):\\n with patch.dict(os.environ, MOCK_ENVIRON), patch(\\n \\\"openpeerpower.components.oppio.OppIO.is_connected\\\",\\n return_value=None,\\n ):\\n result = await async_setup_component(opp, \\\"oppio\\\", {})\\n assert result\\n\\n assert opp.components.oppio.is_oppio()\\n assert \\\"Not connected with Opp.io / system too busy!\\\" in caplog.text\",\n \"def test_exception_raised_no_dlq():\\n\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n with pytest.raises(RuntimeError):\\n test_client.send(blank_message)\",\n \"def test_parse_message_failure_disconnect(self, mock_disconnect):\\n for test_case in self.failure_test_params_disconnect:\\n expected = test_case[KEY_EXPECTED]\\n mock_disconnect = app.on_disconnect()\\n self.assertNotEqual(expected, mock_disconnect)\",\n \"async def test_client_connection_error(hass: HomeAssistant, mock_daikin) -> None:\\n config_entry = MockConfigEntry(\\n domain=DOMAIN,\\n unique_id=MAC,\\n data={CONF_HOST: HOST, KEY_MAC: MAC},\\n )\\n config_entry.add_to_hass(hass)\\n\\n mock_daikin.factory.side_effect = ClientConnectionError\\n await hass.config_entries.async_setup(config_entry.entry_id)\\n await hass.async_block_till_done()\\n\\n assert config_entry.state == ConfigEntryState.SETUP_RETRY\",\n \"def test_sandbox_errors_false(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=False)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.assertRaises(Exception, self.signal.send, self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def test_disconnect_before_connect(connection, events, schedule, flush):\\n schedule(connection.disconnect())\\n flush()\\n assert not connection.connected\\n assert not events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert not events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_already_disconnected(connection, events, schedule, flush):\\n schedule(connection.connect(),\\n connection.disconnect(),\\n connection.disconnect())\\n flush()\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def onleaveerror(self, event):\\n #print(self.config)\\n #try:\\n # self.mqttclient.publish(self.config['MQTT']['TOPICBASE'] + '/fsm/state', e.src + '->' + e.dst)\\n # self.mqttclient.disconnect()\\n # self.network.disconnect()\\n #except:\\n # pass\\n print('onleaveerror; event: %s, %s->%s' % (event.event, event.src, event.dst))\",\n \"def onError(self, connection:MQTTConnection, rc:int) -> bool:\\n\\t\\treturn True\",\n \"def test_exceptions_in_server_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n raise SentinelException()\\n\\n def client_callback(*args): # pragma: nocover\\n pytest.fail(\\\"Should not be called\\\")\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def test_exception(self):\\n\\n sink = TObserver(immediate_continue=0)\\n self.obs.observe(init_observer_info(sink))\\n ack1 = self.left.on_next_list([select_completed])\\n\\n self.right.on_error(self.exception)\\n\\n self.assertIsInstance(self.measure_state(self.obs), ControlledZipStates.Stopped)\\n self.assertEqual(self.exception, sink.exception)\",\n \"def test_invalid_disconnect(self):\\n mediator = Mediator()\\n try:\\n mediator.disconnect(\\\"foo\\\", self.dog.set_sound)\\n mediator.disconnect(\\\"bar\\\", self.cat.set_sound)\\n except:\\n raise AssertionError()\",\n \"def failIfNotConnected(self, err):\\n if (self.connected or self.disconnected or\\n not hasattr(self, \\\"connector\\\")):\\n return\\n\\n self.connector.connectionFailed(failure.Failure(err))\\n del self.connector\\n self.connectionFailedDefer.callback(1)\",\n \"def test_decode_failure(self):\\n\\n def handle(event):\\n def test():\\n pass\\n\\n return 0x0000, test\\n\\n self.ae = ae = AE()\\n ae.add_requested_context(\\n ModalityPerformedProcedureStepNotification, ExplicitVRLittleEndian\\n )\\n ae.add_supported_context(ModalityPerformedProcedureStepNotification)\\n\\n handlers = [(evt.EVT_N_EVENT_REPORT, handle)]\\n scp = ae.start_server((\\\"localhost\\\", 11112), evt_handlers=handlers, block=False)\\n\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n\\n class DummyReply:\\n def getvalue(self):\\n def test():\\n pass\\n\\n return test\\n\\n class DummyMessage:\\n is_valid_response = True\\n EventReply = DummyReply()\\n Status = 0x0000\\n STATUS_OPTIONAL_KEYWORDS = []\\n\\n class DummyDIMSE:\\n msg_queue = queue.Queue()\\n gotten = False\\n\\n def send_msg(*args, **kwargs):\\n return\\n\\n def get_msg(self, *args, **kwargs):\\n if not self.gotten:\\n self.gotten = True\\n return 1, DummyMessage()\\n return None, None\\n\\n assoc._reactor_checkpoint.clear()\\n while not assoc._is_paused:\\n time.sleep(0.01)\\n assoc.dimse = DummyDIMSE()\\n assert assoc.is_established\\n\\n # Event Information\\n ds = Dataset()\\n ds.PatientName = \\\"Test^test\\\"\\n status, ds = assoc.send_n_event_report(\\n ds,\\n 1,\\n ModalityPerformedProcedureStepNotification,\\n \\\"1.2.840.10008.5.1.1.40.1\\\",\\n )\\n\\n assert status.Status == 0x0110\\n assert ds is None\\n\\n assoc.release()\\n scp.shutdown()\",\n \"async def test_setup_failed_connect(\\n hass: HomeAssistant, caplog: pytest.LogCaptureFixture\\n) -> None:\\n respx.get(\\\"http://localhost\\\").mock(\\n side_effect=httpx.RequestError(\\\"server offline\\\", request=MagicMock())\\n )\\n assert await async_setup_component(\\n hass,\\n SENSOR_DOMAIN,\\n {\\n SENSOR_DOMAIN: {\\n \\\"platform\\\": DOMAIN,\\n \\\"resource\\\": \\\"http://localhost\\\",\\n \\\"method\\\": \\\"GET\\\",\\n }\\n },\\n )\\n await hass.async_block_till_done()\\n assert len(hass.states.async_all(SENSOR_DOMAIN)) == 0\\n assert \\\"server offline\\\" in caplog.text\",\n \"def test_protocolShutDownAfterFailure(self):\\n class ExpectedException(Exception):\\n pass\\n\\n resolver = client.Resolver(servers=[('example.com', 53)])\\n protocols = []\\n result = defer.Deferred()\\n\\n class FakeProtocol(object):\\n def __init__(self):\\n self.transport = StubPort()\\n\\n def query(self, address, query, timeout=10, id=None):\\n protocols.append(self)\\n return result\\n\\n resolver._connectedProtocol = FakeProtocol\\n queryResult = resolver.query(dns.Query('foo.example.com'))\\n\\n self.assertFalse(protocols[0].transport.disconnected)\\n result.errback(failure.Failure(ExpectedException()))\\n self.assertTrue(protocols[0].transport.disconnected)\\n\\n return self.assertFailure(queryResult, ExpectedException)\",\n \"def test_disconnect_multiple(self):\\n self.inverter.disconnect()\\n self.inverter.disconnect() # Should not raise exception\",\n \"def inner_test(param: enums.DisconnectReason):\\n pass\",\n \"def errConnectionLost(self):\\n self.logger('stderr closed by process %d' % self._pid)\",\n \"def test_startconnector_with_noretry_on_con_failure(self):\\n\\n yield self.connect('127.0.0.1', self.pbPort)\\n\\n localConfig = copy.copy(self.defaultConfig)\\n localConfig.reconnectOnConnectionFailure = False\\n yield self.add(localConfig)\\n yield self.start(localConfig.id)\\n\\n # It takes a moment to stop the service after a connection failure\\n while True:\\n ssRet = yield self.service_status(localConfig.id)\\n if ssRet != 1:\\n break;\\n else:\\n time.sleep(1)\\n\\n self.assertEqual(0, ssRet)\\n\\n yield self.stop(localConfig.id)\",\n \"def test_shutdown_wrong_args(self):\\n connection = Connection(Context(SSLv23_METHOD), None)\\n with pytest.raises(TypeError):\\n connection.set_shutdown(None)\",\n \"def failure(self, cb: CircuitBreaker, exc: BaseException) -> None:\",\n \"def test_send_event_raises():\\n send_event('pytest-reportportal', '5.0.5')\",\n \"def connection_failed(self, connection, error):\\n assert False\",\n \"def test_has_receivers(error_report_mock):\\n\\n app_crash()\\n error_report_mock.assert_not_called()\\n\\n signal('panic').connect(triage)\\n app_crash()\\n error_report_mock.assert_called_with()\",\n \"def testFeaturesError(self):\\n\\n def _testError(res):\\n self.assertEqual(True,res[1][0].name=='challenge','Did not get correct challenge stanza')\\n\\n def _testSessionCreate(res):\\n self.sid = res[0]['sid']\\n # this xml is valid, just for testing\\n # the point is to wait for a stream error\\n self.assertEqual(True,res[1][0].name=='features','Did not get initial features')\\n\\n d = self.send(\\\"<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='DIGEST-MD5'/>\\\")\\n d.addCallback(_testError)\\n reactor.callLater(1.1, self.server_protocol.triggerChallenge)\\n return d\\n\\n BOSH_XML = \\\"\\\"\\\"<body content='text/xml; charset=utf-8'\\n hold='1'\\n rid='%(rid)i'\\n to='localhost'\\n route='xmpp:127.0.0.1:%(server_port)i'\\n ver='1.6'\\n wait='15'\\n ack='1'\\n xml:lang='en'\\n xmlns='http://jabber.org/protocol/httpbind'/>\\n \\\"\\\"\\\"% { \\\"rid\\\": self.rid, \\\"server_port\\\": self.server_port }\\n self.server_factory.protocol.delay_features = 3\\n\\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\\n # NOTE : to trigger this bug there needs to be 0 waiting requests.\\n\\n return d\",\n \"async def test_flow_link_cannot_connect(hass: HomeAssistant) -> None:\\n disc_bridge = get_discovered_bridge()\\n with patch(\\n \\\"homeassistant.components.hue.config_flow.discover_nupnp\\\",\\n return_value=[disc_bridge],\\n ):\\n result = await hass.config_entries.flow.async_init(\\n const.DOMAIN, context={\\\"source\\\": config_entries.SOURCE_USER}\\n )\\n\\n with patch.object(config_flow, \\\"create_app_key\\\", side_effect=CannotConnect):\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input={\\\"id\\\": disc_bridge.id}\\n )\\n\\n result = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"], user_input={}\\n )\\n\\n assert result[\\\"type\\\"] == \\\"abort\\\"\\n assert result[\\\"reason\\\"] == \\\"cannot_connect\\\"\",\n \"def test_unexpected_EOF(self):\\n server_conn, client_conn = loopback()\\n client_conn.sock_shutdown(SHUT_RDWR)\\n with pytest.raises(SysCallError) as err:\\n server_conn.recv(1024)\\n if platform == \\\"win32\\\":\\n assert err.value.args == (10054, \\\"WSAECONNRESET\\\")\\n else:\\n assert err.value.args == (-1, \\\"Unexpected EOF\\\")\",\n \"def test_plugin_connected_hook(node_factory):\\n opts = [{'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject.py')}, {}, {}]\\n l1, l2, l3 = node_factory.get_nodes(3, opts=opts)\\n l1.rpc.reject(l3.info['id'])\\n\\n l2.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is allowed\\\".format(l2.info['id']))\\n assert len(l1.rpc.listpeers(l2.info['id'])['peers']) == 1\\n\\n l3.connect(l1)\\n l1.daemon.wait_for_log(r\\\"{} is in reject list\\\".format(l3.info['id']))\\n\\n # FIXME: this error occurs *after* connection, so we connect then drop.\\n l3.daemon.wait_for_log(r\\\"lightning_openingd-{} chan #1: peer_in WIRE_ERROR\\\"\\n .format(l1.info['id']))\\n l3.daemon.wait_for_log(r\\\"You are in reject list\\\")\\n\\n def check_disconnect():\\n peers = l1.rpc.listpeers(l3.info['id'])['peers']\\n return peers == [] or not peers[0]['connected']\\n\\n wait_for(check_disconnect)\",\n \"async def test_connection_error(\\n hass: HomeAssistant, init_integration, mock_auth, mock_config_entry\\n) -> None:\\n\\n install = AsyncMock()\\n install.arm = AsyncMock(return_value=False)\\n install.arm_partially = AsyncMock(return_value=True)\\n install.disarm = AsyncMock(return_value=True)\\n install.status = Status.ARMED\\n\\n with patch(\\\"pyprosegur.installation.Installation.retrieve\\\", return_value=install):\\n await hass.async_block_till_done()\\n\\n with patch(\\n \\\"pyprosegur.installation.Installation.retrieve\\\", side_effect=ConnectionError\\n ):\\n await entity_component.async_update_entity(hass, PROSEGUR_ALARM_ENTITY)\\n\\n state = hass.states.get(PROSEGUR_ALARM_ENTITY)\\n assert state.state == STATE_UNAVAILABLE\",\n \"def test_exception_with_callback(self):\\n test_utils.generate_test_config_file()\\n\\n exception_callback = mock.Mock()\\n\\n client = PowerTrackClient(_dummy_callback, exception_callback,\\n config_file_path=config_file)\\n client.connect()\\n client.disconnect()\\n self.assertTrue(exception_callback.called)\\n actual_exinfo = exception_callback.call_args[0][0]\\n actual_ex = actual_exinfo[1]\\n self.assertIsInstance(actual_ex, Exception)\\n self.assertEqual(actual_ex.message, \\\"This is a test exception\\\")\",\n \"async def test_button_connection_error(\\n hass: HomeAssistant,\\n mock_lametric: MagicMock,\\n) -> None:\\n mock_lametric.app_next.side_effect = LaMetricConnectionError\\n\\n with pytest.raises(\\n HomeAssistantError, match=\\\"Error communicating with the LaMetric device\\\"\\n ):\\n await hass.services.async_call(\\n BUTTON_DOMAIN,\\n SERVICE_PRESS,\\n {ATTR_ENTITY_ID: \\\"button.frenck_s_lametric_next_app\\\"},\\n blocking=True,\\n )\\n await hass.async_block_till_done()\\n\\n state = hass.states.get(\\\"button.frenck_s_lametric_next_app\\\")\\n assert state\\n assert state.state == STATE_UNAVAILABLE\",\n \"def error(self, *args):\\n\\n self.log(\\\"ERROR:\\\", args)\\n if not self.transport.connected:\\n Timer(5, connect(self.host, self.port)).register(self)\",\n \"def testConnectionLost(self):\\n d = self.testSimpleRequest()\\n d.addCallback(lambda _: self.factory.crash())\\n d.addCallback(lambda _: self.client.check_rate_limit())\\n d.addTimeout(0.01, reactor)\\n self.assertFailure(d, ConnectionClosed)\\n return d\",\n \"def test_exception_raised_with_a_dlq():\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n dlq: missive.DLQ = {}\\n proc.set_dlq(dlq)\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n test_client.send(blank_message)\\n assert dlq == {blank_message.message_id: (blank_message, \\\"bad bytes!\\\")}\\n assert blank_message in test_client.acked\",\n \"def test_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as err:\\n server.sendall(b\\\"hello, world\\\")\\n if platform == \\\"win32\\\":\\n assert err.value.args[0] == ESHUTDOWN\\n else:\\n assert err.value.args[0] == EPIPE\",\n \"def testRemoteError(self):\\n\\n def _testStreamError(res):\\n self.assertEqual(True, isinstance(res.value, httpb_client.HTTPBNetworkTerminated))\\n\\n self.assertEqual(True, res.value.body_tag.hasAttribute('condition'), 'No attribute condition')\\n # This is not a stream error because we sent invalid xml\\n self.assertEqual(res.value.body_tag['condition'], 'remote-stream-error')\\n self.assertEqual(True, len(res.value.elements)>0)\\n # The XML should exactly match the error XML sent by triggerStreamError().\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/policy-violation\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/arbitrary-extension\\\").matches(res.value.elements[0]))\\n self.assertEqual(True,xpath.XPathQuery(\\\"/error/text[text() = 'Error text']\\\").matches(res.value.elements[0]))\\n\\n\\n\\n def _failStreamError(res):\\n self.fail('A stream error needs to be returned')\\n\\n def _testSessionCreate(res):\\n self.sid = res[0]['sid']\\n # this xml is valid, just for testing\\n # the point is to wait for a stream error\\n d = self.send('<fdsfd/>')\\n d.addCallback(_failStreamError)\\n d.addErrback(_testStreamError)\\n self.server_protocol.triggerStreamError()\\n\\n return d\\n\\n BOSH_XML = \\\"\\\"\\\"<body content='text/xml; charset=utf-8'\\n hold='1'\\n rid='%(rid)i'\\n to='localhost'\\n route='xmpp:127.0.0.1:%(server_port)i'\\n ver='1.6'\\n wait='60'\\n ack='1'\\n xml:lang='en'\\n xmlns='http://jabber.org/protocol/httpbind'/>\\n \\\"\\\"\\\"% { \\\"rid\\\": self.rid, \\\"server_port\\\": self.server_port }\\n\\n d = self.proxy.connect(BOSH_XML).addCallback(_testSessionCreate)\\n\\n return d\",\n \"def _connect_failed(self):\\n\\t\\tself.root.stdout.write(\\\"Error: Connection Failed!\\\\n\\\")\\n\\t\\tself.client = False\",\n \"def test_listen_error(self):\\n listen_port = self.get_port()\\n config = Qdrouterd.Config([\\n ('router', {'mode': 'standalone', 'id': 'bad'}),\\n ('listener', {'port': listen_port, 'maxFrameSize': '2048', 'stripAnnotations': 'no'}),\\n ('listener', {'port': listen_port, 'http':True})])\\n r = Qdrouterd(name=\\\"expect_fail\\\", config=config, wait=False);\\n self.assertEqual(1, r.wait())\",\n \"def test_exceptions_in_client_bubble_up(self):\\n\\n class SentinelException(Exception):\\n pass\\n\\n def server_callback(*args):\\n return self.sample_ocsp_data\\n\\n def client_callback(*args):\\n raise SentinelException()\\n\\n client = self._client_connection(callback=client_callback, data=None)\\n server = self._server_connection(callback=server_callback, data=None)\\n\\n with pytest.raises(SentinelException):\\n handshake_in_memory(client, server)\",\n \"def unhandled_error(self, error):\\n # TODO(mpetazzoni): ws4py >= 0.3.5 only?\\n _logger.debug('WebSocket error: %s; will reconnect.', error)\",\n \"def test_not_running(): # pragma: windows\\n comm_kwargs = dict(comm='IPCComm', direction='send', reverse_names=True)\\n nt.assert_raises(RuntimeError, new_comm, 'test', **comm_kwargs)\",\n \"def test_rsp_failure(self):\\n\\n def handle(event):\\n return 0x0112, None\\n\\n self.ae = ae = AE()\\n ae.acse_timeout = 5\\n ae.dimse_timeout = 5\\n ae.network_timeout = 5\\n ae.add_supported_context(ProceduralEventLogging)\\n scp = ae.start_server(\\n (\\\"localhost\\\", 11112), block=False, evt_handlers=[(evt.EVT_N_ACTION, handle)]\\n )\\n\\n ae.add_requested_context(ProceduralEventLogging)\\n assoc = ae.associate(\\\"localhost\\\", 11112)\\n assert assoc.is_established\\n\\n ds = Dataset()\\n ds.PatientName = \\\"Test^test\\\"\\n status, ds = assoc.send_n_action(\\n ds, 1, ProceduralEventLogging, \\\"1.2.840.10008.5.1.1.40.1\\\"\\n )\\n assert status.Status == 0x0112\\n assert ds is None\\n assoc.release()\\n assert assoc.is_released\\n\\n scp.shutdown()\",\n \"def on_disconnect(unused_client, unused_userdata, rc):\\n print(f\\\"on_disconnect: {error_str(rc)}\\\")\\n print()\\n\\n global connected\\n connected = False\",\n \"async def test_setup_failed_error(hass: HomeAssistant, ufp: MockUFPFixture) -> None:\\n\\n ufp.api.get_nvr = AsyncMock(side_effect=NvrError)\\n\\n await hass.config_entries.async_setup(ufp.entry.entry_id)\\n await hass.async_block_till_done()\\n assert ufp.entry.state == ConfigEntryState.SETUP_RETRY\\n assert not ufp.api.update.called\",\n \"async def test_discovered_by_dhcp_connection_fails(\\n hass: HomeAssistant, source, data\\n) -> None:\\n with patch(\\n \\\"homeassistant.components.wiz.wizlight.getBulbConfig\\\",\\n side_effect=WizLightTimeOutError,\\n ):\\n result = await hass.config_entries.flow.async_init(\\n DOMAIN, context={\\\"source\\\": source}, data=data\\n )\\n await hass.async_block_till_done()\\n\\n assert result[\\\"type\\\"] == FlowResultType.ABORT\\n assert result[\\\"reason\\\"] == \\\"cannot_connect\\\"\",\n \"def test_signal_interruption(self):\\n process = Popen(\\n [STRATIS_CLI, \\\"pool\\\", \\\"create\\\",\\n p_n(), DISKS[0]],\\n stdout=PIPE,\\n stderr=PIPE,\\n close_fds=True,\\n env=os.environ)\\n time.sleep(0.05)\\n process.send_signal(2)\\n result = process.communicate()\\n stdout_text = \\\"\\\"\\n stderr_text = \\\"\\\"\\n if result[0]:\\n stdout_text = bytes(result[0]).decode(\\\"utf-8\\\")\\n if result[1]:\\n stderr_text = bytes(result[1]).decode(\\\"utf-8\\\")\\n\\n self.assertTrue(\\\"Traceback\\\" not in stdout_text)\\n self.assertTrue(\\\"Traceback\\\" not in stderr_text)\\n self.assertNotEqual(process.returncode, 0)\",\n \"def test_pause_not_listening(testchannel):\\n with testchannel.open():\\n with pytest.raises(NotListeningError):\\n testchannel.pause()\",\n \"async def test_child_crash_propagation():\\n looper_cancelled = False\\n\\n async def looper():\\n nonlocal looper_cancelled\\n try:\\n while True:\\n await asyncio.sleep(0)\\n except asyncio.CancelledError:\\n looper_cancelled = True\\n\\n error = ValueError('crashed')\\n\\n async def crasher():\\n raise error\\n\\n with pytest.raises(ValueError) as excinfo:\\n async with Nursery() as nursery:\\n nursery.start_soon(looper())\\n nursery.start_soon(crasher())\\n\\n assert looper_cancelled\\n assert excinfo.value is error\",\n \"def connection_lost(self, exc: Optional[Exception]) -> None:\\n if exc:\\n logger.critical(f\\\"udp bridge lost its connection {exc}\\\")\\n else:\\n logger.info(\\\"udp connection stopped\\\")\",\n \"async def test_startup_errors_should_halt_ready():\\n network = Network()\\n network.set_config(url=\\\"http://nowhere.at.all.localdomain:6865/\\\", connect_timeout=1)\\n\\n client = network.aio_party(\\\"SillyParty\\\")\\n\\n # place the ready() call BEFORE the run\\n f = ensure_future(wait_for(client.ready(), 2))\\n\\n try:\\n await network.aio_run(keep_open=False)\\n except Exception:\\n pass\\n\\n try:\\n await f\\n raise AssertionError(\\n \\\"client.ready() should not have ended because there is nothing to connect to\\\"\\n )\\n except asyncio.TimeoutError:\\n raise AssertionError(\\n \\\"client.ready() did not abort with an appropriate exception and was killed because \\\"\\n \\\"it was taking too long\\\"\\n )\\n except CancelledError:\\n LOG.info(\\\"Successfully terminated because ready() was cancelled.\\\")\",\n \"def test_shutdown_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as exc:\\n server.shutdown()\\n if platform == \\\"win32\\\":\\n assert exc.value.args[0] == ESHUTDOWN\\n else:\\n assert exc.value.args[0] == EPIPE\",\n \"def test_can_not_handle_brew_container_task_failed_event(self):\\n event = self.get_event_from_msg(get_fedmsg('brew_container_task_failed'))\\n self.assertFalse(self.handler.can_handle(event))\",\n \"def test_downgrade_control(self, ping_fixture_all_errs_disconnect):\\n\\n engine = ping_fixture_all_errs_disconnect\\n\\n conn = engine.connect()\\n conn.close()\",\n \"def _connectPrepError(self, failure, authenticator):\\r\\n authenticator.cancel()\\r\\n return failure\",\n \"async def test_discovery_cannot_connect(hass: HomeAssistant) -> None:\\n\\n result = await hass.config_entries.flow.async_init(\\n DOMAIN, context={\\\"source\\\": config_entries.SOURCE_ZEROCONF}, data=TEST_DISCOVERY\\n )\\n\\n with patch(\\n \\\"homeassistant.components.volumio.config_flow.Volumio.get_system_info\\\",\\n side_effect=CannotConnectError,\\n ):\\n result2 = await hass.config_entries.flow.async_configure(\\n result[\\\"flow_id\\\"],\\n user_input={},\\n )\\n\\n assert result2[\\\"type\\\"] == \\\"abort\\\"\\n assert result2[\\\"reason\\\"] == \\\"cannot_connect\\\"\",\n \"def test_that_error_callback_is_not_invoked_on_no_error(self, request):\\n error = False\\n\\n def on_error(_):\\n nonlocal error\\n error = True\\n\\n response = requests.Response()\\n response.status_code = 200\\n request.return_value = response\\n r = rx_request('get', 'url')\\n\\n r.subscribe(on_error=on_error)\\n\\n self.assertFalse(error)\",\n \"def test_error(self, mock_validate_session):\\n mock_validate_session.return_value = False\\n with pytest.raises(SystemExit) as ctx:\\n celery_command.worker(Namespace(queues=1, concurrency=1))\\n assert str(ctx.value) == \\\"Worker exiting, database connection precheck failed.\\\"\",\n \"def on_connection_error(self):\\n log.error(\\\"Stream connection has errored or timed out\\\")\",\n \"def on_connection_open_error(self, _unused_connection, err):\\n # LOGGER.error('Connection open failed: %s', err)\\n self.reconnect()\",\n \"async def test_disconnected_server_raises_on_data_write(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESS\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def test_connect_error():\\n queue = RedisQueue('localhost')\\n assert not queue.is_connected\\n with pytest.raises(ConnectionError):\\n queue.put('test')\\n with pytest.raises(ConnectionError):\\n queue.get()\",\n \"def unknown_event(self, event):\\r\\n pass\",\n \"def test_loginException(self):\\n\\n class UnexpectedException(Exception):\\n \\\"\\\"\\\"\\n An unexpected exception.\\n \\\"\\\"\\\"\\n\\n def raisesUnexpectedException(user, passwd):\\n raise UnexpectedException(\\\"Whoops\\\")\\n\\n self.server.authenticateLogin = raisesUnexpectedException\\n\\n def login():\\n return self.client.login(b'testuser', b'password-test')\\n\\n d1 = self.connected.addCallback(strip(login))\\n\\n d1.addErrback(self.assertClientFailureMessage, b\\\"Server error: Whoops\\\")\\n\\n @d1.addCallback\\n def assertErrorLogged(_):\\n self.assertTrue(self.flushLoggedErrors(UnexpectedException))\\n\\n d1.addErrback(self._ebGeneral)\\n d1.addBoth(self._cbStopClient)\\n\\n d2 = self.loopback()\\n d = defer.gatherResults([d1, d2])\\n return d.addCallback(self._cbTestFailedLogin)\",\n \"def test_original_failure_not_error(self):\\n dr = EventualResult(succeed(3), None)\\n self.assertIdentical(dr.original_failure(), None)\",\n \"def state_failsafe_validate(cfg, app, win, events):\",\n \"def onentererror(self, event):\\n print('onentererror; event: %s, %s->%s' % (event.event, event.src, event.dst))\",\n \"def test_sandbox_errors_true(self):\\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\\n sandbox_errors=True)\\n\\n self.assertEqual(len(self._on_signal_exception.calls), 0)\\n self.signal.send(self)\\n self.assertEqual(len(self._on_signal_exception.calls), 1)\",\n \"def test_scp_callback_exception(self):\\n self.scp = DummyVerificationSCP()\\n def on_c_echo(context, info):\\n raise ValueError\\n self.scp.ae.on_c_echo = on_c_echo\\n self.scp.start()\\n\\n ae = AE()\\n ae.add_requested_context(VerificationSOPClass)\\n assoc = ae.associate('localhost', 11112)\\n assert assoc.is_established\\n rsp = assoc.send_c_echo()\\n assert rsp.Status == 0x0000\\n assoc.release()\\n self.scp.stop()\",\n \"def _on_catastrophic_disconnect(self, channel_id: str) -> None:\\n logger.error(f\\\"Channel {channel_id} called on_catastrophic_disconnect\\\")\\n\\n live_run = self.get_live_run()\\n live_run.force_shutdown = True\",\n \"async def test_options_flow_network_failure(hass):\\n\\n entry = await setup_platform(hass)\\n\\n with patch(\\n \\\"aussiebb.asyncio.AussieBB.get_services\\\", side_effect=ClientConnectionError()\\n ):\\n\\n result1 = await hass.config_entries.options.async_init(entry.entry_id)\\n assert result1[\\\"type\\\"] == RESULT_TYPE_ABORT\\n assert result1[\\\"reason\\\"] == \\\"cannot_connect\\\"\",\n \"def test_error_bubbles_up(self):\\n\\n def fail(box):\\n box.fail(ValueError(\\\"oh dear\\\"))\\n\\n self.assertThat(\\n lambda: sync_perform(func_dispatcher, Effect(fail)),\\n raises(ValueError(\\\"oh dear\\\")),\\n )\",\n \"def on_disconnect(unused_client, unused_userdata, rc):\\n\\tprint('on_disconnect', error_str(rc))\\n\\n\\t# Since a disconnect occurred, the next loop iteration will wait with\\n\\t# exponential backoff.\\n\\tglobal should_backoff\\n\\tshould_backoff = True\",\n \"def connection_lost(self, exc):\\n pass\",\n \"def test_run_without_message(connection, events, loop):\\n loop.run_until_complete(connection.run())\\n assert events.triggered(\\\"CLIENT_CONNECT\\\")\\n assert events.triggered(\\\"CLIENT_DISCONNECT\\\")\",\n \"def test_cond_with_uncaught_error(env):\\n def explode(env, delay):\\n yield env.timeout(delay)\\n raise ValueError(f'Onoes, failed after {delay}!')\\n\\n def process(env):\\n yield env.timeout(1) | env.process(explode(env, 2))\\n\\n env.process(process(env))\\n try:\\n env.run()\\n assert False, 'There should have been an exception.'\\n except ValueError:\\n pass\\n assert env.now == 2\",\n \"def test_disconnect_from_client_side(\\n start_result_q_publisher, start_result_q_subscriber\\n):\\n\\n result_pub = start_result_q_publisher()\\n f = result_pub.publish(b\\\"Hello test_disconnect_from_client_side 1\\\")\\n assert f.result(timeout=1) is None\\n\\n result_pub.stop()\\n\\n try_assert(lambda: not result_pub.is_alive(), \\\"Verify test setup\\\")\\n with pytest.raises(ValueError):\\n result_pub.publish(b\\\"Hello test_disconnect_from_client_side 2\\\")\",\n \"def test_invalid_signal(self):\\n mediator = Mediator()\\n\\n try:\\n mediator.signal(\\\"foo\\\")\\n except:\\n raise AssertionError()\",\n \"async def test_disconnected_server_raises_on_data_read(preset_client):\\n await preset_client.connect()\\n\\n preset_client.server.responses.append(b\\\"250 Hello there\\\")\\n await preset_client.ehlo()\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.mail(\\\"sender@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"250 ok\\\")\\n await preset_client.rcpt(\\\"recipient@example.com\\\")\\n\\n preset_client.server.responses.append(b\\\"354 lets go\\\")\\n preset_client.server.drop_connection_after_request = b\\\"A MESSAGE\\\\r\\\\n.\\\\r\\\\n\\\"\\n\\n with pytest.raises(SMTPServerDisconnected):\\n await preset_client.data(\\\"A MESSAGE\\\")\\n\\n # Verify that the connection was closed\\n assert not preset_client._connect_lock.locked()\\n assert preset_client.protocol is None\\n assert preset_client.transport is None\",\n \"def clientConnectionFailed(self, connector, reason):\\n\\n print(\\\"Connection failed\\\") # client console notification\\n reactor.callFromThread(reactor.stop) # reactor shutdown\",\n \"def exit_failure():\\n\\tglobal state\\n\\tglobal c1, c2\\n\\tglobal a1, a2\\n\\n\\t# Tell clients to close connections\\n\\tc1.send(\\\"CLOSE\\\")\\n\\tc2.send(\\\"CLOSE\\\")\\n\\n\\tprint \\\"EXIT FAILURE\\\"\\n\\tstate += 1 # increment state to 10\",\n \"def test_fail_must_login(self):\\n guest_obj = self._check_init()\\n msg = 'You need to login first'\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.hotplug(vols=[dict()])\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.install_packages([])\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.open_session)\\n with self.assertRaisesRegex(RuntimeError, msg):\\n guest_obj.push_file('source_url', 'target_path')\\n self.assertRaisesRegex(RuntimeError, msg, guest_obj.stop)\",\n \"def test_failure_result(self):\\n dr = EventualResult(fail(RuntimeError()), None)\\n self.assertRaises(RuntimeError, dr.wait, 0.1)\",\n \"def test_silent_write_errors():\\n\\n tracker = pawprint.Tracker(db=None, table=None)\\n\\n try:\\n tracker.write(event=\\\"This will fail silently.\\\")\\n except Exception:\\n pytest.fail(\\\"Failed to fail silently.\\\")\",\n \"def test_shutdown(self):\\n server = self._server(None)\\n server.bio_shutdown()\\n with pytest.raises(Error) as err:\\n server.recv(1024)\\n # We don't want WantReadError or ZeroReturnError or anything - it's a\\n # handshake failure.\\n assert type(err.value) in [Error, SysCallError]\",\n \"async def test_flow_ssdp_bad_discovery(opp, aioclient_mock):\\n result = await opp.config_entries.flow.async_init(\\n DECONZ_DOMAIN,\\n data={ATTR_UPNP_MANUFACTURER_URL: \\\"other\\\"},\\n context={\\\"source\\\": SOURCE_SSDP},\\n )\\n\\n assert result[\\\"type\\\"] == RESULT_TYPE_ABORT\\n assert result[\\\"reason\\\"] == \\\"not_deconz_bridge\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75634176","0.7460929","0.690459","0.6380832","0.6284205","0.61783296","0.61361533","0.61084944","0.6066335","0.60619","0.59785515","0.5976626","0.59717333","0.594296","0.5942044","0.59340584","0.59147024","0.5885476","0.58497363","0.5848464","0.58413315","0.5840039","0.5838695","0.58328646","0.5824669","0.58071864","0.57924974","0.5786006","0.57789177","0.5767232","0.5765568","0.5762816","0.57611674","0.5751774","0.5744494","0.574329","0.57358813","0.573541","0.57182664","0.57069945","0.5706208","0.5706091","0.5703802","0.57025856","0.57021844","0.5697192","0.5693044","0.56757563","0.5669092","0.5663551","0.5657771","0.5654042","0.5649854","0.5649302","0.56297874","0.56155694","0.561504","0.56103516","0.56089395","0.5605649","0.56014013","0.55906624","0.5586494","0.55854297","0.5583403","0.55833846","0.5582513","0.55688506","0.5561265","0.55525964","0.55498785","0.55451757","0.5544501","0.5533976","0.55337465","0.55309284","0.5522611","0.5517619","0.5512626","0.5510542","0.55063206","0.5506035","0.55056125","0.55048454","0.55029356","0.55028117","0.5502706","0.55022764","0.54960597","0.54958326","0.54941386","0.54785126","0.54780436","0.5472413","0.54638875","0.54610264","0.5460386","0.5451947","0.54499215","0.54469985"],"string":"[\n \"0.75634176\",\n \"0.7460929\",\n \"0.690459\",\n \"0.6380832\",\n \"0.6284205\",\n \"0.61783296\",\n \"0.61361533\",\n \"0.61084944\",\n \"0.6066335\",\n \"0.60619\",\n \"0.59785515\",\n \"0.5976626\",\n \"0.59717333\",\n \"0.594296\",\n \"0.5942044\",\n \"0.59340584\",\n \"0.59147024\",\n \"0.5885476\",\n \"0.58497363\",\n \"0.5848464\",\n \"0.58413315\",\n \"0.5840039\",\n \"0.5838695\",\n \"0.58328646\",\n \"0.5824669\",\n \"0.58071864\",\n \"0.57924974\",\n \"0.5786006\",\n \"0.57789177\",\n \"0.5767232\",\n \"0.5765568\",\n \"0.5762816\",\n \"0.57611674\",\n \"0.5751774\",\n \"0.5744494\",\n \"0.574329\",\n \"0.57358813\",\n \"0.573541\",\n \"0.57182664\",\n \"0.57069945\",\n \"0.5706208\",\n \"0.5706091\",\n \"0.5703802\",\n \"0.57025856\",\n \"0.57021844\",\n \"0.5697192\",\n \"0.5693044\",\n \"0.56757563\",\n \"0.5669092\",\n \"0.5663551\",\n \"0.5657771\",\n \"0.5654042\",\n \"0.5649854\",\n \"0.5649302\",\n \"0.56297874\",\n \"0.56155694\",\n \"0.561504\",\n \"0.56103516\",\n \"0.56089395\",\n \"0.5605649\",\n \"0.56014013\",\n \"0.55906624\",\n \"0.5586494\",\n \"0.55854297\",\n \"0.5583403\",\n \"0.55833846\",\n \"0.5582513\",\n \"0.55688506\",\n \"0.5561265\",\n \"0.55525964\",\n \"0.55498785\",\n \"0.55451757\",\n \"0.5544501\",\n \"0.5533976\",\n \"0.55337465\",\n \"0.55309284\",\n \"0.5522611\",\n \"0.5517619\",\n \"0.5512626\",\n \"0.5510542\",\n \"0.55063206\",\n \"0.5506035\",\n \"0.55056125\",\n \"0.55048454\",\n \"0.55029356\",\n \"0.55028117\",\n \"0.5502706\",\n \"0.55022764\",\n \"0.54960597\",\n \"0.54958326\",\n \"0.54941386\",\n \"0.54785126\",\n \"0.54780436\",\n \"0.5472413\",\n \"0.54638875\",\n \"0.54610264\",\n \"0.5460386\",\n \"0.5451947\",\n \"0.54499215\",\n \"0.54469985\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73141897"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":84671,"cells":{"query":{"kind":"string","value":"Given a model instance save it to the database."},"document":{"kind":"string","value":"def save_model(self, request, obj, form, change):\n obj.save()\n casestudy_id = request.session.get('casestudy', None)\n if casestudy_id is not None:\n casestudy = CaseStudy.objects.get(pk=casestudy_id)\n pic = PublicationInCasestudy.objects.get_or_create(\n casestudy=casestudy,\n publication=obj)"},"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 _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()","def save_model(self):\n pass","def save_model( self, request, obj, form, change ):\n obj.save()","def save(self):\n self.presavemodel()\n self.dbm().model_save(self)\n self.set_isdirty(False)\n # we might be smart about flushing when there is no id, so that saving a new model gets it's unique id\n if (self.id == None):\n self.flush_toupdate()","def save_model(self, *args, **kwargs):\n raise NotImplementedError","def save_to_db(self):\n db.session.add(self)\n db.session.commit()","def save_to_db(self):\n db.session.add(self)\n db.session.commit()","def save_to_db(self):\n db.session.add(self)\n db.session.commit()","def save_to_db(self):\n db.session.add(self)\n db.session.commit()","def save_model(self):\n if self.model:\n self.model.save(self.config[\"model_path\"])","def save_to_db(self):\n db.session.add(self)\n db.session.commit()\n # try:\n # db.session.add(self)\n # db.session.commit()\n # except exc.IntegrityError:\n # db.session.rollback()","def save(self):\n\t\tdb.session.add(self)\n\t\tdb.session.commit()","def save(self):\r\n db.session.add(self)\r\n db.session.commit()","def save(self):\n \n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n db.session.add(self)\n db.session.commit()","def save(self):\n\n self.__session.commit()","def save(self):\n\n self.__session.commit()","def save_model(self, request, instance, form, change):\n pass","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.__session.commit()","def save(self):\n self.session.commit()","def save(self):\n self.__db.commit()","def save(self):\n db.session.commit()","def save(self, instance: BaseModel):\n # If this is a new unsaved object, it'll likely have an\n # id of None, which RethinkDB won't like. So if it's None,\n # generate a UUID for it. If the save fails, we should re-set\n # it to None.\n if instance.id is None:\n instance.id = str(uuid.uuid4())\n elif isinstance(instance.id, uuid.UUID):\n instance.id = str(instance.id)\n\n instance = self._fix_uuids(instance)\n with rconnect() as conn:\n try:\n query = self.q.insert(\n instance.to_primitive(),\n conflict=\"replace\"\n )\n rv = query.run(conn) # NOQA\n # console.debug(rv)\n except Exception as e:\n console.error(e)\n instance.id = None\n raise\n else:\n return instance","def save(self):\n self.db.commit()","def model_update(self, db):\n db.session.commit()","def save(self, instance):\n return instance","def save(self, datastore, model):\n datastore.add(model)\n datastore.flush()\n return model","def save(self, instance, commit=True):\n\n self._isinstance(instance)\n db.session.add(instance)\n if commit:\n db.session.commit()\n return instance","def save(self):\n try:\n db.session.add(self)\n db.session.flush()\n except Exception:\n db.session.rollback()\n raise Exception","def save_object(self, object, **kwargs):\n object.save()","def _save_model(self):\n save_generic(self.model, self.model_pkl_fname)","def save(self):\n if self.id:\n self.update()\n else:\n self.create()","def save(self):\r\n s = self.get_session()\r\n s.add(self)\r\n s.commit()\r\n return self","def save(self, db):\n pass","def save(self):\n db.session.add(self)\n self.__commit()\n return self","def save(self, session=None):\n change_fields = self._get_changed_persistent_fields()\n self.db_repo.update_from(self.db_model, self.id,\n change_fields, session=session)\n self.obj_reset_changes()","def save(self) -> \"BaseModel\":\n try:\n db.session.add(self)\n db.session.commit()\n return self\n\n except Exception as e:\n db.session.rollback()\n descripted_exception_logger(e)\n raise","def save(self, obj):\n raise NotImplementedError","def save(self):\n\t\tdb.session.add(self)\n\t\tdb.session.commit()\n\t\treturn self","def save_data(self):\n db.session.add(self)\n db.session.commit( )","def save(self, *args, **kwargs):\n super(self.__class__, self).save(*args, **kwargs)","def save_model(self, path):\n self._model.save(path)","def save(path_to_model):\n pass","def _update(self, model_obj: Any):\n conn = self.provider.get_connection()\n\n identifier = model_obj.meta.id\n\n # Fetch the record from database\n try:\n # Calling `get` will raise `NotFoundError` if record was not found\n self.model_cls.get(\n id=identifier, using=conn, index=self.model_cls._index._name\n )\n except NotFoundError as exc:\n logger.error(f\"Database Record not found: {exc}\")\n raise ObjectNotFoundError(\n {\n \"_entity\": f\"`{self.entity_cls.__name__}` object with identifier {identifier} \"\n f\"does not exist.\"\n }\n )\n\n try:\n model_obj.save(\n refresh=True,\n index=self.model_cls._index._name,\n using=conn,\n )\n except Exception as exc:\n logger.error(f\"Error while creating: {exc}\")\n raise\n\n return model_obj","def _save(self, step, model):\n\n raise NotImplementedError()","def save(self):\n data = self.serialize()\n\n self.validate(data)\n\n saved_data = DATABASE_CONNECTION.insert(self.__class__.__name__, data)\n\n self.__dict__.update(saved_data)","def save(self):\n\n pass","def save(self) -> None:\n pass","def save(self) -> None:\n pass","def save(self) -> None:\n pass","def save(self, *args, **kwargs):\n pass","def save(self, *args, **kwargs) -> None:\n pass","def save(self, *args, **kwargs) -> None:\n pass","def save(self, *args, **kwargs) -> None:\n pass","def save(self, obj):","def save(self):\n print(\"==> Saving model to\", self.model_dir)\n self.model.save(self.model_dir)","def save(self):\n if self.id is None:\n self._insert()\n else:\n self._update()","def save(\n self,\n modelSavePath\n ):\n pass","def save(self, *args, **kwargs):\n return","def save(self):\n if self.iid is not None:\n self.db().update(self.iid, self._attributes)\n else:\n self.iid = self.db().add(self._attributes)","def save(self):\n try:\n self.__session.commit()\n except Exception:\n self.__session.rollback()\n finally:\n self.__session.close()","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save (self):\n pass","def save_db(self) -> None:","def _create(self, model_obj):\n conn = self._get_session()\n\n try:\n conn.add(model_obj)\n except DatabaseError as exc:\n logger.error(f\"Error while creating: {exc}\")\n raise\n finally:\n if not current_uow:\n conn.commit()\n conn.close()\n\n return model_obj","def saveModel(self):\n log.info(\"Saving model to %s...\" % self.savedModelsPath)\n self.model.save(self.savedModelsPath)","def save(self):\n pk = self.get_pk()\n if pk and not self._is_new_record and self._edited_fields:\n set_vars = self.get_field_dict(fields=self._edited_fields)\n self.update(**set_vars).filter(**{self.get_pk_name(): pk}).execute()\n elif self._is_new_record:\n insert_vars = self.get_field_dict()\n if self._meta.auto_increment:\n insert_vars.pop(self.get_pk_name())\n new_pk = self.insert(**insert_vars).execute()\n if self._meta.auto_increment:\n self.set_pk(new_pk)\n self.set_new_record_state(False)\n elif not pk and not self._is_new_record:\n raise ValueError('[Model.save] Primary key is not defined ' +\n 'while the data is stored')\n self._edited_fields.clear()","def save(self, *args, **kwargs):\n super().save(*args, **kwargs)","def save(self, *args, **kwargs):\n super().save(*args, **kwargs)","def save(self):\n # type: () -> bool\n\n return self.query.commit(self.id, self)","def save(self):\n try:\n db.session.add(self)\n db.session.commit()\n return True\n except SQLAlchemyError as error_message:\n app_logger.error(error_message)\n return False","def save(self):\n if not self.id:\n self.id = uuid4()\n DataStore.add_instance(self)","def save_now(self):\r\n self.save()","def save_now(self):\r\n self.save()","def save(self):\n try:\n db.session.add(self)\n db.session.commit()\n return True\n except SQLAlchemyError as e:\n db.session.rollback()\n logger.error(\"database operation error: \", e)\n return False","def save_model(self, path):\n pass","def save(self):\n raise NotImplementedError","def save(self):\n raise NotImplementedError","def save(self):\n raise NotImplementedError","def save(self, context=None):\n updates = self.obj_get_changes()\n self.dbapi.update_boar(context, self.id, updates)\n self.obj_reset_changes()"],"string":"[\n \"def _write_to_db(self, instance: DBModelInstance) -> None:\\n self.db.session.add(instance)\\n self.db.session.commit()\",\n \"def save_model(self):\\n pass\",\n \"def save_model( self, request, obj, form, change ):\\n obj.save()\",\n \"def save(self):\\n self.presavemodel()\\n self.dbm().model_save(self)\\n self.set_isdirty(False)\\n # we might be smart about flushing when there is no id, so that saving a new model gets it's unique id\\n if (self.id == None):\\n self.flush_toupdate()\",\n \"def save_model(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def save_to_db(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save_to_db(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save_to_db(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save_to_db(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save_model(self):\\n if self.model:\\n self.model.save(self.config[\\\"model_path\\\"])\",\n \"def save_to_db(self):\\n db.session.add(self)\\n db.session.commit()\\n # try:\\n # db.session.add(self)\\n # db.session.commit()\\n # except exc.IntegrityError:\\n # db.session.rollback()\",\n \"def save(self):\\n\\t\\tdb.session.add(self)\\n\\t\\tdb.session.commit()\",\n \"def save(self):\\r\\n db.session.add(self)\\r\\n db.session.commit()\",\n \"def save(self):\\n \\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n db.session.add(self)\\n db.session.commit()\",\n \"def save(self):\\n\\n self.__session.commit()\",\n \"def save(self):\\n\\n self.__session.commit()\",\n \"def save_model(self, request, instance, form, change):\\n pass\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.__session.commit()\",\n \"def save(self):\\n self.session.commit()\",\n \"def save(self):\\n self.__db.commit()\",\n \"def save(self):\\n db.session.commit()\",\n \"def save(self, instance: BaseModel):\\n # If this is a new unsaved object, it'll likely have an\\n # id of None, which RethinkDB won't like. So if it's None,\\n # generate a UUID for it. If the save fails, we should re-set\\n # it to None.\\n if instance.id is None:\\n instance.id = str(uuid.uuid4())\\n elif isinstance(instance.id, uuid.UUID):\\n instance.id = str(instance.id)\\n\\n instance = self._fix_uuids(instance)\\n with rconnect() as conn:\\n try:\\n query = self.q.insert(\\n instance.to_primitive(),\\n conflict=\\\"replace\\\"\\n )\\n rv = query.run(conn) # NOQA\\n # console.debug(rv)\\n except Exception as e:\\n console.error(e)\\n instance.id = None\\n raise\\n else:\\n return instance\",\n \"def save(self):\\n self.db.commit()\",\n \"def model_update(self, db):\\n db.session.commit()\",\n \"def save(self, instance):\\n return instance\",\n \"def save(self, datastore, model):\\n datastore.add(model)\\n datastore.flush()\\n return model\",\n \"def save(self, instance, commit=True):\\n\\n self._isinstance(instance)\\n db.session.add(instance)\\n if commit:\\n db.session.commit()\\n return instance\",\n \"def save(self):\\n try:\\n db.session.add(self)\\n db.session.flush()\\n except Exception:\\n db.session.rollback()\\n raise Exception\",\n \"def save_object(self, object, **kwargs):\\n object.save()\",\n \"def _save_model(self):\\n save_generic(self.model, self.model_pkl_fname)\",\n \"def save(self):\\n if self.id:\\n self.update()\\n else:\\n self.create()\",\n \"def save(self):\\r\\n s = self.get_session()\\r\\n s.add(self)\\r\\n s.commit()\\r\\n return self\",\n \"def save(self, db):\\n pass\",\n \"def save(self):\\n db.session.add(self)\\n self.__commit()\\n return self\",\n \"def save(self, session=None):\\n change_fields = self._get_changed_persistent_fields()\\n self.db_repo.update_from(self.db_model, self.id,\\n change_fields, session=session)\\n self.obj_reset_changes()\",\n \"def save(self) -> \\\"BaseModel\\\":\\n try:\\n db.session.add(self)\\n db.session.commit()\\n return self\\n\\n except Exception as e:\\n db.session.rollback()\\n descripted_exception_logger(e)\\n raise\",\n \"def save(self, obj):\\n raise NotImplementedError\",\n \"def save(self):\\n\\t\\tdb.session.add(self)\\n\\t\\tdb.session.commit()\\n\\t\\treturn self\",\n \"def save_data(self):\\n db.session.add(self)\\n db.session.commit( )\",\n \"def save(self, *args, **kwargs):\\n super(self.__class__, self).save(*args, **kwargs)\",\n \"def save_model(self, path):\\n self._model.save(path)\",\n \"def save(path_to_model):\\n pass\",\n \"def _update(self, model_obj: Any):\\n conn = self.provider.get_connection()\\n\\n identifier = model_obj.meta.id\\n\\n # Fetch the record from database\\n try:\\n # Calling `get` will raise `NotFoundError` if record was not found\\n self.model_cls.get(\\n id=identifier, using=conn, index=self.model_cls._index._name\\n )\\n except NotFoundError as exc:\\n logger.error(f\\\"Database Record not found: {exc}\\\")\\n raise ObjectNotFoundError(\\n {\\n \\\"_entity\\\": f\\\"`{self.entity_cls.__name__}` object with identifier {identifier} \\\"\\n f\\\"does not exist.\\\"\\n }\\n )\\n\\n try:\\n model_obj.save(\\n refresh=True,\\n index=self.model_cls._index._name,\\n using=conn,\\n )\\n except Exception as exc:\\n logger.error(f\\\"Error while creating: {exc}\\\")\\n raise\\n\\n return model_obj\",\n \"def _save(self, step, model):\\n\\n raise NotImplementedError()\",\n \"def save(self):\\n data = self.serialize()\\n\\n self.validate(data)\\n\\n saved_data = DATABASE_CONNECTION.insert(self.__class__.__name__, data)\\n\\n self.__dict__.update(saved_data)\",\n \"def save(self):\\n\\n pass\",\n \"def save(self) -> None:\\n pass\",\n \"def save(self) -> None:\\n pass\",\n \"def save(self) -> None:\\n pass\",\n \"def save(self, *args, **kwargs):\\n pass\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save(self, *args, **kwargs) -> None:\\n pass\",\n \"def save(self, obj):\",\n \"def save(self):\\n print(\\\"==> Saving model to\\\", self.model_dir)\\n self.model.save(self.model_dir)\",\n \"def save(self):\\n if self.id is None:\\n self._insert()\\n else:\\n self._update()\",\n \"def save(\\n self,\\n modelSavePath\\n ):\\n pass\",\n \"def save(self, *args, **kwargs):\\n return\",\n \"def save(self):\\n if self.iid is not None:\\n self.db().update(self.iid, self._attributes)\\n else:\\n self.iid = self.db().add(self._attributes)\",\n \"def save(self):\\n try:\\n self.__session.commit()\\n except Exception:\\n self.__session.rollback()\\n finally:\\n self.__session.close()\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save (self):\\n pass\",\n \"def save_db(self) -> None:\",\n \"def _create(self, model_obj):\\n conn = self._get_session()\\n\\n try:\\n conn.add(model_obj)\\n except DatabaseError as exc:\\n logger.error(f\\\"Error while creating: {exc}\\\")\\n raise\\n finally:\\n if not current_uow:\\n conn.commit()\\n conn.close()\\n\\n return model_obj\",\n \"def saveModel(self):\\n log.info(\\\"Saving model to %s...\\\" % self.savedModelsPath)\\n self.model.save(self.savedModelsPath)\",\n \"def save(self):\\n pk = self.get_pk()\\n if pk and not self._is_new_record and self._edited_fields:\\n set_vars = self.get_field_dict(fields=self._edited_fields)\\n self.update(**set_vars).filter(**{self.get_pk_name(): pk}).execute()\\n elif self._is_new_record:\\n insert_vars = self.get_field_dict()\\n if self._meta.auto_increment:\\n insert_vars.pop(self.get_pk_name())\\n new_pk = self.insert(**insert_vars).execute()\\n if self._meta.auto_increment:\\n self.set_pk(new_pk)\\n self.set_new_record_state(False)\\n elif not pk and not self._is_new_record:\\n raise ValueError('[Model.save] Primary key is not defined ' +\\n 'while the data is stored')\\n self._edited_fields.clear()\",\n \"def save(self, *args, **kwargs):\\n super().save(*args, **kwargs)\",\n \"def save(self, *args, **kwargs):\\n super().save(*args, **kwargs)\",\n \"def save(self):\\n # type: () -> bool\\n\\n return self.query.commit(self.id, self)\",\n \"def save(self):\\n try:\\n db.session.add(self)\\n db.session.commit()\\n return True\\n except SQLAlchemyError as error_message:\\n app_logger.error(error_message)\\n return False\",\n \"def save(self):\\n if not self.id:\\n self.id = uuid4()\\n DataStore.add_instance(self)\",\n \"def save_now(self):\\r\\n self.save()\",\n \"def save_now(self):\\r\\n self.save()\",\n \"def save(self):\\n try:\\n db.session.add(self)\\n db.session.commit()\\n return True\\n except SQLAlchemyError as e:\\n db.session.rollback()\\n logger.error(\\\"database operation error: \\\", e)\\n return False\",\n \"def save_model(self, path):\\n pass\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def save(self, context=None):\\n updates = self.obj_get_changes()\\n self.dbapi.update_boar(context, self.id, updates)\\n self.obj_reset_changes()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77996397","0.7456527","0.7434235","0.7422407","0.73011315","0.7194706","0.7194706","0.7194706","0.7194706","0.71695006","0.71580917","0.71512944","0.7132259","0.7122476","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.7114611","0.71057785","0.71057785","0.70874846","0.7060354","0.7060354","0.7060354","0.7060354","0.7060354","0.7060354","0.7060354","0.7060354","0.7048197","0.7020225","0.7007692","0.69859785","0.6955979","0.69544464","0.6952653","0.6898017","0.6886996","0.6876487","0.6839004","0.68022954","0.6794","0.67574686","0.6721868","0.6718128","0.6702298","0.66948086","0.66900307","0.66874784","0.66129935","0.66036075","0.659586","0.6590969","0.6590192","0.6583278","0.6562705","0.6561408","0.6541362","0.6541362","0.6541362","0.6536909","0.65343547","0.65343547","0.65343547","0.6530806","0.65161026","0.6514626","0.65071756","0.6473535","0.64648837","0.6463307","0.644634","0.644634","0.644634","0.644634","0.644634","0.64271957","0.6385594","0.63751954","0.6373962","0.6372621","0.6361066","0.6361066","0.63401103","0.6339905","0.63298756","0.6323057","0.6323057","0.63141567","0.6301236","0.62970966","0.62970966","0.62970966","0.6286437"],"string":"[\n \"0.77996397\",\n \"0.7456527\",\n \"0.7434235\",\n \"0.7422407\",\n \"0.73011315\",\n \"0.7194706\",\n \"0.7194706\",\n \"0.7194706\",\n \"0.7194706\",\n \"0.71695006\",\n \"0.71580917\",\n \"0.71512944\",\n \"0.7132259\",\n \"0.7122476\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.7114611\",\n \"0.71057785\",\n \"0.71057785\",\n \"0.70874846\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7060354\",\n \"0.7048197\",\n \"0.7020225\",\n \"0.7007692\",\n \"0.69859785\",\n \"0.6955979\",\n \"0.69544464\",\n \"0.6952653\",\n \"0.6898017\",\n \"0.6886996\",\n \"0.6876487\",\n \"0.6839004\",\n \"0.68022954\",\n \"0.6794\",\n \"0.67574686\",\n \"0.6721868\",\n \"0.6718128\",\n \"0.6702298\",\n \"0.66948086\",\n \"0.66900307\",\n \"0.66874784\",\n \"0.66129935\",\n \"0.66036075\",\n \"0.659586\",\n \"0.6590969\",\n \"0.6590192\",\n \"0.6583278\",\n \"0.6562705\",\n \"0.6561408\",\n \"0.6541362\",\n \"0.6541362\",\n \"0.6541362\",\n \"0.6536909\",\n \"0.65343547\",\n \"0.65343547\",\n \"0.65343547\",\n \"0.6530806\",\n \"0.65161026\",\n \"0.6514626\",\n \"0.65071756\",\n \"0.6473535\",\n \"0.64648837\",\n \"0.6463307\",\n \"0.644634\",\n \"0.644634\",\n \"0.644634\",\n \"0.644634\",\n \"0.644634\",\n \"0.64271957\",\n \"0.6385594\",\n \"0.63751954\",\n \"0.6373962\",\n \"0.6372621\",\n \"0.6361066\",\n \"0.6361066\",\n \"0.63401103\",\n \"0.6339905\",\n \"0.63298756\",\n \"0.6323057\",\n \"0.6323057\",\n \"0.63141567\",\n \"0.6301236\",\n \"0.62970966\",\n \"0.62970966\",\n \"0.62970966\",\n \"0.6286437\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84672,"cells":{"query":{"kind":"string","value":"NotifyReviewEvent returns comments for a ReviewEvent."},"document":{"kind":"string","value":"def NotifyReviewEvent(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')"},"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_review_comments_body(\n self, pull_request_number: int) -> List[Tuple[str, str]]:\n review_comments = get_pull_request_review_comments(\n self._repo_name, pull_request_number, self._auth)\n if not review_comments:\n return []\n review_comments_msg = []\n for comment in review_comments:\n review_comments_msg.append((comment['path'], comment['body']))\n return review_comments_msg","def _prepare_comment_added_template(self, event):\n from string import Template\n tpl = Template(self.__comment_added_template)\n return tpl.substitute(\n comment_author_name=event[\"author\"][\"name\"],\n comment_author_email=event[\"author\"][\"email\"],\n comment=event[\"comment\"],\n change_url=event[\"change\"][\"url\"],\n change_subject=event[\"change\"][\"subject\"],\n approvals_verified_value=event[\"approvals\"][0][\"value\"], # FIX idx\n approvals_review_value=event[\"approvals\"][1][\"value\"], # FIX idx\n change_owner_name=event[\"change\"][\"owner\"][\"name\"],\n change_owner_email=event[\"change\"][\"owner\"][\"email\"],\n change_number=event[\"change\"][\"number\"],\n change_project=event[\"change\"][\"project\"],\n change_id=event[\"change\"][\"id\"],\n change_branch=event[\"change\"][\"branch\"],\n patchset_uploader_name=event[\"patchSet\"][\"uploader\"][\"name\"],\n patchset_uploader_email=event[\"patchSet\"][\"uploader\"][\"email\"],\n patchset_revision=event[\"patchSet\"][\"revision\"],\n patchset_number=event[\"patchSet\"][\"number\"],\n patchset_ref=event[\"patchSet\"][\"ref\"],\n patchset_created_on=event[\"patchSet\"][\"createdOn\"]\n )","def get_comments(self):\n\t\treturn self._client.get_comments(self)","def invoice_history_comments(invoice):\n history = Invoice.history.filter(id=invoice.id)\n record = history.last()\n comments = []\n while record.next_record:\n next_record = record.next_record\n delta = next_record.diff_against(record)\n message = _('Changed: \\n')\n for change in delta.changes:\n if change.field not in AVOID_COMMENTS:\n if change.field != 'status':\n old_value = change.old\n new_value = change.new\n else:\n old_value = get_status_display(change.old)\n new_value = get_status_display(change.new)\n message += _('{} from {} to {}\\n').format(\n Invoice._meta.get_field(change.field).verbose_name,\n old_value,\n new_value,\n )\n if next_record.history_change_reason:\n message += gettext('\\nChange reason:\\n')\n message += next_record.history_change_reason\n if message != _('Changed: \\n'):\n comment = Comment(\n user=next_record.history_user,\n invoice=next_record.instance,\n message=message,\n comment_date_received=next_record.history_date\n )\n comments.append(comment)\n record = next_record\n return comments","def get_comments(self, visitor = None):\n if visitor.is_anonymous():\n return self.comments.all().order_by('id')\n else:\n comment_content_type = ContentType.objects.get_for_model(Comment)\n #a fancy query to annotate comments with the visitor votes\n comments = self.comments.extra(\n select = SortedDict([\n (\n 'upvoted_by_user',\n 'SELECT COUNT(*) from vote, comment '\n 'WHERE vote.user_id = %s AND '\n 'vote.content_type_id = %s AND '\n 'vote.object_id = comment.id',\n )\n ]),\n select_params = (visitor.id, comment_content_type.id)\n ).order_by('id')\n return comments","def get_repo_review_comments(owner, repo, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/comments'\n return get_one_item_at_a_time(url, session=session)","def get_comments(self):\n raise NotImplementedError","def get_comments(self, resp):\n comments = CommentList()\n for value in resp['comments']:\n comment = Comment()\n comment.set_comment_id(value['comment_id'])\n comment.set_expense_id(value['expense_id'])\n comment.set_description(value['description'])\n comment.set_commented_by_id(value['commented_by_id'])\n comment.set_commented_by(value['commented_by'])\n comment.set_date(value['date'])\n comment.set_date_description(value['date_description'])\n comment.set_time(value['time'])\n comment.set_operation_type(value['operation_type'])\n comment.set_transaction_id(value['transaction_id'])\n comment.set_transaction_type(value['transaction_type'])\n comments.set_comments(comment)\n return comments","def comment_added(self, event):\n import simplejson\n comment = str(event[\"comment\"])\n author_name = str(event[\"author\"][\"name\"])\n change_url = str(event[\"change\"][\"url\"])\n change_subject = str(event[\"change\"][\"subject\"])\n comment = simplejson.dumps({\n \"issue\": {\n \"notes\": self._prepare_comment_added_template(event)\n }\n })\n # get a unique list of issue IDs\n subject_issue_ids = self.__get_issue_ids(change_subject)\n comment_issue_ids = self.__get_issue_ids(comment)\n issue_ids = list(set(subject_issue_ids + comment_issue_ids))\n for issue_id in issue_ids:\n self.__add_comment(issue_id, comment)","def comments(self) -> list:\n return self._node[\"app_data\"][\"ui_data\"].get(\"comments\", [])","def process_review_event(self, request: ReviewEvent) -> EventResponse: # noqa: D401\n base_ptr = ReferencePointer.from_pb(request.commit_revision.base)\n head_ptr = ReferencePointer.from_pb(request.commit_revision.head)\n response = EventResponse()\n response.analyzer_version = self.version\n comments = []\n for analyzer in self._analyzers:\n try:\n mycfg = self._protobuf_struct_to_dict(request.configuration[analyzer.name])\n self._log.info(\"%s config: %s\", analyzer.name, mycfg)\n except (KeyError, ValueError):\n mycfg = {}\n self._log.debug(\"no config was provided for %s\", analyzer.name)\n if analyzer.model_type != DummyAnalyzerModel:\n model = self._get_model(analyzer, base_ptr.url)\n if model is None:\n self._log.info(\"training: %s\", analyzer.name)\n record_event(\"%s.train\" % analyzer.name, 1)\n model = analyzer.train(base_ptr, mycfg, self._data_service)\n self._model_repository.set(self._model_id(analyzer), base_ptr.url, model)\n else:\n model = DummyAnalyzerModel()\n self._log.debug(\"running %s\", analyzer.name)\n record_event(\"%s.analyze\" % analyzer.name, 1)\n results = analyzer(model, head_ptr.url, mycfg).analyze(\n base_ptr, head_ptr, self._data_service)\n self._log.info(\"%s: %d comments\", analyzer.name, len(results))\n record_event(\"%s.comments\" % analyzer.name, len(results))\n comments.extend(results)\n response.comments.extend(comments)\n return response","def comments(self):\n comments_url = self.data['comments_url']\n return json.load(urllib2.urlopen(comments_url))","def getComment(self, n = None):\n \n if n is None:\n return self._comments\n else:\n return self._comments[n]","def list_comments_history(self, expense_id):\n url = base_url + expense_id + '/comments'\n resp = zoho_http_client.get(url, self.details, self.headers)\n return parser.get_comments(resp)","def comments(self):\n return self.container['comments']","def get_comments(comments):\n API_KEY = secrets.YT_KEY\n youtube = build('youtube', 'v3', developerKey=API_KEY)\n request = youtube.commentThreads().list(\n part='replies',\n videoId=comments,\n textFormat=\"plainText\"\n )\n\n response = request.execute()\n\n video = response['items'][0]['replies']['comments']\n\n\n for i in video:\n print('\\n')\n print(i['snippet']['textDisplay'])\n # print(response['items'][0].keys())","def get_review(self, language):\n comment_generator = CommentGenerator(language)\n return comment_generator.generateComment()","def notify_comment(**kwargs): # pragma: no cover\n actor = kwargs[\"request\"].user\n receiver = kwargs[\"comment\"].content_object.user\n obj = kwargs[\"comment\"].content_object\n notification_handler(actor, receiver, Notification.COMMENTED, action_object=obj)","def get_comments(self):\n url = \"https://api.imgur.com/3/gallery/{0}/comments\".format(self.id)\n resp = self._imgur._send_request(url)\n return [Comment(com, self._imgur) for com in resp]","def get_comment(self, index):\r\n\r\n # Get request to get all the comments for all exercises\r\n comments = requests.get(API.url_comment, headers = self.headers).json()\r\n # Parse the response\r\n for my_comment in comments:\r\n if my_comment['id'] == index:\r\n print(my_comment['comment'])","def comments(self):\n return self._comments","def comments(self):\n return self._comments","def get_review_comments_for_pr(owner, repo, pr_number, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\n return get_one_item_at_a_time(url, session=session)","def do_comments(self, line):\n for comment in self.review.comments():\n print(comment)","def get_comments(self):\n\t\tself.comments = graph.get_connections(post['id'], 'comments')","def on_issue_comment(self, payload):\n pass","def reactions(self, request, *args, **kwargs):\n comment = self.get_object()\n reactions = ReactionComment.objects.filter(comment=comment)\n serializer = ReactionCommentModelSummarySerializer(\n reactions, many=True)\n return Response(serializer.data, status=status.HTTP_200_OK)","def get_comments(yt_id):\n\n client = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,developerKey=DEVELOPER_KEY)\n\n video_comments = client.commentThreads().list(\n videoId = yt_id,\n part=\"snippet,replies\").execute()\n\n comment_items = video_comments['items']\n\n class MLStripper(HTMLParser):\n def __init__(self):\n self.reset()\n self.strict = False\n self.convert_charrefs= True\n self.fed = []\n def handle_data(self, d):\n self.fed.append(d)\n def get_data(self):\n return ''.join(self.fed)\n\n def strip_tags(html):\n s = MLStripper()\n s.feed(html)\n return s.get_data()\n\n comments = []\n for sub_block in comment_items:\n comments.append(strip_tags(sub_block['snippet']['topLevelComment']['snippet']['textDisplay']))\n\n comments_all = ' '.join(comments)\n\n print(\"YouTube comments scanned\")\n return comments_all","def on_review_reply(request: Request):\n initialize()\n request_json = request.get_json(force=True, silent=True)\n update = decode_update(request_json)\n dispatcher.process_update(update)\n return \"\"","def get_comments(self, ticket_id):\n response = self.http_call(\"{0}/tickets/{1}/comments.json\".format(self.uri, ticket_id))\n return json.loads(response.content.decode(sys.stdout.encoding, \"replace\"))","def get_comments(self,comments):\n all_comments = []\n for comment in comments:\n try :\n all_comments.append({\n 'comment':comment['data']['body'],\n 'score':comment['data']['score']\n })\n except: pass\n return all_comments","def GetChangeReview(host, change, revision='current'):\n path = '%s/revisions/%s/review' % (_GetChangePath(change), revision)\n return FetchUrlJson(host, path)","def test_issue_get_comment_reactions(self):\n pass","def api_draft_comments(request):\n try:\n def sanitize(comment):\n patch = models.Patch.get_by_id(int(comment.patch_id),\n parent=request.patchset.key)\n assert not patch is None\n message_id = str(comment.message_id) if message_id in comment else None,\n return {\n user: request.user,\n issue: request.issue,\n patch: patch,\n lineno: int(comment.lineno),\n left: bool(comment.left),\n text: str(comment.text),\n message_id: message_id,\n }\n return [\n {message_id: _add_or_update_comment(**comment).message_id}\n for comment in map(sanitize, json.load(request.data))\n ]\n except Exception as err:\n return HttpTextResponse('An error occurred.', status=500)","def get_comments(convo_ID):\n # Make API request\n url = \"https://api2.frontapp.com/conversations/\" + convo_ID + \"/comments\"\n payload = {}\n headers = {\"Authorization\": BEARER_TOKEN}\n response = requests.request(\"GET\", url, headers=headers, data=payload)\n for comment in response.json()[\"_results\"]:\n # For each comment in Front, print out its message\n print_friendly_JSON_object(comment[\"body\"])","def get_comments(self):\n url = \"https://api.imgur.com/3/account/{0}/comments\".format(self.name)\n resp = self._imgur._send_request(url)\n return [Comment(com, self._imgur) for com in resp]","def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\n if project_name == PROJECT_ALL:\n # comments in changes across all projects after from_datetime\n comments = reviewer.comments.filter(\n timestamp__gte=from_datetime).distinct()\n else:\n # comments in changes in given project after from_datetime\n comments = reviewer.comments.filter(\n change__project_name=project_name,\n timestamp__gte=from_datetime).distinct()\n\n return comments.count()","def reviews(self):\n reviewList = []\n for review in storage.all(Review).values():\n if review.getattr('place_id') == self.id:\n reviewList.append(review)\n return(reviewList)","def get_comment_obj(self, videoId):\n response = self.build_service()\n\n # you only need to build the service once\n # collect all comments\n \n response2 = response.commentThreads().list(\n part='snippet',\n maxResults=100,\n textFormat='plainText',\n order='time',\n videoId=videoId,\n\n ).execute()\n\n return response2","def get_previous_pr_comments(pr_id):\n relevant_comments = get_status_json(pr_id, 'comments')\n\n comments = [Comment(c[\"body\"], datetime.fromisoformat(c['createdAt'].strip('Z')), c['author']['login'])\n for c in relevant_comments]\n return comments","def reviews(self) -> object:\n return self._reviews","def calc_comments(self):\n for comment in self.pull_request.get_comments():\n self._users.add(comment.user.login)\n lowercase_body = comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_comments += 1\n if comment.body is not None:\n self.len_comments += len(comment.body)\n for reaction in comment.get_reactions():\n self._users.add(reaction.user.login)\n self.comment_reactions += 1","def problem_comments(self, identifier):\n return self._get(\"problems/%d/comments\" % identifier).json()","def get(self,event_id,timestamp,limit):\n # ensure that limit is an integer!!!\n if len(event_id) != 32:\n self.set_status(400)\n self.write_json({\n 'result' : []\n })\n try:\n int(timestamp)\n limit = int(limit)\n except:\n self.set_status(400)\n self.write_json({\n 'result' : []\n })\n if limit <= 10 or limit >= 20:\n self.write_json_with_status(400,{\n 'result' : 'fail',\n 'reason' : 'limit is too low or too high'\n })\n\n comments = self.event_comment_table.scan(\n EventID__eq=event_id,\n Timestamp_le=timestamp,\n limit=limit\n )\n\n response = []\n for comment in comments:\n response.append(comment)\n\n if len(response) == 0:\n self.write_json({\n 'result' : [],\n })\n\n else:\n # assure comment from latest to early time\n response = sorted(\n response,\n key=attrgetter('Timestamp'),\n reverse=True)\n\n self.write_json({\n 'result' : response,\n 'new_timestamp' : response[-1]['Timestamp']\n })","def GetChangeReviewers(host, change):\n path = '%s/reviewers' % _GetChangePath(change)\n return FetchUrlJson(host, path)","def test_get_comments():\n comments = list(get_comments(TEST_SUBREDDIT, TEST_START_DATE, TEST_END_DATE, TEST_MAX))\n\n # prints the dictionary of variables for each comment\n for x in comments:\n print(x.d_)","def review(self):\n return self._review","def get_comments(subreddit, start_date, end_date, limit):\n api = PushshiftAPI()\n return api.search_comments(after=start_date, before=end_date,\n subreddit=subreddit, limit=limit\n # , filter=['author', 'body', 'created_utc', 'nest_level']\n )","def _get_comments(self, issue_id):\n data = self._get(\"/issues/{}/comments\".format(issue_id))\n comments = []\n for item in data:\n comments.append(\n Comment(item['user']['login'], item['body'])\n )\n return comments","def _get_issue_comments_body(self, pull_request_number: int) -> List[str]:\n issue_comments = get_pull_request_issue_comments(\n self._repo_name, pull_request_number, self._auth)\n if not issue_comments:\n return []\n issue_comments_msg = []\n for comment in issue_comments:\n issue_comments_msg.append(comment['body'])\n return issue_comments_msg","def get_comments(video_id, CLIENT_SECRETS_FILE):","def comment_added(self, event):\n pass","def send_idea_comment_notification(comment_id: int) -> None:\n logger = logging.getLogger()\n logger.info('Sending notifications for comment #%s', comment_id)\n\n # Task will fail if comment is not found\n comment = Comment.objects.get(id=comment_id)\n\n recipients = _get_recipients(comment)\n if not recipients:\n return\n\n # Transform to plain email list\n recipients_emails = {recipient.email for recipient in recipients}\n\n _send_email(comment, recipients_emails)","def order_reviews(self, reviews):\n return reviews","def reviews(self):\n list_reviews = []\n all_reviews = models.storage.all(Review)\n for review_item in all_reviews.items():\n if review_item.place_id == self.id:\n list_review.append(review_item)\n\n return list_review","def comments(self, request, pk=None):\n post = self.get_object()\n comments = Comment.objects.filter(post=post).order_by('created_at')\n serializer = PostCommentsSerializer(comments, many=True)\n return Response(serializer.data, status.HTTP_200_OK)","def comments(self):\r\n return c.Comments(self)","def comments(self):\r\n return c.Comments(self)","def comments(self):\r\n return c.Comments(self)","def question_comments(request, question, form=None):\n populate_foreign_key_caches(User, (\n ((question,), ('author', 'last_edited_by', 'closed_by')),\n ),\n fields=('username', 'gravatar', 'reputation', 'gold', 'silver',\n 'bronze'))\n\n content_type = ContentType.objects.get_for_model(Question)\n comments = Comment.objects.filter(content_type=content_type,\n object_id=question.id)\n\n if form is None:\n form = CommentForm()\n\n return render_to_response('question.html', {\n 'title': u'Comments on %s' % question.title,\n 'question': question,\n 'tags': question.tags.all(),\n 'comments': comments,\n 'comment_form': form,\n }, context_instance=RequestContext(request))","async def scrape_comments(self):\n\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\n\n comment_count = 0\n async for comment in subreddit_origin.comments(limit=self.limit):\n if self.memory.contains(comment.id):\n continue\n\n self.memory.add(comment.id)\n\n # Parse Comment\n comment = self.parse_comment(comment)\n\n # Save in Pub/Sub\n if self.enable_publish:\n self.publish(comment)\n\n comment_count += 1\n\n return comment_count","def notify(self, event):\n for observer in self.observers:\n observer.on_notify(event)","def notify(self, event):\n for observer in self.observers:\n observer.on_notify(event)","def notify(self, event):\n for o in self.observers:\n o.on_notify(event)","def comments(self):\r\n return comments.ForumSuggestionComments(self)","def get_discussion_comments(self, post_id):\n query = \"SELECT users.Username , discussionreplies.* FROM discussionreplies INNER JOIN users ON (discussionreplies.Users_idUsers=users.idUsers) WHERE Discussions_idDiscussions={}\".format(post_id)\n cursor = DB.instance.connection.cursor()\n cursor.execute(query)\n return cursor.fetchall()","def generate_html_reviews_email(event, recommendations):\n pull_request_id = event['PullRequestId']\n lines_scanned = event['Metrics']['MeteredLinesOfCodeCount']\n recommendations_found = event['Metrics']['FindingsCount']\n recommendations_html_table_contents = [\n f\"\"\"\n <tr>\n <td>{recommendation['FilePath']}</td>\n <td>{recommendation['StartLine']}</td>\n <td>{recommendation['EndLine']}</td>\n <td>{recommendation['Description']}</td>\n </tr>\n \"\"\"\n for recommendation in recommendations\n ]\n recommendations_html_table = '\\n'.join(recommendations_html_table_contents)\n html_body = f\"\"\"\n <!DOCTYPE html>\n <html>\n <head>\n </head>\n <body>\n <p>Hi team,</p>\n <p>Amazon CodeGuru Reviewer has completed the review of {pull_request_id}, \n scanning {lines_scanned} and found {recommendations_found} of recommendations.</p>\n <p>See Table below for the recommendations, and review the BUSINESS LOGIC in the pull request</p>\n <table style=\"width:100%\">\n <tr>\n <th>File Path</th>\n <th>Start Line</th>\n <th>End Line</th>\n <th>Description/Recommendation</th>\n </tr>\n {recommendations_html_table}\n </table>\n </body>\n </html>\n \"\"\"\n return html_body","def get_review_request(self, rid):\r\n rsp = self.api_call('api/review-requests/%s/' % rid)\r\n return rsp['review_request']","def lambda_handler(event, context):\n code_review_arn = event['CodeReviewArn']\n response = codeguru_reviewer.list_recommendations(\n MaxResults=50,\n CodeReviewArn=code_review_arn\n )\n recommendation_summaries = response['RecommendationSummaries']\n num_of_reviews = event['Metrics']['FindingsCount']\n repo_name = event['RepositoryName']\n pr_id = event['PullRequestId']\n html_body = generate_html_reviews_email(event, recommendation_summaries)\n email_subject = 'Hey team, Amazon CodeGuru Reviewer found {num_of_reviews} in the {repo_name} PR: {pr_id}'.format(\n num_of_reviews=num_of_reviews,\n repo_name=repo_name,\n pr_id=pr_id\n )\n sns.publish(\n TopicArn=CODEGURU_SNS_TOPIC,\n Message=html_body,\n Subject=email_subject\n )","def comments(self):\r\n return RepoCommitsComments(self.parent)","def reviews(self):\n list_reviews = []\n place_reviews = models.engine.all(Review)\n for pl_reviews in place_reviews.values():\n if pl_reviews.place_id == self.id:\n list_reviews.append(pl_reviews)\n return list_reviews","def get_reviews(recipe_id=None):\n\n recipe = storage.get(Recipe, recipe_id)\n print(recipe)\n if not recipe:\n abort(404)\n reviews = []\n for review in recipe.reviews:\n reviews.append(review.to_dict())\n return jsonify(reviews)","def calc_conv_comments(self):\n for conv_comment in self.pull_request.get_issue_comments():\n self._users.add(conv_comment.user.login)\n lowercase_body = conv_comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_conv_comments += 1\n for reaction in conv_comment.get_reactions():\n self._users.add(reaction.user.login)\n self.conv_comment_reactions += 1\n if conv_comment.body is not None:\n self.len_issue_comments += len(conv_comment.body)","def get_comments(self, project, story):\n ret_val = []\n resource = \"projects/{0:d}/stories/{1:d}/comments\".format(project.id,\n story.id)\n params = {\"fields\": Comment.FIELDS}\n comments = self._request(\"get\", resource, params=params)\n\n for comment in comments:\n ret_val.append(Comment(comment))\n\n return ret_val","def fetch_review(self):\n c = self.db.cursor()\n c.execute(\"\"\"SELECT * FROM cards\n WHERE date_last_reviewed < (DATETIME('now', 'localtime', '-8 hours'))\n OR correct = 0\"\"\")\n rows = c.fetchall()\n cards = [\n Card(\n id=id,\n card_type=card_type,\n text=text,\n created=created,\n uri=uri,\n updated=updated,\n difficulty=difficulty,\n days_between=days_between,\n date_last_reviewed=date_last_reviewed,\n correct=correct,\n )\n for id, card_type, text, uri, created, updated, difficulty, days_between, date_last_reviewed, correct in rows\n ]\n cards = filter(lambda card: card.percent_overdue >= 1, cards)\n cards = sorted(cards, key=lambda card: card.percent_overdue)\n\n return cards[:20]","def get_notifications(self):\n return self.ws.events['notifications']","def approvals_comments_list(self, mar, request):\n issue = self._services.issue.GetIssueByLocalID(\n mar.cnxn, mar.project_id, request.issueId)\n if not permissions.CanViewIssue(\n mar.auth.effective_ids, mar.perms, mar.project, issue,\n mar.granted_perms):\n raise permissions.PermissionException(\n 'User is not allowed to view this issue (%s, %d)' %\n (request.projectId, request.issueId))\n config = self._services.config.GetProjectConfig(mar.cnxn, issue.project_id)\n approval_fd = tracker_bizobj.FindFieldDef(request.approvalName, config)\n if not approval_fd:\n raise endpoints.BadRequestException(\n 'Field definition for %s not found in project config' %\n request.approvalName)\n comments = self._services.issue.GetCommentsForIssue(\n mar.cnxn, issue.issue_id)\n comments = [comment for comment in comments\n if comment.approval_id == approval_fd.field_id]\n visible_comments = []\n for comment in comments[\n request.startIndex:(request.startIndex + request.maxResults)]:\n visible_comments.append(\n api_pb2_v1_helpers.convert_approval_comment(\n issue, comment, mar, self._services, mar.granted_perms))\n\n return api_pb2_v1.ApprovalsCommentsListResponse(\n kind='monorail#approvalCommentList',\n totalResults=len(comments),\n items=visible_comments)","def comments(self):\r\n return RepoCommitsComments(self)","def comments(self, limit=100, all=False):\n source, edge = self.id, \"comments\"\n return lazygen(Comment, source, edge,\n limit=limit, get_all=all)","def comments(self, comments):\n\n self.container['comments'] = comments","def _get_information(self):\n reviews = self._tab.find_all(\"div\", class_=\"review\", attrs={'itemprop': 'review'})\n return [(self._get_review(elem), self._get_published_date(elem)) for elem in reviews]","def get_user_reviews(self):\n raw_review_data = imdb.get_title_user_reviews(self.ID) # Returns dictionary of dicts\n reviews_dict = raw_review_data['reviews'] # Stores the dictionary of reviews\n for dictionary in reviews_dict:\n self.user_reviews.append(dictionary['reviewText'])\n # Appends review text to list\n self._review_printer() # Calls printer to output reviews","def _comment():\r\n id = request.args.get('answer_id')\r\n per_page=current_app.config['FLASKY_ANSWERS_PER_PAGE']\r\n answer = Answer.query.get_or_404(id)\r\n page = request.args.get('page', type=int, default=1)\r\n comment =request.args.get('comment')\r\n if current_user.can(Permission.COMMENT) and comment is not None:\r\n comment = Comment(body=comment,\r\n author=current_user._get_current_object(),\r\n answer_id=id)\r\n db.session.add(comment)\r\n db.session.commit()\r\n page = -1\r\n if page == -1:\r\n page = answer.comments.count() / per_page\r\n pagination = Comment.query.order_by(Comment.timestamp).filter_by(answer_id=id).paginate(\r\n page,per_page=per_page,error_out=False\r\n )\r\n macro_comment = get_template_attribute(\"_comments.html\", \"render_comments\")\r\n macro_page = get_template_attribute(\"_page.html\", \"render_page\")\r\n comments = pagination.items\r\n return jsonify({'result': True,\r\n 'comment_html': macro_comment(comments),\r\n 'page_html':macro_page(pagination),\r\n 'comments_timestamp':[comment.timestamp for comment in comments],\r\n 'comments_id':[comment.id for comment in comments]\r\n })","def review(self) -> object:\n return self._review","def get_video_comments(self):\n other_user_email = request.args.get('other_user_email')\n video_title = request.args.get('video_title')\n if not other_user_email or not video_title:\n self.logger.debug(messages.MISSING_FIELDS_ERROR % \"query params\")\n return messages.ERROR_JSON % messages.MISSING_FIELDS_ERROR % \"query params\", 400\n users_data, comments = self.video_database.get_comments(other_user_email, video_title)\n response = [{\"user\": u,\n \"comment\": {\"content\":c.content, \"timestamp\": c.timestamp.isoformat()}}\n for u,c in zip(users_data, comments)]\n return json.dumps(response), 200","def comments(self):\r\n return IssueComments(self)","def comments(self):\r\n return IssueComments(self)","def post_review(self, form):\n comments_file = form.cleaned_data.get('comments', None)\n return_code = form.cleaned_data.get('return_code', None)\n\n # Update the review\n self.object.post_review(comments_file, return_code=return_code)\n if return_code:\n self.revision.return_code = return_code\n\n verb = None\n # If every reviewer has posted comments, close the reviewers step\n if self.object.role == 'reviewer':\n qs = Review.objects \\\n .filter(document=self.document) \\\n .filter(revision=self.revision.revision) \\\n .filter(role='reviewer') \\\n .exclude(closed_on=None)\n if qs.count() == self.revision.reviewers.count():\n self.revision.end_reviewers_step(save=False)\n verb = Activity.VERB_CLOSED_REVIEWER_STEP\n\n # If leader, end leader step\n elif self.object.role == 'leader':\n self.revision.end_leader_step(save=False)\n verb = Activity.VERB_CLOSED_LEADER_STEP\n\n # If approver, end approver step\n elif self.object.role == 'approver':\n self.revision.end_review(save=False)\n verb = Activity.VERB_CLOSED_APPROVER_STEP\n\n self.revision.save(update_document=True)\n\n if verb:\n activity_log.send(verb=verb,\n target=self.revision,\n sender=do_batch_import,\n actor=self.request.user)","def getAll(self, event_name):\n raw_events = self._callEventGetAll(self._id, event_name)\n return [snippet_event.from_dict(msg) for msg in raw_events]","def GetReviewers(host, change):\n path = '%s/reviewers' % _GetChangePath(change)\n return FetchUrlJson(host, path)","async def get_history_by_comment(request):\n try:\n comment_id = int(request.match_info.get('comment_id'))\n except ValueError:\n raise web.HTTPBadRequest(reason=\"Field 'comment_id' should be int\")\n\n rows = await CommentHistoryDAO(request['conn']).get_by_comment(comment_id)\n return web.json_response(rows)","def notify_participant_event_decision(request, user, event, decision, comment_to_applicant):\n\n subject = f\"{settings.SITE_NAME} Event Registration Decision\"\n context = {\n 'name': user.get_full_name(),\n 'domain': get_current_site(request),\n 'url_prefix': get_url_prefix(request),\n 'event_title': event.title,\n 'event_url': reverse('event_detail', args=[event.slug]),\n 'decision': decision,\n 'comment_to_applicant': comment_to_applicant,\n 'SITE_NAME': settings.SITE_NAME,\n }\n body = loader.render_to_string('events/email/event_participation_decision.html', context)\n # Not resend the email if there was an integrity error\n send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False)","def get_comments(self, post_id, post_type):\n\n try:\n if not post_id or not post_type:\n raise Exception('Invalid parameter')\n if post_type != 'question' and post_type != 'answer':\n raise Exception('Invalid parameter')\n\n url = BASE_URL + 'post_comments/'\n url += '?' + urllib.parse.urlencode({'post_id': int(post_id), 'post_type': post_type})\n response = self.request('GET', url, is_ajax=True)\n response = response.json()\n output = []\n for item in response:\n output.append(self._convert_comment(item))\n return output\n except Exception as e:\n Utils.log(traceback.format_exc())\n Utils.error(e.args[0])","def _get_draft_details(request, comments):\n last_key = None\n output = []\n linecache = {} # Maps (c.patch_key, c.left) to mapping (lineno, line)\n modified_patches = []\n fetch_base_failed = False\n\n for c in comments:\n patch = c.patch_key.get()\n if (patch.key, c.left) != last_key:\n url = request.build_absolute_uri(\n reverse(diff, args=[request.issue.key.id(),\n patch.patchset_key.id(),\n patch.filename]))\n output.append('\\n%s\\nFile %s (%s):' % (url, patch.filename,\n c.left and \"left\" or \"right\"))\n last_key = (patch.key, c.left)\n if patch.no_base_file:\n linecache[last_key] = _patchlines2cache(\n patching.ParsePatchToLines(patch.lines), c.left)\n else:\n try:\n if c.left:\n old_lines = patch.get_content().text.splitlines(True)\n linecache[last_key] = dict(enumerate(old_lines, 1))\n else:\n new_lines = patch.get_patched_content().text.splitlines(True)\n linecache[last_key] = dict(enumerate(new_lines, 1))\n except FetchError:\n linecache[last_key] = _patchlines2cache(\n patching.ParsePatchToLines(patch.lines), c.left)\n fetch_base_failed = True\n context = linecache[last_key].get(c.lineno, '').strip()\n url = request.build_absolute_uri(\n '%s#%scode%d' % (reverse(diff, args=[request.issue.key.id(),\n patch.patchset_key.id(),\n patch.filename]),\n c.left and \"old\" or \"new\",\n c.lineno))\n output.append('\\n%s\\n%s:%d: %s\\n%s' % (url, patch.filename, c.lineno,\n context, c.text.rstrip()))\n if modified_patches:\n ndb.put_multi(modified_patches)\n return '\\n'.join(output)","def _get_comments(self):\n if not hasattr(self, 'id'):\n raise BadReference('No matching issue on disk')\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))","def comments(self):\n return comments.Comments(self)","def comments(self):\r\n return comments.Comments(self)","def get_comment(self, object_id):\n return self.get_object(\"comment\", object_id)","def comments_for_object(request, reminder_id):\n check_permissions(request.user, [PERMISSION_COMMENT_VIEW])\n\n reminder = get_object_or_404(Reminder, pk=reminder_id)\n\n return render_to_response('generic_list.html', {\n 'object': reminder,\n 'title': _(u'comments'),\n 'object_list': Comment.objects.for_model(reminder).order_by('-submit_date'),\n 'hide_link': True,\n 'hide_object': True,\n }, context_instance=RequestContext(request))","def GetNotifyEvent(self):\r\n \r\n return self.notify"],"string":"[\n \"def _get_review_comments_body(\\n self, pull_request_number: int) -> List[Tuple[str, str]]:\\n review_comments = get_pull_request_review_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not review_comments:\\n return []\\n review_comments_msg = []\\n for comment in review_comments:\\n review_comments_msg.append((comment['path'], comment['body']))\\n return review_comments_msg\",\n \"def _prepare_comment_added_template(self, event):\\n from string import Template\\n tpl = Template(self.__comment_added_template)\\n return tpl.substitute(\\n comment_author_name=event[\\\"author\\\"][\\\"name\\\"],\\n comment_author_email=event[\\\"author\\\"][\\\"email\\\"],\\n comment=event[\\\"comment\\\"],\\n change_url=event[\\\"change\\\"][\\\"url\\\"],\\n change_subject=event[\\\"change\\\"][\\\"subject\\\"],\\n approvals_verified_value=event[\\\"approvals\\\"][0][\\\"value\\\"], # FIX idx\\n approvals_review_value=event[\\\"approvals\\\"][1][\\\"value\\\"], # FIX idx\\n change_owner_name=event[\\\"change\\\"][\\\"owner\\\"][\\\"name\\\"],\\n change_owner_email=event[\\\"change\\\"][\\\"owner\\\"][\\\"email\\\"],\\n change_number=event[\\\"change\\\"][\\\"number\\\"],\\n change_project=event[\\\"change\\\"][\\\"project\\\"],\\n change_id=event[\\\"change\\\"][\\\"id\\\"],\\n change_branch=event[\\\"change\\\"][\\\"branch\\\"],\\n patchset_uploader_name=event[\\\"patchSet\\\"][\\\"uploader\\\"][\\\"name\\\"],\\n patchset_uploader_email=event[\\\"patchSet\\\"][\\\"uploader\\\"][\\\"email\\\"],\\n patchset_revision=event[\\\"patchSet\\\"][\\\"revision\\\"],\\n patchset_number=event[\\\"patchSet\\\"][\\\"number\\\"],\\n patchset_ref=event[\\\"patchSet\\\"][\\\"ref\\\"],\\n patchset_created_on=event[\\\"patchSet\\\"][\\\"createdOn\\\"]\\n )\",\n \"def get_comments(self):\\n\\t\\treturn self._client.get_comments(self)\",\n \"def invoice_history_comments(invoice):\\n history = Invoice.history.filter(id=invoice.id)\\n record = history.last()\\n comments = []\\n while record.next_record:\\n next_record = record.next_record\\n delta = next_record.diff_against(record)\\n message = _('Changed: \\\\n')\\n for change in delta.changes:\\n if change.field not in AVOID_COMMENTS:\\n if change.field != 'status':\\n old_value = change.old\\n new_value = change.new\\n else:\\n old_value = get_status_display(change.old)\\n new_value = get_status_display(change.new)\\n message += _('{} from {} to {}\\\\n').format(\\n Invoice._meta.get_field(change.field).verbose_name,\\n old_value,\\n new_value,\\n )\\n if next_record.history_change_reason:\\n message += gettext('\\\\nChange reason:\\\\n')\\n message += next_record.history_change_reason\\n if message != _('Changed: \\\\n'):\\n comment = Comment(\\n user=next_record.history_user,\\n invoice=next_record.instance,\\n message=message,\\n comment_date_received=next_record.history_date\\n )\\n comments.append(comment)\\n record = next_record\\n return comments\",\n \"def get_comments(self, visitor = None):\\n if visitor.is_anonymous():\\n return self.comments.all().order_by('id')\\n else:\\n comment_content_type = ContentType.objects.get_for_model(Comment)\\n #a fancy query to annotate comments with the visitor votes\\n comments = self.comments.extra(\\n select = SortedDict([\\n (\\n 'upvoted_by_user',\\n 'SELECT COUNT(*) from vote, comment '\\n 'WHERE vote.user_id = %s AND '\\n 'vote.content_type_id = %s AND '\\n 'vote.object_id = comment.id',\\n )\\n ]),\\n select_params = (visitor.id, comment_content_type.id)\\n ).order_by('id')\\n return comments\",\n \"def get_repo_review_comments(owner, repo, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def get_comments(self):\\n raise NotImplementedError\",\n \"def get_comments(self, resp):\\n comments = CommentList()\\n for value in resp['comments']:\\n comment = Comment()\\n comment.set_comment_id(value['comment_id'])\\n comment.set_expense_id(value['expense_id'])\\n comment.set_description(value['description'])\\n comment.set_commented_by_id(value['commented_by_id'])\\n comment.set_commented_by(value['commented_by'])\\n comment.set_date(value['date'])\\n comment.set_date_description(value['date_description'])\\n comment.set_time(value['time'])\\n comment.set_operation_type(value['operation_type'])\\n comment.set_transaction_id(value['transaction_id'])\\n comment.set_transaction_type(value['transaction_type'])\\n comments.set_comments(comment)\\n return comments\",\n \"def comment_added(self, event):\\n import simplejson\\n comment = str(event[\\\"comment\\\"])\\n author_name = str(event[\\\"author\\\"][\\\"name\\\"])\\n change_url = str(event[\\\"change\\\"][\\\"url\\\"])\\n change_subject = str(event[\\\"change\\\"][\\\"subject\\\"])\\n comment = simplejson.dumps({\\n \\\"issue\\\": {\\n \\\"notes\\\": self._prepare_comment_added_template(event)\\n }\\n })\\n # get a unique list of issue IDs\\n subject_issue_ids = self.__get_issue_ids(change_subject)\\n comment_issue_ids = self.__get_issue_ids(comment)\\n issue_ids = list(set(subject_issue_ids + comment_issue_ids))\\n for issue_id in issue_ids:\\n self.__add_comment(issue_id, comment)\",\n \"def comments(self) -> list:\\n return self._node[\\\"app_data\\\"][\\\"ui_data\\\"].get(\\\"comments\\\", [])\",\n \"def process_review_event(self, request: ReviewEvent) -> EventResponse: # noqa: D401\\n base_ptr = ReferencePointer.from_pb(request.commit_revision.base)\\n head_ptr = ReferencePointer.from_pb(request.commit_revision.head)\\n response = EventResponse()\\n response.analyzer_version = self.version\\n comments = []\\n for analyzer in self._analyzers:\\n try:\\n mycfg = self._protobuf_struct_to_dict(request.configuration[analyzer.name])\\n self._log.info(\\\"%s config: %s\\\", analyzer.name, mycfg)\\n except (KeyError, ValueError):\\n mycfg = {}\\n self._log.debug(\\\"no config was provided for %s\\\", analyzer.name)\\n if analyzer.model_type != DummyAnalyzerModel:\\n model = self._get_model(analyzer, base_ptr.url)\\n if model is None:\\n self._log.info(\\\"training: %s\\\", analyzer.name)\\n record_event(\\\"%s.train\\\" % analyzer.name, 1)\\n model = analyzer.train(base_ptr, mycfg, self._data_service)\\n self._model_repository.set(self._model_id(analyzer), base_ptr.url, model)\\n else:\\n model = DummyAnalyzerModel()\\n self._log.debug(\\\"running %s\\\", analyzer.name)\\n record_event(\\\"%s.analyze\\\" % analyzer.name, 1)\\n results = analyzer(model, head_ptr.url, mycfg).analyze(\\n base_ptr, head_ptr, self._data_service)\\n self._log.info(\\\"%s: %d comments\\\", analyzer.name, len(results))\\n record_event(\\\"%s.comments\\\" % analyzer.name, len(results))\\n comments.extend(results)\\n response.comments.extend(comments)\\n return response\",\n \"def comments(self):\\n comments_url = self.data['comments_url']\\n return json.load(urllib2.urlopen(comments_url))\",\n \"def getComment(self, n = None):\\n \\n if n is None:\\n return self._comments\\n else:\\n return self._comments[n]\",\n \"def list_comments_history(self, expense_id):\\n url = base_url + expense_id + '/comments'\\n resp = zoho_http_client.get(url, self.details, self.headers)\\n return parser.get_comments(resp)\",\n \"def comments(self):\\n return self.container['comments']\",\n \"def get_comments(comments):\\n API_KEY = secrets.YT_KEY\\n youtube = build('youtube', 'v3', developerKey=API_KEY)\\n request = youtube.commentThreads().list(\\n part='replies',\\n videoId=comments,\\n textFormat=\\\"plainText\\\"\\n )\\n\\n response = request.execute()\\n\\n video = response['items'][0]['replies']['comments']\\n\\n\\n for i in video:\\n print('\\\\n')\\n print(i['snippet']['textDisplay'])\\n # print(response['items'][0].keys())\",\n \"def get_review(self, language):\\n comment_generator = CommentGenerator(language)\\n return comment_generator.generateComment()\",\n \"def notify_comment(**kwargs): # pragma: no cover\\n actor = kwargs[\\\"request\\\"].user\\n receiver = kwargs[\\\"comment\\\"].content_object.user\\n obj = kwargs[\\\"comment\\\"].content_object\\n notification_handler(actor, receiver, Notification.COMMENTED, action_object=obj)\",\n \"def get_comments(self):\\n url = \\\"https://api.imgur.com/3/gallery/{0}/comments\\\".format(self.id)\\n resp = self._imgur._send_request(url)\\n return [Comment(com, self._imgur) for com in resp]\",\n \"def get_comment(self, index):\\r\\n\\r\\n # Get request to get all the comments for all exercises\\r\\n comments = requests.get(API.url_comment, headers = self.headers).json()\\r\\n # Parse the response\\r\\n for my_comment in comments:\\r\\n if my_comment['id'] == index:\\r\\n print(my_comment['comment'])\",\n \"def comments(self):\\n return self._comments\",\n \"def comments(self):\\n return self._comments\",\n \"def get_review_comments_for_pr(owner, repo, pr_number, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def do_comments(self, line):\\n for comment in self.review.comments():\\n print(comment)\",\n \"def get_comments(self):\\n\\t\\tself.comments = graph.get_connections(post['id'], 'comments')\",\n \"def on_issue_comment(self, payload):\\n pass\",\n \"def reactions(self, request, *args, **kwargs):\\n comment = self.get_object()\\n reactions = ReactionComment.objects.filter(comment=comment)\\n serializer = ReactionCommentModelSummarySerializer(\\n reactions, many=True)\\n return Response(serializer.data, status=status.HTTP_200_OK)\",\n \"def get_comments(yt_id):\\n\\n client = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,developerKey=DEVELOPER_KEY)\\n\\n video_comments = client.commentThreads().list(\\n videoId = yt_id,\\n part=\\\"snippet,replies\\\").execute()\\n\\n comment_items = video_comments['items']\\n\\n class MLStripper(HTMLParser):\\n def __init__(self):\\n self.reset()\\n self.strict = False\\n self.convert_charrefs= True\\n self.fed = []\\n def handle_data(self, d):\\n self.fed.append(d)\\n def get_data(self):\\n return ''.join(self.fed)\\n\\n def strip_tags(html):\\n s = MLStripper()\\n s.feed(html)\\n return s.get_data()\\n\\n comments = []\\n for sub_block in comment_items:\\n comments.append(strip_tags(sub_block['snippet']['topLevelComment']['snippet']['textDisplay']))\\n\\n comments_all = ' '.join(comments)\\n\\n print(\\\"YouTube comments scanned\\\")\\n return comments_all\",\n \"def on_review_reply(request: Request):\\n initialize()\\n request_json = request.get_json(force=True, silent=True)\\n update = decode_update(request_json)\\n dispatcher.process_update(update)\\n return \\\"\\\"\",\n \"def get_comments(self, ticket_id):\\n response = self.http_call(\\\"{0}/tickets/{1}/comments.json\\\".format(self.uri, ticket_id))\\n return json.loads(response.content.decode(sys.stdout.encoding, \\\"replace\\\"))\",\n \"def get_comments(self,comments):\\n all_comments = []\\n for comment in comments:\\n try :\\n all_comments.append({\\n 'comment':comment['data']['body'],\\n 'score':comment['data']['score']\\n })\\n except: pass\\n return all_comments\",\n \"def GetChangeReview(host, change, revision='current'):\\n path = '%s/revisions/%s/review' % (_GetChangePath(change), revision)\\n return FetchUrlJson(host, path)\",\n \"def test_issue_get_comment_reactions(self):\\n pass\",\n \"def api_draft_comments(request):\\n try:\\n def sanitize(comment):\\n patch = models.Patch.get_by_id(int(comment.patch_id),\\n parent=request.patchset.key)\\n assert not patch is None\\n message_id = str(comment.message_id) if message_id in comment else None,\\n return {\\n user: request.user,\\n issue: request.issue,\\n patch: patch,\\n lineno: int(comment.lineno),\\n left: bool(comment.left),\\n text: str(comment.text),\\n message_id: message_id,\\n }\\n return [\\n {message_id: _add_or_update_comment(**comment).message_id}\\n for comment in map(sanitize, json.load(request.data))\\n ]\\n except Exception as err:\\n return HttpTextResponse('An error occurred.', status=500)\",\n \"def get_comments(convo_ID):\\n # Make API request\\n url = \\\"https://api2.frontapp.com/conversations/\\\" + convo_ID + \\\"/comments\\\"\\n payload = {}\\n headers = {\\\"Authorization\\\": BEARER_TOKEN}\\n response = requests.request(\\\"GET\\\", url, headers=headers, data=payload)\\n for comment in response.json()[\\\"_results\\\"]:\\n # For each comment in Front, print out its message\\n print_friendly_JSON_object(comment[\\\"body\\\"])\",\n \"def get_comments(self):\\n url = \\\"https://api.imgur.com/3/account/{0}/comments\\\".format(self.name)\\n resp = self._imgur._send_request(url)\\n return [Comment(com, self._imgur) for com in resp]\",\n \"def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\\n if project_name == PROJECT_ALL:\\n # comments in changes across all projects after from_datetime\\n comments = reviewer.comments.filter(\\n timestamp__gte=from_datetime).distinct()\\n else:\\n # comments in changes in given project after from_datetime\\n comments = reviewer.comments.filter(\\n change__project_name=project_name,\\n timestamp__gte=from_datetime).distinct()\\n\\n return comments.count()\",\n \"def reviews(self):\\n reviewList = []\\n for review in storage.all(Review).values():\\n if review.getattr('place_id') == self.id:\\n reviewList.append(review)\\n return(reviewList)\",\n \"def get_comment_obj(self, videoId):\\n response = self.build_service()\\n\\n # you only need to build the service once\\n # collect all comments\\n \\n response2 = response.commentThreads().list(\\n part='snippet',\\n maxResults=100,\\n textFormat='plainText',\\n order='time',\\n videoId=videoId,\\n\\n ).execute()\\n\\n return response2\",\n \"def get_previous_pr_comments(pr_id):\\n relevant_comments = get_status_json(pr_id, 'comments')\\n\\n comments = [Comment(c[\\\"body\\\"], datetime.fromisoformat(c['createdAt'].strip('Z')), c['author']['login'])\\n for c in relevant_comments]\\n return comments\",\n \"def reviews(self) -> object:\\n return self._reviews\",\n \"def calc_comments(self):\\n for comment in self.pull_request.get_comments():\\n self._users.add(comment.user.login)\\n lowercase_body = comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_comments += 1\\n if comment.body is not None:\\n self.len_comments += len(comment.body)\\n for reaction in comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.comment_reactions += 1\",\n \"def problem_comments(self, identifier):\\n return self._get(\\\"problems/%d/comments\\\" % identifier).json()\",\n \"def get(self,event_id,timestamp,limit):\\n # ensure that limit is an integer!!!\\n if len(event_id) != 32:\\n self.set_status(400)\\n self.write_json({\\n 'result' : []\\n })\\n try:\\n int(timestamp)\\n limit = int(limit)\\n except:\\n self.set_status(400)\\n self.write_json({\\n 'result' : []\\n })\\n if limit <= 10 or limit >= 20:\\n self.write_json_with_status(400,{\\n 'result' : 'fail',\\n 'reason' : 'limit is too low or too high'\\n })\\n\\n comments = self.event_comment_table.scan(\\n EventID__eq=event_id,\\n Timestamp_le=timestamp,\\n limit=limit\\n )\\n\\n response = []\\n for comment in comments:\\n response.append(comment)\\n\\n if len(response) == 0:\\n self.write_json({\\n 'result' : [],\\n })\\n\\n else:\\n # assure comment from latest to early time\\n response = sorted(\\n response,\\n key=attrgetter('Timestamp'),\\n reverse=True)\\n\\n self.write_json({\\n 'result' : response,\\n 'new_timestamp' : response[-1]['Timestamp']\\n })\",\n \"def GetChangeReviewers(host, change):\\n path = '%s/reviewers' % _GetChangePath(change)\\n return FetchUrlJson(host, path)\",\n \"def test_get_comments():\\n comments = list(get_comments(TEST_SUBREDDIT, TEST_START_DATE, TEST_END_DATE, TEST_MAX))\\n\\n # prints the dictionary of variables for each comment\\n for x in comments:\\n print(x.d_)\",\n \"def review(self):\\n return self._review\",\n \"def get_comments(subreddit, start_date, end_date, limit):\\n api = PushshiftAPI()\\n return api.search_comments(after=start_date, before=end_date,\\n subreddit=subreddit, limit=limit\\n # , filter=['author', 'body', 'created_utc', 'nest_level']\\n )\",\n \"def _get_comments(self, issue_id):\\n data = self._get(\\\"/issues/{}/comments\\\".format(issue_id))\\n comments = []\\n for item in data:\\n comments.append(\\n Comment(item['user']['login'], item['body'])\\n )\\n return comments\",\n \"def _get_issue_comments_body(self, pull_request_number: int) -> List[str]:\\n issue_comments = get_pull_request_issue_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not issue_comments:\\n return []\\n issue_comments_msg = []\\n for comment in issue_comments:\\n issue_comments_msg.append(comment['body'])\\n return issue_comments_msg\",\n \"def get_comments(video_id, CLIENT_SECRETS_FILE):\",\n \"def comment_added(self, event):\\n pass\",\n \"def send_idea_comment_notification(comment_id: int) -> None:\\n logger = logging.getLogger()\\n logger.info('Sending notifications for comment #%s', comment_id)\\n\\n # Task will fail if comment is not found\\n comment = Comment.objects.get(id=comment_id)\\n\\n recipients = _get_recipients(comment)\\n if not recipients:\\n return\\n\\n # Transform to plain email list\\n recipients_emails = {recipient.email for recipient in recipients}\\n\\n _send_email(comment, recipients_emails)\",\n \"def order_reviews(self, reviews):\\n return reviews\",\n \"def reviews(self):\\n list_reviews = []\\n all_reviews = models.storage.all(Review)\\n for review_item in all_reviews.items():\\n if review_item.place_id == self.id:\\n list_review.append(review_item)\\n\\n return list_review\",\n \"def comments(self, request, pk=None):\\n post = self.get_object()\\n comments = Comment.objects.filter(post=post).order_by('created_at')\\n serializer = PostCommentsSerializer(comments, many=True)\\n return Response(serializer.data, status.HTTP_200_OK)\",\n \"def comments(self):\\r\\n return c.Comments(self)\",\n \"def comments(self):\\r\\n return c.Comments(self)\",\n \"def comments(self):\\r\\n return c.Comments(self)\",\n \"def question_comments(request, question, form=None):\\n populate_foreign_key_caches(User, (\\n ((question,), ('author', 'last_edited_by', 'closed_by')),\\n ),\\n fields=('username', 'gravatar', 'reputation', 'gold', 'silver',\\n 'bronze'))\\n\\n content_type = ContentType.objects.get_for_model(Question)\\n comments = Comment.objects.filter(content_type=content_type,\\n object_id=question.id)\\n\\n if form is None:\\n form = CommentForm()\\n\\n return render_to_response('question.html', {\\n 'title': u'Comments on %s' % question.title,\\n 'question': question,\\n 'tags': question.tags.all(),\\n 'comments': comments,\\n 'comment_form': form,\\n }, context_instance=RequestContext(request))\",\n \"async def scrape_comments(self):\\n\\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\\n\\n comment_count = 0\\n async for comment in subreddit_origin.comments(limit=self.limit):\\n if self.memory.contains(comment.id):\\n continue\\n\\n self.memory.add(comment.id)\\n\\n # Parse Comment\\n comment = self.parse_comment(comment)\\n\\n # Save in Pub/Sub\\n if self.enable_publish:\\n self.publish(comment)\\n\\n comment_count += 1\\n\\n return comment_count\",\n \"def notify(self, event):\\n for observer in self.observers:\\n observer.on_notify(event)\",\n \"def notify(self, event):\\n for observer in self.observers:\\n observer.on_notify(event)\",\n \"def notify(self, event):\\n for o in self.observers:\\n o.on_notify(event)\",\n \"def comments(self):\\r\\n return comments.ForumSuggestionComments(self)\",\n \"def get_discussion_comments(self, post_id):\\n query = \\\"SELECT users.Username , discussionreplies.* FROM discussionreplies INNER JOIN users ON (discussionreplies.Users_idUsers=users.idUsers) WHERE Discussions_idDiscussions={}\\\".format(post_id)\\n cursor = DB.instance.connection.cursor()\\n cursor.execute(query)\\n return cursor.fetchall()\",\n \"def generate_html_reviews_email(event, recommendations):\\n pull_request_id = event['PullRequestId']\\n lines_scanned = event['Metrics']['MeteredLinesOfCodeCount']\\n recommendations_found = event['Metrics']['FindingsCount']\\n recommendations_html_table_contents = [\\n f\\\"\\\"\\\"\\n <tr>\\n <td>{recommendation['FilePath']}</td>\\n <td>{recommendation['StartLine']}</td>\\n <td>{recommendation['EndLine']}</td>\\n <td>{recommendation['Description']}</td>\\n </tr>\\n \\\"\\\"\\\"\\n for recommendation in recommendations\\n ]\\n recommendations_html_table = '\\\\n'.join(recommendations_html_table_contents)\\n html_body = f\\\"\\\"\\\"\\n <!DOCTYPE html>\\n <html>\\n <head>\\n </head>\\n <body>\\n <p>Hi team,</p>\\n <p>Amazon CodeGuru Reviewer has completed the review of {pull_request_id}, \\n scanning {lines_scanned} and found {recommendations_found} of recommendations.</p>\\n <p>See Table below for the recommendations, and review the BUSINESS LOGIC in the pull request</p>\\n <table style=\\\"width:100%\\\">\\n <tr>\\n <th>File Path</th>\\n <th>Start Line</th>\\n <th>End Line</th>\\n <th>Description/Recommendation</th>\\n </tr>\\n {recommendations_html_table}\\n </table>\\n </body>\\n </html>\\n \\\"\\\"\\\"\\n return html_body\",\n \"def get_review_request(self, rid):\\r\\n rsp = self.api_call('api/review-requests/%s/' % rid)\\r\\n return rsp['review_request']\",\n \"def lambda_handler(event, context):\\n code_review_arn = event['CodeReviewArn']\\n response = codeguru_reviewer.list_recommendations(\\n MaxResults=50,\\n CodeReviewArn=code_review_arn\\n )\\n recommendation_summaries = response['RecommendationSummaries']\\n num_of_reviews = event['Metrics']['FindingsCount']\\n repo_name = event['RepositoryName']\\n pr_id = event['PullRequestId']\\n html_body = generate_html_reviews_email(event, recommendation_summaries)\\n email_subject = 'Hey team, Amazon CodeGuru Reviewer found {num_of_reviews} in the {repo_name} PR: {pr_id}'.format(\\n num_of_reviews=num_of_reviews,\\n repo_name=repo_name,\\n pr_id=pr_id\\n )\\n sns.publish(\\n TopicArn=CODEGURU_SNS_TOPIC,\\n Message=html_body,\\n Subject=email_subject\\n )\",\n \"def comments(self):\\r\\n return RepoCommitsComments(self.parent)\",\n \"def reviews(self):\\n list_reviews = []\\n place_reviews = models.engine.all(Review)\\n for pl_reviews in place_reviews.values():\\n if pl_reviews.place_id == self.id:\\n list_reviews.append(pl_reviews)\\n return list_reviews\",\n \"def get_reviews(recipe_id=None):\\n\\n recipe = storage.get(Recipe, recipe_id)\\n print(recipe)\\n if not recipe:\\n abort(404)\\n reviews = []\\n for review in recipe.reviews:\\n reviews.append(review.to_dict())\\n return jsonify(reviews)\",\n \"def calc_conv_comments(self):\\n for conv_comment in self.pull_request.get_issue_comments():\\n self._users.add(conv_comment.user.login)\\n lowercase_body = conv_comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_conv_comments += 1\\n for reaction in conv_comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.conv_comment_reactions += 1\\n if conv_comment.body is not None:\\n self.len_issue_comments += len(conv_comment.body)\",\n \"def get_comments(self, project, story):\\n ret_val = []\\n resource = \\\"projects/{0:d}/stories/{1:d}/comments\\\".format(project.id,\\n story.id)\\n params = {\\\"fields\\\": Comment.FIELDS}\\n comments = self._request(\\\"get\\\", resource, params=params)\\n\\n for comment in comments:\\n ret_val.append(Comment(comment))\\n\\n return ret_val\",\n \"def fetch_review(self):\\n c = self.db.cursor()\\n c.execute(\\\"\\\"\\\"SELECT * FROM cards\\n WHERE date_last_reviewed < (DATETIME('now', 'localtime', '-8 hours'))\\n OR correct = 0\\\"\\\"\\\")\\n rows = c.fetchall()\\n cards = [\\n Card(\\n id=id,\\n card_type=card_type,\\n text=text,\\n created=created,\\n uri=uri,\\n updated=updated,\\n difficulty=difficulty,\\n days_between=days_between,\\n date_last_reviewed=date_last_reviewed,\\n correct=correct,\\n )\\n for id, card_type, text, uri, created, updated, difficulty, days_between, date_last_reviewed, correct in rows\\n ]\\n cards = filter(lambda card: card.percent_overdue >= 1, cards)\\n cards = sorted(cards, key=lambda card: card.percent_overdue)\\n\\n return cards[:20]\",\n \"def get_notifications(self):\\n return self.ws.events['notifications']\",\n \"def approvals_comments_list(self, mar, request):\\n issue = self._services.issue.GetIssueByLocalID(\\n mar.cnxn, mar.project_id, request.issueId)\\n if not permissions.CanViewIssue(\\n mar.auth.effective_ids, mar.perms, mar.project, issue,\\n mar.granted_perms):\\n raise permissions.PermissionException(\\n 'User is not allowed to view this issue (%s, %d)' %\\n (request.projectId, request.issueId))\\n config = self._services.config.GetProjectConfig(mar.cnxn, issue.project_id)\\n approval_fd = tracker_bizobj.FindFieldDef(request.approvalName, config)\\n if not approval_fd:\\n raise endpoints.BadRequestException(\\n 'Field definition for %s not found in project config' %\\n request.approvalName)\\n comments = self._services.issue.GetCommentsForIssue(\\n mar.cnxn, issue.issue_id)\\n comments = [comment for comment in comments\\n if comment.approval_id == approval_fd.field_id]\\n visible_comments = []\\n for comment in comments[\\n request.startIndex:(request.startIndex + request.maxResults)]:\\n visible_comments.append(\\n api_pb2_v1_helpers.convert_approval_comment(\\n issue, comment, mar, self._services, mar.granted_perms))\\n\\n return api_pb2_v1.ApprovalsCommentsListResponse(\\n kind='monorail#approvalCommentList',\\n totalResults=len(comments),\\n items=visible_comments)\",\n \"def comments(self):\\r\\n return RepoCommitsComments(self)\",\n \"def comments(self, limit=100, all=False):\\n source, edge = self.id, \\\"comments\\\"\\n return lazygen(Comment, source, edge,\\n limit=limit, get_all=all)\",\n \"def comments(self, comments):\\n\\n self.container['comments'] = comments\",\n \"def _get_information(self):\\n reviews = self._tab.find_all(\\\"div\\\", class_=\\\"review\\\", attrs={'itemprop': 'review'})\\n return [(self._get_review(elem), self._get_published_date(elem)) for elem in reviews]\",\n \"def get_user_reviews(self):\\n raw_review_data = imdb.get_title_user_reviews(self.ID) # Returns dictionary of dicts\\n reviews_dict = raw_review_data['reviews'] # Stores the dictionary of reviews\\n for dictionary in reviews_dict:\\n self.user_reviews.append(dictionary['reviewText'])\\n # Appends review text to list\\n self._review_printer() # Calls printer to output reviews\",\n \"def _comment():\\r\\n id = request.args.get('answer_id')\\r\\n per_page=current_app.config['FLASKY_ANSWERS_PER_PAGE']\\r\\n answer = Answer.query.get_or_404(id)\\r\\n page = request.args.get('page', type=int, default=1)\\r\\n comment =request.args.get('comment')\\r\\n if current_user.can(Permission.COMMENT) and comment is not None:\\r\\n comment = Comment(body=comment,\\r\\n author=current_user._get_current_object(),\\r\\n answer_id=id)\\r\\n db.session.add(comment)\\r\\n db.session.commit()\\r\\n page = -1\\r\\n if page == -1:\\r\\n page = answer.comments.count() / per_page\\r\\n pagination = Comment.query.order_by(Comment.timestamp).filter_by(answer_id=id).paginate(\\r\\n page,per_page=per_page,error_out=False\\r\\n )\\r\\n macro_comment = get_template_attribute(\\\"_comments.html\\\", \\\"render_comments\\\")\\r\\n macro_page = get_template_attribute(\\\"_page.html\\\", \\\"render_page\\\")\\r\\n comments = pagination.items\\r\\n return jsonify({'result': True,\\r\\n 'comment_html': macro_comment(comments),\\r\\n 'page_html':macro_page(pagination),\\r\\n 'comments_timestamp':[comment.timestamp for comment in comments],\\r\\n 'comments_id':[comment.id for comment in comments]\\r\\n })\",\n \"def review(self) -> object:\\n return self._review\",\n \"def get_video_comments(self):\\n other_user_email = request.args.get('other_user_email')\\n video_title = request.args.get('video_title')\\n if not other_user_email or not video_title:\\n self.logger.debug(messages.MISSING_FIELDS_ERROR % \\\"query params\\\")\\n return messages.ERROR_JSON % messages.MISSING_FIELDS_ERROR % \\\"query params\\\", 400\\n users_data, comments = self.video_database.get_comments(other_user_email, video_title)\\n response = [{\\\"user\\\": u,\\n \\\"comment\\\": {\\\"content\\\":c.content, \\\"timestamp\\\": c.timestamp.isoformat()}}\\n for u,c in zip(users_data, comments)]\\n return json.dumps(response), 200\",\n \"def comments(self):\\r\\n return IssueComments(self)\",\n \"def comments(self):\\r\\n return IssueComments(self)\",\n \"def post_review(self, form):\\n comments_file = form.cleaned_data.get('comments', None)\\n return_code = form.cleaned_data.get('return_code', None)\\n\\n # Update the review\\n self.object.post_review(comments_file, return_code=return_code)\\n if return_code:\\n self.revision.return_code = return_code\\n\\n verb = None\\n # If every reviewer has posted comments, close the reviewers step\\n if self.object.role == 'reviewer':\\n qs = Review.objects \\\\\\n .filter(document=self.document) \\\\\\n .filter(revision=self.revision.revision) \\\\\\n .filter(role='reviewer') \\\\\\n .exclude(closed_on=None)\\n if qs.count() == self.revision.reviewers.count():\\n self.revision.end_reviewers_step(save=False)\\n verb = Activity.VERB_CLOSED_REVIEWER_STEP\\n\\n # If leader, end leader step\\n elif self.object.role == 'leader':\\n self.revision.end_leader_step(save=False)\\n verb = Activity.VERB_CLOSED_LEADER_STEP\\n\\n # If approver, end approver step\\n elif self.object.role == 'approver':\\n self.revision.end_review(save=False)\\n verb = Activity.VERB_CLOSED_APPROVER_STEP\\n\\n self.revision.save(update_document=True)\\n\\n if verb:\\n activity_log.send(verb=verb,\\n target=self.revision,\\n sender=do_batch_import,\\n actor=self.request.user)\",\n \"def getAll(self, event_name):\\n raw_events = self._callEventGetAll(self._id, event_name)\\n return [snippet_event.from_dict(msg) for msg in raw_events]\",\n \"def GetReviewers(host, change):\\n path = '%s/reviewers' % _GetChangePath(change)\\n return FetchUrlJson(host, path)\",\n \"async def get_history_by_comment(request):\\n try:\\n comment_id = int(request.match_info.get('comment_id'))\\n except ValueError:\\n raise web.HTTPBadRequest(reason=\\\"Field 'comment_id' should be int\\\")\\n\\n rows = await CommentHistoryDAO(request['conn']).get_by_comment(comment_id)\\n return web.json_response(rows)\",\n \"def notify_participant_event_decision(request, user, event, decision, comment_to_applicant):\\n\\n subject = f\\\"{settings.SITE_NAME} Event Registration Decision\\\"\\n context = {\\n 'name': user.get_full_name(),\\n 'domain': get_current_site(request),\\n 'url_prefix': get_url_prefix(request),\\n 'event_title': event.title,\\n 'event_url': reverse('event_detail', args=[event.slug]),\\n 'decision': decision,\\n 'comment_to_applicant': comment_to_applicant,\\n 'SITE_NAME': settings.SITE_NAME,\\n }\\n body = loader.render_to_string('events/email/event_participation_decision.html', context)\\n # Not resend the email if there was an integrity error\\n send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=False)\",\n \"def get_comments(self, post_id, post_type):\\n\\n try:\\n if not post_id or not post_type:\\n raise Exception('Invalid parameter')\\n if post_type != 'question' and post_type != 'answer':\\n raise Exception('Invalid parameter')\\n\\n url = BASE_URL + 'post_comments/'\\n url += '?' + urllib.parse.urlencode({'post_id': int(post_id), 'post_type': post_type})\\n response = self.request('GET', url, is_ajax=True)\\n response = response.json()\\n output = []\\n for item in response:\\n output.append(self._convert_comment(item))\\n return output\\n except Exception as e:\\n Utils.log(traceback.format_exc())\\n Utils.error(e.args[0])\",\n \"def _get_draft_details(request, comments):\\n last_key = None\\n output = []\\n linecache = {} # Maps (c.patch_key, c.left) to mapping (lineno, line)\\n modified_patches = []\\n fetch_base_failed = False\\n\\n for c in comments:\\n patch = c.patch_key.get()\\n if (patch.key, c.left) != last_key:\\n url = request.build_absolute_uri(\\n reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]))\\n output.append('\\\\n%s\\\\nFile %s (%s):' % (url, patch.filename,\\n c.left and \\\"left\\\" or \\\"right\\\"))\\n last_key = (patch.key, c.left)\\n if patch.no_base_file:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n else:\\n try:\\n if c.left:\\n old_lines = patch.get_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(old_lines, 1))\\n else:\\n new_lines = patch.get_patched_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(new_lines, 1))\\n except FetchError:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n fetch_base_failed = True\\n context = linecache[last_key].get(c.lineno, '').strip()\\n url = request.build_absolute_uri(\\n '%s#%scode%d' % (reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]),\\n c.left and \\\"old\\\" or \\\"new\\\",\\n c.lineno))\\n output.append('\\\\n%s\\\\n%s:%d: %s\\\\n%s' % (url, patch.filename, c.lineno,\\n context, c.text.rstrip()))\\n if modified_patches:\\n ndb.put_multi(modified_patches)\\n return '\\\\n'.join(output)\",\n \"def _get_comments(self):\\n if not hasattr(self, 'id'):\\n raise BadReference('No matching issue on disk')\\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))\",\n \"def comments(self):\\n return comments.Comments(self)\",\n \"def comments(self):\\r\\n return comments.Comments(self)\",\n \"def get_comment(self, object_id):\\n return self.get_object(\\\"comment\\\", object_id)\",\n \"def comments_for_object(request, reminder_id):\\n check_permissions(request.user, [PERMISSION_COMMENT_VIEW])\\n\\n reminder = get_object_or_404(Reminder, pk=reminder_id)\\n\\n return render_to_response('generic_list.html', {\\n 'object': reminder,\\n 'title': _(u'comments'),\\n 'object_list': Comment.objects.for_model(reminder).order_by('-submit_date'),\\n 'hide_link': True,\\n 'hide_object': True,\\n }, context_instance=RequestContext(request))\",\n \"def GetNotifyEvent(self):\\r\\n \\r\\n return self.notify\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5948147","0.5384553","0.5373081","0.5350771","0.53389245","0.5330528","0.53114086","0.53063893","0.53036827","0.52942955","0.5259007","0.5222319","0.52145696","0.5210138","0.51832515","0.5155651","0.5119935","0.50863373","0.5073527","0.5065843","0.5062373","0.5062373","0.50561464","0.50447565","0.50272703","0.50065184","0.5005768","0.5005059","0.49968648","0.4989186","0.49891627","0.4981257","0.49397945","0.4932696","0.49212965","0.4865233","0.48632172","0.4858023","0.48498207","0.48466307","0.48459357","0.48370945","0.48276207","0.48039967","0.4801055","0.47964","0.47925526","0.4788232","0.47823736","0.47758323","0.47699675","0.47607735","0.47576576","0.4755835","0.4751171","0.47483936","0.47448707","0.47448707","0.47448707","0.47435203","0.47253358","0.47194204","0.47194204","0.47156677","0.47154522","0.47067627","0.4702382","0.46973503","0.46932298","0.46909136","0.46760452","0.46708122","0.4670499","0.46643507","0.46578425","0.465717","0.46498713","0.4642842","0.4639211","0.46379262","0.46366656","0.46333688","0.46302387","0.46296182","0.46186182","0.4615579","0.4615579","0.46125302","0.46089035","0.46069363","0.46045","0.46004406","0.46003306","0.45967695","0.45919484","0.45857233","0.45837712","0.4576855","0.4573648","0.4570708"],"string":"[\n \"0.5948147\",\n \"0.5384553\",\n \"0.5373081\",\n \"0.5350771\",\n \"0.53389245\",\n \"0.5330528\",\n \"0.53114086\",\n \"0.53063893\",\n \"0.53036827\",\n \"0.52942955\",\n \"0.5259007\",\n \"0.5222319\",\n \"0.52145696\",\n \"0.5210138\",\n \"0.51832515\",\n \"0.5155651\",\n \"0.5119935\",\n \"0.50863373\",\n \"0.5073527\",\n \"0.5065843\",\n \"0.5062373\",\n \"0.5062373\",\n \"0.50561464\",\n \"0.50447565\",\n \"0.50272703\",\n \"0.50065184\",\n \"0.5005768\",\n \"0.5005059\",\n \"0.49968648\",\n \"0.4989186\",\n \"0.49891627\",\n \"0.4981257\",\n \"0.49397945\",\n \"0.4932696\",\n \"0.49212965\",\n \"0.4865233\",\n \"0.48632172\",\n \"0.4858023\",\n \"0.48498207\",\n \"0.48466307\",\n \"0.48459357\",\n \"0.48370945\",\n \"0.48276207\",\n \"0.48039967\",\n \"0.4801055\",\n \"0.47964\",\n \"0.47925526\",\n \"0.4788232\",\n \"0.47823736\",\n \"0.47758323\",\n \"0.47699675\",\n \"0.47607735\",\n \"0.47576576\",\n \"0.4755835\",\n \"0.4751171\",\n \"0.47483936\",\n \"0.47448707\",\n \"0.47448707\",\n \"0.47448707\",\n \"0.47435203\",\n \"0.47253358\",\n \"0.47194204\",\n \"0.47194204\",\n \"0.47156677\",\n \"0.47154522\",\n \"0.47067627\",\n \"0.4702382\",\n \"0.46973503\",\n \"0.46932298\",\n \"0.46909136\",\n \"0.46760452\",\n \"0.46708122\",\n \"0.4670499\",\n \"0.46643507\",\n \"0.46578425\",\n \"0.465717\",\n \"0.46498713\",\n \"0.4642842\",\n \"0.4639211\",\n \"0.46379262\",\n \"0.46366656\",\n \"0.46333688\",\n \"0.46302387\",\n \"0.46296182\",\n \"0.46186182\",\n \"0.4615579\",\n \"0.4615579\",\n \"0.46125302\",\n \"0.46089035\",\n \"0.46069363\",\n \"0.46045\",\n \"0.46004406\",\n \"0.46003306\",\n \"0.45967695\",\n \"0.45919484\",\n \"0.45857233\",\n \"0.45837712\",\n \"0.4576855\",\n \"0.4573648\",\n \"0.4570708\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.523376"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":84673,"cells":{"query":{"kind":"string","value":"NotifyPushEvent is not expected to return any comments. Its purpose for now is to notify the analyzer of a new push to a repository, that could be used to trigger training tasks over new contents."},"document":{"kind":"string","value":"def NotifyPushEvent(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')"},"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 on_push(self, payload):\n pass","def notify(self, event):\n\n self.send_json(event[\"payload\"])","def push(event):\n _pushedEvents.append(event)","def send_notification (event):\n Publisher.sendMessage (event)","def notify(self, event):\n raise NotImplementedError","def svn_notify(self,event):\n # pysvn.wc_notify_action.update_completed\n if event['action'] == pysvn.wc_notify_action.update_completed:\n revision = event['revision']\n self.revision = revision","def on_push(self, data):\n if data[\"type\"] == \"push\":\n self._data = data[\"push\"]","def push(self, *args, **kwargs):\n pass","def on_notify(self, name):\r\n pass","def dispatch_push(self, p, tweaks, badge):\n pass","async def process_push_hook(push: models.PushHook):\n repository = push.repository\n project = push.project\n commit_str = \"commit\" if push.total_commits_count == 1 else \"commits\"\n # Show link to commit compare if there's more than one commit\n if push.total_commits_count > 1:\n embed_url = f\"{repository.homepage}/compare/{push.before[:7]}...{push.after[:7]}\"\n else:\n embed_url = f\"{repository.homepage}/commit/{push.after[:7]}\"\n\n if push.before == EMPTY_COMMIT:\n embed = discord.Embed(title=f\"[{project.namespace}/{project.name}] New branch created {push.branch}\",\n url=embed_url, colour=discord.Colour.light_grey())\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)\n elif push.after == EMPTY_COMMIT:\n embed = discord.Embed(title=f\"[{project.namespace}/{project.name}] Branch deleted {push.branch}\",\n url=embed_url, colour=discord.Colour.light_grey())\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)\n\n # If there are no commits, do not show a message\n if not push.total_commits_count:\n return\n\n embed = discord.Embed(title=f\"[{project.namespace}/{project.name}:{push.branch}] \"\n f\"{push.total_commits_count} new {commit_str}\",\n url=embed_url, colour=discord.Colour.blurple())\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\n embed.description = \"\"\n for commit in push.commits:\n message = commit.message.splitlines()[0]\n embed.description += f\"[`{commit.id[:7]}`]({commit.url}) {message} - {commit.author.name}\\n\"\n print(\"Sending push message\")\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)","def _send_notification() -> None:\n send_notification(\n self,\n \"slack:@aaron\",\n \"New {0} Version: {1}\".format(\n self.properties[CONF_APP_NAME], new_version\n ),\n title=\"New Software 💿\",\n )","def infocalypse_push(ui_, repo, **opts):\n params, stored_cfg = get_config_info(ui_, opts)\n insert_uri = opts['uri']\n if insert_uri == '':\n insert_uri = stored_cfg.get_dir_insert_uri(repo.root)\n if not insert_uri:\n ui_.warn(\"There is no stored insert URI for this repo.\\n\"\n \"Please set one with the --uri option.\\n\")\n return\n\n set_target_version(ui_, repo, opts, params,\n \"Only pushing to version(s): %s\\n\")\n params['INSERT_URI'] = insert_uri\n #if opts['requesturi'] != '':\n # # DOESN'T search the insert uri index.\n # ui_.status((\"Copying from:\\n%s\\nTo:\\n%s\\n\\nThis is an \"\n # + \"advanced feature. \"\n # + \"I hope you know what you're doing.\\n\") %\n # (opts['requesturi'], insert_uri))\n # params['REQUEST_URI'] = opts['requesturi']\n\n execute_push(ui_, repo, params, stored_cfg)","def __gitPush(self):\n self.vcs.gitPush(self.project.getProjectPath())","def notify_new(self, **kwargs):\n return self.notify(\"notify_new\", **kwargs)","def create_push_notification(package, repository):\n # type: (str, str) -> str\n notification_dict = {\n \"repository\": repository,\n \"package\": package,\n \"event\": \"push\",\n }\n return json.dumps(notification_dict)","def on_new_notification(data, index, *args):\n print(data)","def remote_push(self, pNamespace):","def notify(r, wiki):\n\n if not settings.EMAIL_NOTIFY:\n return\n\n HEAD = r.repo.head.commit\n HEADp = r.repo.head.commit.parents[0]\n\n diff = r.repo.git.diff(HEADp.hexsha, HEAD.hexsha)\n\n send_mail(u'[wiki/{0}] {1}'.format(wiki, HEAD.message), diff, os.environ['GIT_AUTHOR_EMAIL'], settings.EMAIL_LIST, fail_silently=True)","def notify(cls, self, message):\n pass","def notify(self) -> None:\n pass","def notify(self) -> None:\n pass","def write(self, notification):","def push_commits(self, verbose=True):\n # The subprocess will return a non-zero exit code even if it succeeded.\n # Check its output to determine whether it worked.\n push_proc = subprocess.run(\n [\"git\", \"push\"],\n cwd=self.path,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT,\n universal_newlines=True,\n )\n if \"updated in conservator\" not in push_proc.stdout:\n if \"Everything up-to-date\" in push_proc.stdout:\n logger.warning(push_proc.stdout)\n else:\n logger.error(\n \"Server did not accept changes to index.json:\\n%s\", push_proc.stdout\n )\n raise RuntimeError(\"Failed to push changes to index.json\")\n self.pull(verbose)","def call_git_push():\n print(\"This will commit and push the git repo\")\n today = datetime.datetime.today()\n call([\"git\", \"add\", \".\"])\n call([\"git\", \"commit\", \"-m\", \"Updated notes. {:%Y-%m-%d %H:%M:%S}\".format(today)])\n call([\"git\", \"push\", \"origin\", \"master\"])","def on_commit_comment(self, payload):\n pass","def notify_on_action(self):\n desired_action = self.pr.config.actionToBeNotifiedFor\n if self.pr.action == desired_action:\n if self.pr.base_branch == self.pr.config.mainBranch:\n msg = MSG_OPENED_TO_MAIN_BRANCH.format(repo=self.pr.repo, pr_by=self.created_by,\n main_branch=self.pr.config.mainBranch, title=self.pr.title,\n pr=self.pr.link_pretty, action=self.pr.action)\n for person in self.pr.config.techLeadsToBeNotified:\n self.slack.postToSlack(person, msg + MSG_RELEASE_PREPARATION)\n LOG.info(\"Notified to %s on action %s\" % (self.pr.config.techLeadsToBeNotified, self.pr.action))\n return {\"msg\": \"Notified to %s on action %s\" % (self.pr.config.techLeadsToBeNotified, self.pr.action)}\n else:\n msg = MSG_OPENED_TO_PREVENTED_BRANCH.format(repo=self.pr.repo, pr_by=self.created_by,\n base_branch=self.pr.base_branch, title=self.pr.title,\n pr=self.pr.link_pretty, action=self.pr.action)\n self.slack.postToSlack(self.pr.config.personToBeNotified, msg)\n LOG.info(\"Notified to %s on action %s\" % (self.pr.config.personToBeNotified, self.pr.action))\n return {\"msg\": \"Notified to %s on action %s\" % (self.pr.config.personToBeNotified, self.pr.action)}\n return {\"msg\": \"Skipped notify because its (%s) not desired event '%s'\" %(self.pr.action, desired_action)}","def __notify_slack(self):\n\t\ttry:\n\t\t\tprint(\"[+] Sending Slack notifications...\")\n\t\t\tslack_http_headers = {\n\t\t\t\t'User-Agent': 'GitHubScrap',\n\t\t\t\t'Content-type': 'application/json',\n\t\t\t}\n\t\t\tslack_http_data = {}\n\t\t\tfor ix in range(0,len(self.final_results[\"results\"]),SLACK_CHUNK_SIZE):\n\t\t\t\tdata_to_send = \"\"\n\t\t\t\tchunk_results = self.final_results[\"results\"][ix:ix+SLACK_CHUNK_SIZE]\n\t\t\t\tfor url in chunk_results:\n\t\t\t\t\tdata_to_send += \"{} ({})\\n\".format(url[\"query\"], url[\"link\"])\n\n\t\t\t\tslack_http_data.update({\n\t\t\t\t\t'text': data_to_send,\n\t\t\t\t})\n\t\t\t\trequests.post(\n\t\t\t\t\tself.slack_webhook,\n\t\t\t\t\theaders = slack_http_headers,\n\t\t\t\t\tdata = json.dumps(slack_http_data),\n\t\t\t\t)\n\t\t\t\tsleep(SLACK_HTTP_DELAY)\n\n\t\texcept Exception as exception:\n\t\t\traise MsgException('Slack notifications could not be sent', exception)","async def notify(self, message: str) -> None:\n\n pass","def start_notify(self, on_change):\n raise NotImplementedError","def _push(self):\n push_cmds = self.vcs.push_commands()\n if not push_cmds:\n return\n if utils.ask(\"OK to push commits to the server?\"):\n for push_cmd in push_cmds:\n output = execute_command(push_cmd)\n logger.info(output)","def notify(guid, message):","def on_issue_comment(self, payload):\n pass","def notify(self):\n if self.has_changed:\n event = self.event_factory(self.resource, registry=self.registry, schema=self.schema,\n changed=self.changed)\n self.registry.notify(event)","def on_watch(self, payload):\n pass","def on_pull_request(self, payload):\n pass","def receive_notification(self, *args, **kwargs):\n\t\tprint(f\"{self.__location} is now hearing \\\"{args[0]}\\\" on {args[1]}\")","def push_the_change(self, issue_id: str, commit_msg: List[str] = None) -> None:\n index = self.git.index\n index.add([\"INFO.yaml\"])\n if not commit_msg:\n commit_msg = [\"Edit INFO.yaml file.\"]\n commit_msg_with_m = list(\n chain.from_iterable(zip_longest([], commit_msg, fillvalue=\"-m\"))\n )\n self.git.git.execute(\n [\n \"git\",\n \"commit\",\n *commit_msg_with_m,\n \"-m\",\n \"That change was done by automated integration tool to maintain commiters list in INFO.yaml\",\n \"-m\",\n f\"Issue-ID: {issue_id}\",\n \"-s\",\n ]\n )\n self.git.git.execute([\"git\", \"push\", \"origin\", f\"HEAD:refs/for/{self._branch}\"])\n print(f\"Pushed successfully to {self._repo} respository\")","def push(self):\n out, err, code = self.command( [\"git\", \"push\"], self.directory )","def notify(self, event, user):\n raise NotImplementedError(\"Subclasses must override notify() method\")","def notify(self, title, message, config):\n notification = {\n 'application': config.get('application'),\n 'event': title,\n 'description': message,\n 'url': config.get('url'),\n 'priority': config.get('priority'),\n 'providerkey': config.get('provider_key'),\n }\n\n if isinstance(config['api_key'], list):\n config['api_key'] = [config['api_key']]\n notification['apikey'] = config['api_key']\n\n try:\n response = requests.post(PROWL_URL, data=notification)\n except RequestException as e:\n raise PluginWarning(repr(e))\n\n request_status = ET.fromstring(response.content)\n error = request_status.find('error')\n if error is not None:\n raise PluginWarning(error.text)\n else:\n success = request_status.find('success').attrib\n logger.debug(\n 'prowl notification sent. Notifications remaining until next reset: {}. '\n 'Next reset will occur in {} minutes',\n success['remaining'],\n success['resetdate'],\n )","def create_pr_notification(package, repository, id):\n # type: (str, str, int) -> str\n notification_dict = {\n \"repository\": repository,\n \"package\": package,\n \"event\": \"pull-request\",\n \"id\": id\n }\n return json.dumps(notification_dict)","def push_update_reference(self, refname, message):","def git_webhook():\n client = MongoClient(os.getenv('MONGODB_URI', 'mongodb://localhost:27017'))\n database = client.get_database()\n content = {\n \"event\": request.headers['X-GitHub-Event'],\n \"payload\" : request.json,\n \"date\": datetime.utcnow()\n }\n log.info(\"Content Received - \", request.headers['X-GitHub-Delivery'])\n inserted_id = database.events.insert_one(content).inserted_id\n log.info(\"Content Inserted - \", inserted_id)\n return jsonify({\n \"message\": \"Okay!\"\n })","def push(self):\n self.runtime.logger.info('Pushing config...')\n with Dir(self.runtime.metadata_dir):\n exectools.cmd_assert([\"git\", \"push\"])","def event_player_push(self) -> None:\n print(f\"You got a push, your bet of {self.user.bet} is returned\")","def infocalypse_fmsnotify(ui_, repo, **opts):\n params, stored_cfg = get_config_info(ui_, opts)\n insert_uri = stored_cfg.get_dir_insert_uri(repo.root)\n if not insert_uri and not (opts['submitbundle'] or\n opts['submitwiki']):\n ui_.warn(\"You can't notify because there's no stored \"\n + \"insert URI for this repo.\\n\"\n + \"Run from the directory you inserted from.\\n\")\n return\n\n params['ANNOUNCE'] = opts['announce']\n params['SUBMIT_BUNDLE'] = opts['submitbundle']\n params['SUBMIT_WIKI'] = opts['submitwiki']\n if params['SUBMIT_WIKI'] or params['SUBMIT_BUNDLE']:\n request_uri = stored_cfg.get_request_uri(repo.root)\n if not request_uri:\n ui_.warn(\"There is no stored request URI for this repo.\\n\")\n raise util.Abort(\"No request URI.\")\n params['REQUEST_URI'] = request_uri\n\n params['DRYRUN'] = opts['dryrun']\n params['INSERT_URI'] = insert_uri\n execute_fmsnotify(ui_, repo, params, stored_cfg)","def handle(self):\n self.app.logger.info('==== handle github event: %s', self.event)\n # self.app.logger.info('data send: %s', json.dumps(self.data, indent=2))\n if self.event == 'ping':\n return {'msg': 'Hi!'}\n else:\n task_match = []\n repo_config = self.get_repo_config()\n if repo_config:\n for task_config in repo_config['tasks']:\n event_hit = False\n if self.event == 'push':\n event_hit = self._is_task_push(task_config)\n elif self.event == 'pull_request':\n event_hit = self._is_task_pull_request(task_config)\n if event_hit:\n task_match.append(task_config)\n # work start execute here...\n for task in task_match:\n self.app.logger.info(\"event hit, start tasks under %s/%s...\", self.repo_meta['owner'], self.repo_meta['name'])\n self._jenkins_build(task)\n pass\n return \"OK\"","def notify(self, event):\n for o in self.observers:\n o.on_notify(event)","def execute(self):\n return LOGGER.info(f\"{datetime.datetime.now()} - Sending notification in Slack\")","def notify(self, event):\n for observer in self.observers:\n observer.on_notify(event)","def notify(self, event):\n for observer in self.observers:\n observer.on_notify(event)","def notified(self, notified):\n\n self._notified = notified","def push_changes_mock(*_, **__):\n return \"origin\"","def push():\n local('hg push jvacx')","def create_issue_notification(package, repository, id):\n # type: (str, str, int) -> str\n notification_dict = {\n \"repository\": repository,\n \"package\": package,\n \"event\": \"issue\",\n \"id\": id\n }\n return json.dumps(notification_dict)","def push(self):\n origin = self.git_repo.remotes.origin\n origin.push()","def retrieve_pushes(self):\n\n self.listener = Listener(account=self.pushbullet, on_push=self.on_push)\n _LOGGER.debug(\"Getting pushes\")\n try:\n self.listener.run_forever()\n finally:\n self.listener.close()","def notify(self, **kwargs):\n return self.send(kwargs)","def notify(self, **kwargs):\n return self.send(kwargs)","def on_publish(client, userdata, mid):\n print(\"Message Published.\")","def handleNotification(self, notification):\n pass","def notify(self, builder):\n\n # Build the <files> section for the template...\n commit = builder.commit\n files = E.files()\n\n commit_msg = commit.message.strip()\n commit_msg = re.sub(r'[\\x00-\\x09\\x0B-\\x1f\\x7f-\\xff]', '', commit_msg)\n\n for filename in commit.files_changed:\n safe_filename = re.sub(r'[\\x00-\\x09\\x0B-\\x1f\\x7f-\\xff]', '', filename)\n file_element = E.file(safe_filename)\n files.append(file_element)\n\n # Build the message\n cia_message = self.MESSAGE()\n cia_message.append(self._generator)\n\n source = self.SOURCE(E.project(\"KDE\"))\n source.append(E.module(self.repository.path))\n source.append(E.branch(self.repository.ref_name))\n\n cia_message.append(source)\n cia_message.append(self.TIMESTAMP(commit.date))\n\n body = self.BODY()\n\n commit_data = self.COMMIT()\n commit_data.append(E.author(commit.author_name))\n commit_data.append(E.revision(commit.description))\n commit_data.append(files)\n commit_data.append(E.log(commit_msg))\n commit_data.append(E.url(commit.url))\n\n body.append(commit_data)\n cia_message.append(body)\n\n # Convert to a string\n commit_xml = etree.tostring(cia_message)\n\n # Craft the email....\n message = MIMEText( commit_xml, 'xml', 'utf-8' )\n message['Subject'] = \"DeliverXML\"\n message['From'] = \"sysadmin@kde.org\"\n message['To'] = \"commits@platna.kde.org\"\n\n # Send email...\n self.smtp.sendmail(\"sysadmin@kde.org\", [\"commits@platna.kde.org\"],\n message.as_string())","def on_issue(self, payload):\n pass","def notify(self, MVCEvent) -> None:\n raise NotImplementedError(\"The notify method should be overridden in {}\".format(self.__class__))","def push(self):\n if self.forward:\n git = self.repo.git\n try:\n git.push()\n self.forward = \"pushed\"\n except:\n self.forward = \"push error - \"+self.forward","def test_topic_notification_notify_new_comment(self):\n creator = utils.create_user()\n subscriber = utils.create_user()\n topic = utils.create_topic(self.category)\n comment = utils.create_comment(user=creator, topic=topic)\n TopicNotification.objects.create(\n user=creator, topic=topic, comment=comment,\n is_active=True, is_read=True)\n TopicNotification.objects.create(\n user=subscriber, topic=topic, comment=comment,\n is_active=True, is_read=True)\n\n TopicNotification.notify_new_comment(comment)\n notification = TopicNotification.objects.get(\n user=subscriber, topic=topic)\n self.assertTrue(notification.is_active)\n self.assertFalse(notification.is_read)\n self.assertEqual(notification.action, COMMENT)\n\n # Author should not be notified of its own comment\n notification2 = TopicNotification.objects.get(\n user=creator, topic=topic)\n self.assertTrue(notification2.is_read)","def send_notification(summary, message=\"\", icon=None, update=True):\n if icon == None:\n icon = \"sonata\"\n\n if pynotify_module:\n global notification\n if update:\n notification.update(summary=summary, message=message, icon=icon)\n else:\n notification = pynotify.Notification(summary=summary, message=message, icon=icon)\n notification.show()\n else:\n # Use notify-send instead\n os.popen('notify-send -i \"{0}\" \"{1}\" \"{2}\"'.format(icon.replace('\"', '\\\\\"'), summary.replace('\"', '\\\\\"'), message.replace('\"', '\\\\\"')))","def perform(self):\n emails.notify(\n event=self.event_type,\n user=self.user,\n node=self.node,\n timestamp=self.timestamp,\n message=self.html_message,\n profile_image_url=self.profile_image_url,\n url=self.url\n )","def push(self, *arguments, **kwargs):\n return self.get_returncode('push', *arguments, **kwargs)","def push(self, event):\n ignored = self.ignored__.pop(event_key(event), None)\n if ignored:\n if event.date - ignored.date < 2:\n return\n\n cursor = self.conn.cursor()\n\n cursor.execute(\"\"\"\n SELECT * FROM events\n WHERE path = ? AND event = ? AND folder = ? AND countdown > 0\n \"\"\", [event.path, event.event, event.folder])\n\n row = cursor.fetchone()\n if row:\n # print \"Ingoring Duplicate event: %s\" % (event, )\n pass\n else:\n cursor.execute(\n \"REPLACE INTO events VALUES (?, ?, ?, ?, ?, ?, ?)\", event\n )\n self.conn.commit()","def cmd_push_review(remote):\n return ['git', 'push', remote]","def send_push_notification(request: Request, report_id: str, message: str):\n reports_collection = request.app.state.db.data.reports\n\n res = reports_collection.find_one({\"_id\": report_id})\n\n if res is None:\n raise HTTPException(404)\n\n report = Report(**res)\n\n pusher_client = request.app.state.pusher_client\n pusher_client.trigger(report.name, \"update\", {'message': message})","def notify(self, observable, *args, **kwargs) -> None:","def wiki_page_changed(self, page, version, t, comment, author, ipnr):\n if 'wiki' not in self.sources:\n return\n gnp = GrowlNotificationPacket(notification='wiki',\n title='Page updated',\n description=self._wiki_repr(page,\n comment))\n gs = GrowlSender(self.env)\n gs.notify(self._get_hosts('wiki'), gnp)","def notify(self):\n return _MethodCall(self._proto)","async def _notify(self):\n await self._event.acquire()\n self._event.notify_all()\n self._event.release()","def notifyChange(self, uri, observer, syncToNetwork=None, flags=None):\n pass","async def trigger_build(self, *, branch=None, message=None):","def _push_to_server(self) -> None:\n pass","def _get_pushes(self):\n data = json.loads(self._get().text)\n try:\n print(data)\n timestamp = data[\"pushes\"][0][\"modified\"]\n if timestamp != self._timestamp:\n self.update_timestamp.emit(timestamp)\n self._timestamp = timestamp\n else:\n return\n except IndexError:\n return None\n except KeyError:\n self._stop = True\n return None\n except Exception as e:\n exception_type = type(e).__name__\n print(exception_type)\n print(e)\n return None\n for push in data[\"pushes\"]:\n if push[\"type\"] == \"file\":\n self.media_received.emit(self._get_file_path(push[\"file_url\"]))","def svn_fs_invoke_pack_notify(*args):\r\n return _fs.svn_fs_invoke_pack_notify(*args)","def push():\n files = []\n for i in sp.check_output([\"git\", \"status\"]).decode().split(\"\\n\"):\n nf = \"#\\tnew file:\"\n mf = \"#\\tmodified:\"\n\t# Should have a deleted-files option here too.\n if i[: len(nf)] == nf or i[: len(mf)] == mf:\n f = i.split(\" \")[-1]\n files.append(f)\n files = list(set(files)) # Remove duplicates\n\n print(\"Committing these files: {}\".format(files))\n\n # Run all py scripts through black for formatting.\n# for f in files:\n# if f[-3:] == \".py\":\n# sp.call([\"black\", f])\n\n [sp.call([\"git\", \"add\", \"{}\".format(i)]) for i in files]\n\n commit_message = str(input(\"Enter commit message:\\n\"))\n commit_message = \"Updated\" if commit_message == \"\" else commit_message\n print(\"Committing with commit message of: {}\\n\\n\".format(commit_message))\n sp.call([\"git\", \"commit\", \"-m\", \"{}\".format(commit_message)])\n sp.call([\"git\", \"push\"])","def push_updates():\n check_call(['git', 'push', '--tags', '--force'])","def handle_issue(self, evt):\n author = self.format_nickname(evt.author)\n if evt.new:\n short_url = \"https://dolp.in/i%d\" % evt.issue\n url = Tags.UnderlineBlue(short_url)\n msg = 'Issue %d created: \"%s\" by %s - %s'\n msg = msg % (evt.issue, evt.title, author, url)\n else:\n short_url = \"https://dolp.in/i%d/%d\" % (evt.issue, evt.update)\n url = Tags.UnderlineBlue(short_url)\n msg = 'Update %d to issue %d (\"%s\") by %s - %s'\n msg = msg % (evt.update, evt.issue, evt.title, author, url)\n self.bot.say(msg)","def _push(project: Project):\n repo = project.repo\n remote_name = project.config.get('github.remote')\n remote = repo.remote(remote_name)\n result = _call_remote_push(remote)\n failures = lfilter(complement(did_git_push_succeed), result)\n if failures:\n for push_info in failures:\n logger.error(\n 'Failed to push ref {from_ref} to {to_ref}'\n .format(from_ref=push_info.local_ref.name,\n to_ref=push_info.remote_ref.name))\n raise BalletError('Push failed')","def send(self, event, message):\n pass","def notify(plaintext_message, signature):","def _notify(self, observable):\n pass","def notify(self, notification):\n topic = 'notify.' + notification['subject']\n payload = serializer.dumps(notification, use_bin_type=True)\n self.socket.send_string(topic, flags=zmq.SNDMORE)\n self.socket.send(payload)\n return self.socket.recv_string()","def push_updates(update_alias, config, path_or_url):\n api = get_packit_api(config=config, local_project=path_or_url)\n api.push_updates(update_alias)","def trigger_pushcut(notification: str, data=None) -> int:\n headers = {\"API-Key\": os.environ[\"PUSHCUT_API_TOKEN\"]}\n url = f\"https://api.pushcut.io/v1/notifications/{urllib.parse.quote(notification)}\"\n return requests.post(url, json=data, headers=headers).status_code","def wiki_page_added(self, page):\n if 'wiki' not in self.sources:\n return\n gnp = GrowlNotificationPacket(notification='wiki',\n title='Page created',\n description=page.name)\n gs = GrowlSender(self.env)\n gs.notify(self._get_hosts('wiki'), gnp)","def notify(self, event):\n if isinstance(event, EventEveryTick):\n cur_state = self.model.state.peek()\n if cur_state == model.STATE_PLAY:\n self.API_play()\n elif isinstance(event, EventQuit):\n pass\n elif isinstance(event, EventInitialize):\n self.initialize()","def notification_slack(Config, **notfication_data): \n slackConf = Config[\"NOTIFICAION_SLACK\"]\n slack_token = slackConf.get('slack_token')\n slack_channel = slackConf.get('slack_channel')\n slack_icon_url = slackConf.get('slack_icon_url')\n notification_description = slackConf.get('notification_description')\n \n result = NotifySlack(\n slack_token, \n slack_channel, \n slack_icon_url, \n notification_description,\n **notfication_data).send_message()\n \n if result['ok']:\n logging.debug('Sent a notification to {} channel'.format(slack_channel) )\n else:\n logging.debug(\"Failed sending notification, Error message - '{}'\".format(result['error']))","def trigger(self, data):\n if settings.PUSHER_ENABLED:\n\n # get the current timestamp\n pusher_start_ts = int(time.time())\n # use pusher to send the data to clients!\n self.pusher.trigger(self.channel, self.event, data)\n\n pusher_completed_ts = int(time.time())\n log_msg = 'PSHR_NOW=\"%s\", PSHR_NOW_TS=%s, PSHR_LOG=Send, PSHR_CHANNEL=%s, ' \\\n 'PSHR_EVENT=%s, PSHR_DATA_ID=\"%s\", PSHR_ITEM=Object, PSHR_VALUE=%s, ' \\\n 'PSHR_START_TS=%s, PSHR_END_TS=%s, PSHR_DELTA_MS=%s, ' % (\n str(timezone.now()),\n int(time.time()),\n self.channel,\n self.event,\n str(data.get('id')),\n str(data), str(\n pusher_start_ts), str(pusher_completed_ts),\n str(int(\n pusher_completed_ts - pusher_start_ts)))\n logger.debug(log_msg)\n\n else:\n # print to console if its disable to remind us\n logger.info(\n 'settings.PUSHER_ENABLED == False ... pusher.trigger() blocked. object not sent.')\n\n # Should we write out to a local kinda-json-formatted text file?\n if settings.PUSHER_OUTPUT_TO_FILE:\n file_path = 'tmp/pusher_events__%s.%s.txt' % (self.channel, self.event)\n logger.info(\"Writing out pusher events to: `%s`\" % file_path)\n\n try:\n # Open the file and append our event data in JSON format.\n with open(file_path, mode='a+', encoding='utf-8') as outfile:\n outfile.write(json.dumps(data))\n outfile.write('\\n')\n\n except Exception as e:\n logger.error(e)\n client.captureException()","def comment_added(self, event):\n import simplejson\n comment = str(event[\"comment\"])\n author_name = str(event[\"author\"][\"name\"])\n change_url = str(event[\"change\"][\"url\"])\n change_subject = str(event[\"change\"][\"subject\"])\n comment = simplejson.dumps({\n \"issue\": {\n \"notes\": self._prepare_comment_added_template(event)\n }\n })\n # get a unique list of issue IDs\n subject_issue_ids = self.__get_issue_ids(change_subject)\n comment_issue_ids = self.__get_issue_ids(comment)\n issue_ids = list(set(subject_issue_ids + comment_issue_ids))\n for issue_id in issue_ids:\n self.__add_comment(issue_id, comment)","def send_notification(self):\n s1 = System()\n b1 = Books(\"1984\", \"George Orwell\", \"Harvill Secker\", \"1949\", \"0123456789123\")\n m1 = Members(\"Richard\", \"Blackmore\", \"14-04-1945\", \"Weston\")\n s1.send_notification(\"Please return book\")\n self.assertEqual(m1.get_notifications(), None)\n s1.add_resource(b1)\n s1.lending_process(b1, m1)\n s1.send_notification(\"Please return book\")\n self.assertEqual(m1.get_notifications(), \"-Please return boo- \")","def notify(cls, state):\r\n return PlatformMessage(method=\"__reply__\", kwargs={\"state\": state})","def _notify(title, message, icon=\"dialog-error\"):\n try:\n import pynotify\n except ImportError:\n return\n pynotify.init(\"moya-doc\")\n n = pynotify.Notification(title, message, icon)\n n.show()"],"string":"[\n \"def on_push(self, payload):\\n pass\",\n \"def notify(self, event):\\n\\n self.send_json(event[\\\"payload\\\"])\",\n \"def push(event):\\n _pushedEvents.append(event)\",\n \"def send_notification (event):\\n Publisher.sendMessage (event)\",\n \"def notify(self, event):\\n raise NotImplementedError\",\n \"def svn_notify(self,event):\\n # pysvn.wc_notify_action.update_completed\\n if event['action'] == pysvn.wc_notify_action.update_completed:\\n revision = event['revision']\\n self.revision = revision\",\n \"def on_push(self, data):\\n if data[\\\"type\\\"] == \\\"push\\\":\\n self._data = data[\\\"push\\\"]\",\n \"def push(self, *args, **kwargs):\\n pass\",\n \"def on_notify(self, name):\\r\\n pass\",\n \"def dispatch_push(self, p, tweaks, badge):\\n pass\",\n \"async def process_push_hook(push: models.PushHook):\\n repository = push.repository\\n project = push.project\\n commit_str = \\\"commit\\\" if push.total_commits_count == 1 else \\\"commits\\\"\\n # Show link to commit compare if there's more than one commit\\n if push.total_commits_count > 1:\\n embed_url = f\\\"{repository.homepage}/compare/{push.before[:7]}...{push.after[:7]}\\\"\\n else:\\n embed_url = f\\\"{repository.homepage}/commit/{push.after[:7]}\\\"\\n\\n if push.before == EMPTY_COMMIT:\\n embed = discord.Embed(title=f\\\"[{project.namespace}/{project.name}] New branch created {push.branch}\\\",\\n url=embed_url, colour=discord.Colour.light_grey())\\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)\\n elif push.after == EMPTY_COMMIT:\\n embed = discord.Embed(title=f\\\"[{project.namespace}/{project.name}] Branch deleted {push.branch}\\\",\\n url=embed_url, colour=discord.Colour.light_grey())\\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)\\n\\n # If there are no commits, do not show a message\\n if not push.total_commits_count:\\n return\\n\\n embed = discord.Embed(title=f\\\"[{project.namespace}/{project.name}:{push.branch}] \\\"\\n f\\\"{push.total_commits_count} new {commit_str}\\\",\\n url=embed_url, colour=discord.Colour.blurple())\\n embed.set_author(name=push.user_name, icon_url=push.user_avatar)\\n embed.description = \\\"\\\"\\n for commit in push.commits:\\n message = commit.message.splitlines()[0]\\n embed.description += f\\\"[`{commit.id[:7]}`]({commit.url}) {message} - {commit.author.name}\\\\n\\\"\\n print(\\\"Sending push message\\\")\\n await send_message(None, embed=embed, avatar_url=push.project.avatar_url)\",\n \"def _send_notification() -> None:\\n send_notification(\\n self,\\n \\\"slack:@aaron\\\",\\n \\\"New {0} Version: {1}\\\".format(\\n self.properties[CONF_APP_NAME], new_version\\n ),\\n title=\\\"New Software 💿\\\",\\n )\",\n \"def infocalypse_push(ui_, repo, **opts):\\n params, stored_cfg = get_config_info(ui_, opts)\\n insert_uri = opts['uri']\\n if insert_uri == '':\\n insert_uri = stored_cfg.get_dir_insert_uri(repo.root)\\n if not insert_uri:\\n ui_.warn(\\\"There is no stored insert URI for this repo.\\\\n\\\"\\n \\\"Please set one with the --uri option.\\\\n\\\")\\n return\\n\\n set_target_version(ui_, repo, opts, params,\\n \\\"Only pushing to version(s): %s\\\\n\\\")\\n params['INSERT_URI'] = insert_uri\\n #if opts['requesturi'] != '':\\n # # DOESN'T search the insert uri index.\\n # ui_.status((\\\"Copying from:\\\\n%s\\\\nTo:\\\\n%s\\\\n\\\\nThis is an \\\"\\n # + \\\"advanced feature. \\\"\\n # + \\\"I hope you know what you're doing.\\\\n\\\") %\\n # (opts['requesturi'], insert_uri))\\n # params['REQUEST_URI'] = opts['requesturi']\\n\\n execute_push(ui_, repo, params, stored_cfg)\",\n \"def __gitPush(self):\\n self.vcs.gitPush(self.project.getProjectPath())\",\n \"def notify_new(self, **kwargs):\\n return self.notify(\\\"notify_new\\\", **kwargs)\",\n \"def create_push_notification(package, repository):\\n # type: (str, str) -> str\\n notification_dict = {\\n \\\"repository\\\": repository,\\n \\\"package\\\": package,\\n \\\"event\\\": \\\"push\\\",\\n }\\n return json.dumps(notification_dict)\",\n \"def on_new_notification(data, index, *args):\\n print(data)\",\n \"def remote_push(self, pNamespace):\",\n \"def notify(r, wiki):\\n\\n if not settings.EMAIL_NOTIFY:\\n return\\n\\n HEAD = r.repo.head.commit\\n HEADp = r.repo.head.commit.parents[0]\\n\\n diff = r.repo.git.diff(HEADp.hexsha, HEAD.hexsha)\\n\\n send_mail(u'[wiki/{0}] {1}'.format(wiki, HEAD.message), diff, os.environ['GIT_AUTHOR_EMAIL'], settings.EMAIL_LIST, fail_silently=True)\",\n \"def notify(cls, self, message):\\n pass\",\n \"def notify(self) -> None:\\n pass\",\n \"def notify(self) -> None:\\n pass\",\n \"def write(self, notification):\",\n \"def push_commits(self, verbose=True):\\n # The subprocess will return a non-zero exit code even if it succeeded.\\n # Check its output to determine whether it worked.\\n push_proc = subprocess.run(\\n [\\\"git\\\", \\\"push\\\"],\\n cwd=self.path,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT,\\n universal_newlines=True,\\n )\\n if \\\"updated in conservator\\\" not in push_proc.stdout:\\n if \\\"Everything up-to-date\\\" in push_proc.stdout:\\n logger.warning(push_proc.stdout)\\n else:\\n logger.error(\\n \\\"Server did not accept changes to index.json:\\\\n%s\\\", push_proc.stdout\\n )\\n raise RuntimeError(\\\"Failed to push changes to index.json\\\")\\n self.pull(verbose)\",\n \"def call_git_push():\\n print(\\\"This will commit and push the git repo\\\")\\n today = datetime.datetime.today()\\n call([\\\"git\\\", \\\"add\\\", \\\".\\\"])\\n call([\\\"git\\\", \\\"commit\\\", \\\"-m\\\", \\\"Updated notes. {:%Y-%m-%d %H:%M:%S}\\\".format(today)])\\n call([\\\"git\\\", \\\"push\\\", \\\"origin\\\", \\\"master\\\"])\",\n \"def on_commit_comment(self, payload):\\n pass\",\n \"def notify_on_action(self):\\n desired_action = self.pr.config.actionToBeNotifiedFor\\n if self.pr.action == desired_action:\\n if self.pr.base_branch == self.pr.config.mainBranch:\\n msg = MSG_OPENED_TO_MAIN_BRANCH.format(repo=self.pr.repo, pr_by=self.created_by,\\n main_branch=self.pr.config.mainBranch, title=self.pr.title,\\n pr=self.pr.link_pretty, action=self.pr.action)\\n for person in self.pr.config.techLeadsToBeNotified:\\n self.slack.postToSlack(person, msg + MSG_RELEASE_PREPARATION)\\n LOG.info(\\\"Notified to %s on action %s\\\" % (self.pr.config.techLeadsToBeNotified, self.pr.action))\\n return {\\\"msg\\\": \\\"Notified to %s on action %s\\\" % (self.pr.config.techLeadsToBeNotified, self.pr.action)}\\n else:\\n msg = MSG_OPENED_TO_PREVENTED_BRANCH.format(repo=self.pr.repo, pr_by=self.created_by,\\n base_branch=self.pr.base_branch, title=self.pr.title,\\n pr=self.pr.link_pretty, action=self.pr.action)\\n self.slack.postToSlack(self.pr.config.personToBeNotified, msg)\\n LOG.info(\\\"Notified to %s on action %s\\\" % (self.pr.config.personToBeNotified, self.pr.action))\\n return {\\\"msg\\\": \\\"Notified to %s on action %s\\\" % (self.pr.config.personToBeNotified, self.pr.action)}\\n return {\\\"msg\\\": \\\"Skipped notify because its (%s) not desired event '%s'\\\" %(self.pr.action, desired_action)}\",\n \"def __notify_slack(self):\\n\\t\\ttry:\\n\\t\\t\\tprint(\\\"[+] Sending Slack notifications...\\\")\\n\\t\\t\\tslack_http_headers = {\\n\\t\\t\\t\\t'User-Agent': 'GitHubScrap',\\n\\t\\t\\t\\t'Content-type': 'application/json',\\n\\t\\t\\t}\\n\\t\\t\\tslack_http_data = {}\\n\\t\\t\\tfor ix in range(0,len(self.final_results[\\\"results\\\"]),SLACK_CHUNK_SIZE):\\n\\t\\t\\t\\tdata_to_send = \\\"\\\"\\n\\t\\t\\t\\tchunk_results = self.final_results[\\\"results\\\"][ix:ix+SLACK_CHUNK_SIZE]\\n\\t\\t\\t\\tfor url in chunk_results:\\n\\t\\t\\t\\t\\tdata_to_send += \\\"{} ({})\\\\n\\\".format(url[\\\"query\\\"], url[\\\"link\\\"])\\n\\n\\t\\t\\t\\tslack_http_data.update({\\n\\t\\t\\t\\t\\t'text': data_to_send,\\n\\t\\t\\t\\t})\\n\\t\\t\\t\\trequests.post(\\n\\t\\t\\t\\t\\tself.slack_webhook,\\n\\t\\t\\t\\t\\theaders = slack_http_headers,\\n\\t\\t\\t\\t\\tdata = json.dumps(slack_http_data),\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\tsleep(SLACK_HTTP_DELAY)\\n\\n\\t\\texcept Exception as exception:\\n\\t\\t\\traise MsgException('Slack notifications could not be sent', exception)\",\n \"async def notify(self, message: str) -> None:\\n\\n pass\",\n \"def start_notify(self, on_change):\\n raise NotImplementedError\",\n \"def _push(self):\\n push_cmds = self.vcs.push_commands()\\n if not push_cmds:\\n return\\n if utils.ask(\\\"OK to push commits to the server?\\\"):\\n for push_cmd in push_cmds:\\n output = execute_command(push_cmd)\\n logger.info(output)\",\n \"def notify(guid, message):\",\n \"def on_issue_comment(self, payload):\\n pass\",\n \"def notify(self):\\n if self.has_changed:\\n event = self.event_factory(self.resource, registry=self.registry, schema=self.schema,\\n changed=self.changed)\\n self.registry.notify(event)\",\n \"def on_watch(self, payload):\\n pass\",\n \"def on_pull_request(self, payload):\\n pass\",\n \"def receive_notification(self, *args, **kwargs):\\n\\t\\tprint(f\\\"{self.__location} is now hearing \\\\\\\"{args[0]}\\\\\\\" on {args[1]}\\\")\",\n \"def push_the_change(self, issue_id: str, commit_msg: List[str] = None) -> None:\\n index = self.git.index\\n index.add([\\\"INFO.yaml\\\"])\\n if not commit_msg:\\n commit_msg = [\\\"Edit INFO.yaml file.\\\"]\\n commit_msg_with_m = list(\\n chain.from_iterable(zip_longest([], commit_msg, fillvalue=\\\"-m\\\"))\\n )\\n self.git.git.execute(\\n [\\n \\\"git\\\",\\n \\\"commit\\\",\\n *commit_msg_with_m,\\n \\\"-m\\\",\\n \\\"That change was done by automated integration tool to maintain commiters list in INFO.yaml\\\",\\n \\\"-m\\\",\\n f\\\"Issue-ID: {issue_id}\\\",\\n \\\"-s\\\",\\n ]\\n )\\n self.git.git.execute([\\\"git\\\", \\\"push\\\", \\\"origin\\\", f\\\"HEAD:refs/for/{self._branch}\\\"])\\n print(f\\\"Pushed successfully to {self._repo} respository\\\")\",\n \"def push(self):\\n out, err, code = self.command( [\\\"git\\\", \\\"push\\\"], self.directory )\",\n \"def notify(self, event, user):\\n raise NotImplementedError(\\\"Subclasses must override notify() method\\\")\",\n \"def notify(self, title, message, config):\\n notification = {\\n 'application': config.get('application'),\\n 'event': title,\\n 'description': message,\\n 'url': config.get('url'),\\n 'priority': config.get('priority'),\\n 'providerkey': config.get('provider_key'),\\n }\\n\\n if isinstance(config['api_key'], list):\\n config['api_key'] = [config['api_key']]\\n notification['apikey'] = config['api_key']\\n\\n try:\\n response = requests.post(PROWL_URL, data=notification)\\n except RequestException as e:\\n raise PluginWarning(repr(e))\\n\\n request_status = ET.fromstring(response.content)\\n error = request_status.find('error')\\n if error is not None:\\n raise PluginWarning(error.text)\\n else:\\n success = request_status.find('success').attrib\\n logger.debug(\\n 'prowl notification sent. Notifications remaining until next reset: {}. '\\n 'Next reset will occur in {} minutes',\\n success['remaining'],\\n success['resetdate'],\\n )\",\n \"def create_pr_notification(package, repository, id):\\n # type: (str, str, int) -> str\\n notification_dict = {\\n \\\"repository\\\": repository,\\n \\\"package\\\": package,\\n \\\"event\\\": \\\"pull-request\\\",\\n \\\"id\\\": id\\n }\\n return json.dumps(notification_dict)\",\n \"def push_update_reference(self, refname, message):\",\n \"def git_webhook():\\n client = MongoClient(os.getenv('MONGODB_URI', 'mongodb://localhost:27017'))\\n database = client.get_database()\\n content = {\\n \\\"event\\\": request.headers['X-GitHub-Event'],\\n \\\"payload\\\" : request.json,\\n \\\"date\\\": datetime.utcnow()\\n }\\n log.info(\\\"Content Received - \\\", request.headers['X-GitHub-Delivery'])\\n inserted_id = database.events.insert_one(content).inserted_id\\n log.info(\\\"Content Inserted - \\\", inserted_id)\\n return jsonify({\\n \\\"message\\\": \\\"Okay!\\\"\\n })\",\n \"def push(self):\\n self.runtime.logger.info('Pushing config...')\\n with Dir(self.runtime.metadata_dir):\\n exectools.cmd_assert([\\\"git\\\", \\\"push\\\"])\",\n \"def event_player_push(self) -> None:\\n print(f\\\"You got a push, your bet of {self.user.bet} is returned\\\")\",\n \"def infocalypse_fmsnotify(ui_, repo, **opts):\\n params, stored_cfg = get_config_info(ui_, opts)\\n insert_uri = stored_cfg.get_dir_insert_uri(repo.root)\\n if not insert_uri and not (opts['submitbundle'] or\\n opts['submitwiki']):\\n ui_.warn(\\\"You can't notify because there's no stored \\\"\\n + \\\"insert URI for this repo.\\\\n\\\"\\n + \\\"Run from the directory you inserted from.\\\\n\\\")\\n return\\n\\n params['ANNOUNCE'] = opts['announce']\\n params['SUBMIT_BUNDLE'] = opts['submitbundle']\\n params['SUBMIT_WIKI'] = opts['submitwiki']\\n if params['SUBMIT_WIKI'] or params['SUBMIT_BUNDLE']:\\n request_uri = stored_cfg.get_request_uri(repo.root)\\n if not request_uri:\\n ui_.warn(\\\"There is no stored request URI for this repo.\\\\n\\\")\\n raise util.Abort(\\\"No request URI.\\\")\\n params['REQUEST_URI'] = request_uri\\n\\n params['DRYRUN'] = opts['dryrun']\\n params['INSERT_URI'] = insert_uri\\n execute_fmsnotify(ui_, repo, params, stored_cfg)\",\n \"def handle(self):\\n self.app.logger.info('==== handle github event: %s', self.event)\\n # self.app.logger.info('data send: %s', json.dumps(self.data, indent=2))\\n if self.event == 'ping':\\n return {'msg': 'Hi!'}\\n else:\\n task_match = []\\n repo_config = self.get_repo_config()\\n if repo_config:\\n for task_config in repo_config['tasks']:\\n event_hit = False\\n if self.event == 'push':\\n event_hit = self._is_task_push(task_config)\\n elif self.event == 'pull_request':\\n event_hit = self._is_task_pull_request(task_config)\\n if event_hit:\\n task_match.append(task_config)\\n # work start execute here...\\n for task in task_match:\\n self.app.logger.info(\\\"event hit, start tasks under %s/%s...\\\", self.repo_meta['owner'], self.repo_meta['name'])\\n self._jenkins_build(task)\\n pass\\n return \\\"OK\\\"\",\n \"def notify(self, event):\\n for o in self.observers:\\n o.on_notify(event)\",\n \"def execute(self):\\n return LOGGER.info(f\\\"{datetime.datetime.now()} - Sending notification in Slack\\\")\",\n \"def notify(self, event):\\n for observer in self.observers:\\n observer.on_notify(event)\",\n \"def notify(self, event):\\n for observer in self.observers:\\n observer.on_notify(event)\",\n \"def notified(self, notified):\\n\\n self._notified = notified\",\n \"def push_changes_mock(*_, **__):\\n return \\\"origin\\\"\",\n \"def push():\\n local('hg push jvacx')\",\n \"def create_issue_notification(package, repository, id):\\n # type: (str, str, int) -> str\\n notification_dict = {\\n \\\"repository\\\": repository,\\n \\\"package\\\": package,\\n \\\"event\\\": \\\"issue\\\",\\n \\\"id\\\": id\\n }\\n return json.dumps(notification_dict)\",\n \"def push(self):\\n origin = self.git_repo.remotes.origin\\n origin.push()\",\n \"def retrieve_pushes(self):\\n\\n self.listener = Listener(account=self.pushbullet, on_push=self.on_push)\\n _LOGGER.debug(\\\"Getting pushes\\\")\\n try:\\n self.listener.run_forever()\\n finally:\\n self.listener.close()\",\n \"def notify(self, **kwargs):\\n return self.send(kwargs)\",\n \"def notify(self, **kwargs):\\n return self.send(kwargs)\",\n \"def on_publish(client, userdata, mid):\\n print(\\\"Message Published.\\\")\",\n \"def handleNotification(self, notification):\\n pass\",\n \"def notify(self, builder):\\n\\n # Build the <files> section for the template...\\n commit = builder.commit\\n files = E.files()\\n\\n commit_msg = commit.message.strip()\\n commit_msg = re.sub(r'[\\\\x00-\\\\x09\\\\x0B-\\\\x1f\\\\x7f-\\\\xff]', '', commit_msg)\\n\\n for filename in commit.files_changed:\\n safe_filename = re.sub(r'[\\\\x00-\\\\x09\\\\x0B-\\\\x1f\\\\x7f-\\\\xff]', '', filename)\\n file_element = E.file(safe_filename)\\n files.append(file_element)\\n\\n # Build the message\\n cia_message = self.MESSAGE()\\n cia_message.append(self._generator)\\n\\n source = self.SOURCE(E.project(\\\"KDE\\\"))\\n source.append(E.module(self.repository.path))\\n source.append(E.branch(self.repository.ref_name))\\n\\n cia_message.append(source)\\n cia_message.append(self.TIMESTAMP(commit.date))\\n\\n body = self.BODY()\\n\\n commit_data = self.COMMIT()\\n commit_data.append(E.author(commit.author_name))\\n commit_data.append(E.revision(commit.description))\\n commit_data.append(files)\\n commit_data.append(E.log(commit_msg))\\n commit_data.append(E.url(commit.url))\\n\\n body.append(commit_data)\\n cia_message.append(body)\\n\\n # Convert to a string\\n commit_xml = etree.tostring(cia_message)\\n\\n # Craft the email....\\n message = MIMEText( commit_xml, 'xml', 'utf-8' )\\n message['Subject'] = \\\"DeliverXML\\\"\\n message['From'] = \\\"sysadmin@kde.org\\\"\\n message['To'] = \\\"commits@platna.kde.org\\\"\\n\\n # Send email...\\n self.smtp.sendmail(\\\"sysadmin@kde.org\\\", [\\\"commits@platna.kde.org\\\"],\\n message.as_string())\",\n \"def on_issue(self, payload):\\n pass\",\n \"def notify(self, MVCEvent) -> None:\\n raise NotImplementedError(\\\"The notify method should be overridden in {}\\\".format(self.__class__))\",\n \"def push(self):\\n if self.forward:\\n git = self.repo.git\\n try:\\n git.push()\\n self.forward = \\\"pushed\\\"\\n except:\\n self.forward = \\\"push error - \\\"+self.forward\",\n \"def test_topic_notification_notify_new_comment(self):\\n creator = utils.create_user()\\n subscriber = utils.create_user()\\n topic = utils.create_topic(self.category)\\n comment = utils.create_comment(user=creator, topic=topic)\\n TopicNotification.objects.create(\\n user=creator, topic=topic, comment=comment,\\n is_active=True, is_read=True)\\n TopicNotification.objects.create(\\n user=subscriber, topic=topic, comment=comment,\\n is_active=True, is_read=True)\\n\\n TopicNotification.notify_new_comment(comment)\\n notification = TopicNotification.objects.get(\\n user=subscriber, topic=topic)\\n self.assertTrue(notification.is_active)\\n self.assertFalse(notification.is_read)\\n self.assertEqual(notification.action, COMMENT)\\n\\n # Author should not be notified of its own comment\\n notification2 = TopicNotification.objects.get(\\n user=creator, topic=topic)\\n self.assertTrue(notification2.is_read)\",\n \"def send_notification(summary, message=\\\"\\\", icon=None, update=True):\\n if icon == None:\\n icon = \\\"sonata\\\"\\n\\n if pynotify_module:\\n global notification\\n if update:\\n notification.update(summary=summary, message=message, icon=icon)\\n else:\\n notification = pynotify.Notification(summary=summary, message=message, icon=icon)\\n notification.show()\\n else:\\n # Use notify-send instead\\n os.popen('notify-send -i \\\"{0}\\\" \\\"{1}\\\" \\\"{2}\\\"'.format(icon.replace('\\\"', '\\\\\\\\\\\"'), summary.replace('\\\"', '\\\\\\\\\\\"'), message.replace('\\\"', '\\\\\\\\\\\"')))\",\n \"def perform(self):\\n emails.notify(\\n event=self.event_type,\\n user=self.user,\\n node=self.node,\\n timestamp=self.timestamp,\\n message=self.html_message,\\n profile_image_url=self.profile_image_url,\\n url=self.url\\n )\",\n \"def push(self, *arguments, **kwargs):\\n return self.get_returncode('push', *arguments, **kwargs)\",\n \"def push(self, event):\\n ignored = self.ignored__.pop(event_key(event), None)\\n if ignored:\\n if event.date - ignored.date < 2:\\n return\\n\\n cursor = self.conn.cursor()\\n\\n cursor.execute(\\\"\\\"\\\"\\n SELECT * FROM events\\n WHERE path = ? AND event = ? AND folder = ? AND countdown > 0\\n \\\"\\\"\\\", [event.path, event.event, event.folder])\\n\\n row = cursor.fetchone()\\n if row:\\n # print \\\"Ingoring Duplicate event: %s\\\" % (event, )\\n pass\\n else:\\n cursor.execute(\\n \\\"REPLACE INTO events VALUES (?, ?, ?, ?, ?, ?, ?)\\\", event\\n )\\n self.conn.commit()\",\n \"def cmd_push_review(remote):\\n return ['git', 'push', remote]\",\n \"def send_push_notification(request: Request, report_id: str, message: str):\\n reports_collection = request.app.state.db.data.reports\\n\\n res = reports_collection.find_one({\\\"_id\\\": report_id})\\n\\n if res is None:\\n raise HTTPException(404)\\n\\n report = Report(**res)\\n\\n pusher_client = request.app.state.pusher_client\\n pusher_client.trigger(report.name, \\\"update\\\", {'message': message})\",\n \"def notify(self, observable, *args, **kwargs) -> None:\",\n \"def wiki_page_changed(self, page, version, t, comment, author, ipnr):\\n if 'wiki' not in self.sources:\\n return\\n gnp = GrowlNotificationPacket(notification='wiki',\\n title='Page updated',\\n description=self._wiki_repr(page,\\n comment))\\n gs = GrowlSender(self.env)\\n gs.notify(self._get_hosts('wiki'), gnp)\",\n \"def notify(self):\\n return _MethodCall(self._proto)\",\n \"async def _notify(self):\\n await self._event.acquire()\\n self._event.notify_all()\\n self._event.release()\",\n \"def notifyChange(self, uri, observer, syncToNetwork=None, flags=None):\\n pass\",\n \"async def trigger_build(self, *, branch=None, message=None):\",\n \"def _push_to_server(self) -> None:\\n pass\",\n \"def _get_pushes(self):\\n data = json.loads(self._get().text)\\n try:\\n print(data)\\n timestamp = data[\\\"pushes\\\"][0][\\\"modified\\\"]\\n if timestamp != self._timestamp:\\n self.update_timestamp.emit(timestamp)\\n self._timestamp = timestamp\\n else:\\n return\\n except IndexError:\\n return None\\n except KeyError:\\n self._stop = True\\n return None\\n except Exception as e:\\n exception_type = type(e).__name__\\n print(exception_type)\\n print(e)\\n return None\\n for push in data[\\\"pushes\\\"]:\\n if push[\\\"type\\\"] == \\\"file\\\":\\n self.media_received.emit(self._get_file_path(push[\\\"file_url\\\"]))\",\n \"def svn_fs_invoke_pack_notify(*args):\\r\\n return _fs.svn_fs_invoke_pack_notify(*args)\",\n \"def push():\\n files = []\\n for i in sp.check_output([\\\"git\\\", \\\"status\\\"]).decode().split(\\\"\\\\n\\\"):\\n nf = \\\"#\\\\tnew file:\\\"\\n mf = \\\"#\\\\tmodified:\\\"\\n\\t# Should have a deleted-files option here too.\\n if i[: len(nf)] == nf or i[: len(mf)] == mf:\\n f = i.split(\\\" \\\")[-1]\\n files.append(f)\\n files = list(set(files)) # Remove duplicates\\n\\n print(\\\"Committing these files: {}\\\".format(files))\\n\\n # Run all py scripts through black for formatting.\\n# for f in files:\\n# if f[-3:] == \\\".py\\\":\\n# sp.call([\\\"black\\\", f])\\n\\n [sp.call([\\\"git\\\", \\\"add\\\", \\\"{}\\\".format(i)]) for i in files]\\n\\n commit_message = str(input(\\\"Enter commit message:\\\\n\\\"))\\n commit_message = \\\"Updated\\\" if commit_message == \\\"\\\" else commit_message\\n print(\\\"Committing with commit message of: {}\\\\n\\\\n\\\".format(commit_message))\\n sp.call([\\\"git\\\", \\\"commit\\\", \\\"-m\\\", \\\"{}\\\".format(commit_message)])\\n sp.call([\\\"git\\\", \\\"push\\\"])\",\n \"def push_updates():\\n check_call(['git', 'push', '--tags', '--force'])\",\n \"def handle_issue(self, evt):\\n author = self.format_nickname(evt.author)\\n if evt.new:\\n short_url = \\\"https://dolp.in/i%d\\\" % evt.issue\\n url = Tags.UnderlineBlue(short_url)\\n msg = 'Issue %d created: \\\"%s\\\" by %s - %s'\\n msg = msg % (evt.issue, evt.title, author, url)\\n else:\\n short_url = \\\"https://dolp.in/i%d/%d\\\" % (evt.issue, evt.update)\\n url = Tags.UnderlineBlue(short_url)\\n msg = 'Update %d to issue %d (\\\"%s\\\") by %s - %s'\\n msg = msg % (evt.update, evt.issue, evt.title, author, url)\\n self.bot.say(msg)\",\n \"def _push(project: Project):\\n repo = project.repo\\n remote_name = project.config.get('github.remote')\\n remote = repo.remote(remote_name)\\n result = _call_remote_push(remote)\\n failures = lfilter(complement(did_git_push_succeed), result)\\n if failures:\\n for push_info in failures:\\n logger.error(\\n 'Failed to push ref {from_ref} to {to_ref}'\\n .format(from_ref=push_info.local_ref.name,\\n to_ref=push_info.remote_ref.name))\\n raise BalletError('Push failed')\",\n \"def send(self, event, message):\\n pass\",\n \"def notify(plaintext_message, signature):\",\n \"def _notify(self, observable):\\n pass\",\n \"def notify(self, notification):\\n topic = 'notify.' + notification['subject']\\n payload = serializer.dumps(notification, use_bin_type=True)\\n self.socket.send_string(topic, flags=zmq.SNDMORE)\\n self.socket.send(payload)\\n return self.socket.recv_string()\",\n \"def push_updates(update_alias, config, path_or_url):\\n api = get_packit_api(config=config, local_project=path_or_url)\\n api.push_updates(update_alias)\",\n \"def trigger_pushcut(notification: str, data=None) -> int:\\n headers = {\\\"API-Key\\\": os.environ[\\\"PUSHCUT_API_TOKEN\\\"]}\\n url = f\\\"https://api.pushcut.io/v1/notifications/{urllib.parse.quote(notification)}\\\"\\n return requests.post(url, json=data, headers=headers).status_code\",\n \"def wiki_page_added(self, page):\\n if 'wiki' not in self.sources:\\n return\\n gnp = GrowlNotificationPacket(notification='wiki',\\n title='Page created',\\n description=page.name)\\n gs = GrowlSender(self.env)\\n gs.notify(self._get_hosts('wiki'), gnp)\",\n \"def notify(self, event):\\n if isinstance(event, EventEveryTick):\\n cur_state = self.model.state.peek()\\n if cur_state == model.STATE_PLAY:\\n self.API_play()\\n elif isinstance(event, EventQuit):\\n pass\\n elif isinstance(event, EventInitialize):\\n self.initialize()\",\n \"def notification_slack(Config, **notfication_data): \\n slackConf = Config[\\\"NOTIFICAION_SLACK\\\"]\\n slack_token = slackConf.get('slack_token')\\n slack_channel = slackConf.get('slack_channel')\\n slack_icon_url = slackConf.get('slack_icon_url')\\n notification_description = slackConf.get('notification_description')\\n \\n result = NotifySlack(\\n slack_token, \\n slack_channel, \\n slack_icon_url, \\n notification_description,\\n **notfication_data).send_message()\\n \\n if result['ok']:\\n logging.debug('Sent a notification to {} channel'.format(slack_channel) )\\n else:\\n logging.debug(\\\"Failed sending notification, Error message - '{}'\\\".format(result['error']))\",\n \"def trigger(self, data):\\n if settings.PUSHER_ENABLED:\\n\\n # get the current timestamp\\n pusher_start_ts = int(time.time())\\n # use pusher to send the data to clients!\\n self.pusher.trigger(self.channel, self.event, data)\\n\\n pusher_completed_ts = int(time.time())\\n log_msg = 'PSHR_NOW=\\\"%s\\\", PSHR_NOW_TS=%s, PSHR_LOG=Send, PSHR_CHANNEL=%s, ' \\\\\\n 'PSHR_EVENT=%s, PSHR_DATA_ID=\\\"%s\\\", PSHR_ITEM=Object, PSHR_VALUE=%s, ' \\\\\\n 'PSHR_START_TS=%s, PSHR_END_TS=%s, PSHR_DELTA_MS=%s, ' % (\\n str(timezone.now()),\\n int(time.time()),\\n self.channel,\\n self.event,\\n str(data.get('id')),\\n str(data), str(\\n pusher_start_ts), str(pusher_completed_ts),\\n str(int(\\n pusher_completed_ts - pusher_start_ts)))\\n logger.debug(log_msg)\\n\\n else:\\n # print to console if its disable to remind us\\n logger.info(\\n 'settings.PUSHER_ENABLED == False ... pusher.trigger() blocked. object not sent.')\\n\\n # Should we write out to a local kinda-json-formatted text file?\\n if settings.PUSHER_OUTPUT_TO_FILE:\\n file_path = 'tmp/pusher_events__%s.%s.txt' % (self.channel, self.event)\\n logger.info(\\\"Writing out pusher events to: `%s`\\\" % file_path)\\n\\n try:\\n # Open the file and append our event data in JSON format.\\n with open(file_path, mode='a+', encoding='utf-8') as outfile:\\n outfile.write(json.dumps(data))\\n outfile.write('\\\\n')\\n\\n except Exception as e:\\n logger.error(e)\\n client.captureException()\",\n \"def comment_added(self, event):\\n import simplejson\\n comment = str(event[\\\"comment\\\"])\\n author_name = str(event[\\\"author\\\"][\\\"name\\\"])\\n change_url = str(event[\\\"change\\\"][\\\"url\\\"])\\n change_subject = str(event[\\\"change\\\"][\\\"subject\\\"])\\n comment = simplejson.dumps({\\n \\\"issue\\\": {\\n \\\"notes\\\": self._prepare_comment_added_template(event)\\n }\\n })\\n # get a unique list of issue IDs\\n subject_issue_ids = self.__get_issue_ids(change_subject)\\n comment_issue_ids = self.__get_issue_ids(comment)\\n issue_ids = list(set(subject_issue_ids + comment_issue_ids))\\n for issue_id in issue_ids:\\n self.__add_comment(issue_id, comment)\",\n \"def send_notification(self):\\n s1 = System()\\n b1 = Books(\\\"1984\\\", \\\"George Orwell\\\", \\\"Harvill Secker\\\", \\\"1949\\\", \\\"0123456789123\\\")\\n m1 = Members(\\\"Richard\\\", \\\"Blackmore\\\", \\\"14-04-1945\\\", \\\"Weston\\\")\\n s1.send_notification(\\\"Please return book\\\")\\n self.assertEqual(m1.get_notifications(), None)\\n s1.add_resource(b1)\\n s1.lending_process(b1, m1)\\n s1.send_notification(\\\"Please return book\\\")\\n self.assertEqual(m1.get_notifications(), \\\"-Please return boo- \\\")\",\n \"def notify(cls, state):\\r\\n return PlatformMessage(method=\\\"__reply__\\\", kwargs={\\\"state\\\": state})\",\n \"def _notify(title, message, icon=\\\"dialog-error\\\"):\\n try:\\n import pynotify\\n except ImportError:\\n return\\n pynotify.init(\\\"moya-doc\\\")\\n n = pynotify.Notification(title, message, icon)\\n n.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6505522","0.6299715","0.62783396","0.6245916","0.6223001","0.5992067","0.59633183","0.59553176","0.59267044","0.58976245","0.58153737","0.5808903","0.574537","0.5725313","0.5693843","0.5667237","0.5548502","0.55202025","0.5500606","0.54958946","0.54796505","0.54796505","0.54748994","0.54677004","0.5462145","0.5455995","0.5423602","0.53951573","0.5391456","0.5378304","0.53751034","0.5346756","0.5344724","0.5311645","0.5309366","0.53011835","0.52955645","0.52874506","0.52776784","0.52774656","0.52739155","0.52730495","0.5271506","0.52621245","0.52480346","0.524702","0.52264774","0.5215678","0.52148026","0.5214725","0.5205414","0.5205414","0.5187964","0.518781","0.5169619","0.5164741","0.515414","0.5152327","0.5147482","0.5147482","0.51425546","0.5141276","0.51398236","0.5138008","0.51377904","0.5134723","0.5133375","0.5125691","0.51228416","0.5088475","0.50811976","0.50692284","0.5064841","0.50565135","0.5050606","0.50430864","0.5024439","0.5020901","0.5009663","0.4993434","0.49921224","0.49786246","0.4970846","0.49640474","0.49605137","0.4957253","0.495697","0.49477","0.49458015","0.49375254","0.49374583","0.492599","0.49200788","0.49160925","0.49086112","0.48947304","0.4890608","0.48844343","0.48822334","0.48809305"],"string":"[\n \"0.6505522\",\n \"0.6299715\",\n \"0.62783396\",\n \"0.6245916\",\n \"0.6223001\",\n \"0.5992067\",\n \"0.59633183\",\n \"0.59553176\",\n \"0.59267044\",\n \"0.58976245\",\n \"0.58153737\",\n \"0.5808903\",\n \"0.574537\",\n \"0.5725313\",\n \"0.5693843\",\n \"0.5667237\",\n \"0.5548502\",\n \"0.55202025\",\n \"0.5500606\",\n \"0.54958946\",\n \"0.54796505\",\n \"0.54796505\",\n \"0.54748994\",\n \"0.54677004\",\n \"0.5462145\",\n \"0.5455995\",\n \"0.5423602\",\n \"0.53951573\",\n \"0.5391456\",\n \"0.5378304\",\n \"0.53751034\",\n \"0.5346756\",\n \"0.5344724\",\n \"0.5311645\",\n \"0.5309366\",\n \"0.53011835\",\n \"0.52955645\",\n \"0.52874506\",\n \"0.52776784\",\n \"0.52774656\",\n \"0.52739155\",\n \"0.52730495\",\n \"0.5271506\",\n \"0.52621245\",\n \"0.52480346\",\n \"0.524702\",\n \"0.52264774\",\n \"0.5215678\",\n \"0.52148026\",\n \"0.5214725\",\n \"0.5205414\",\n \"0.5205414\",\n \"0.5187964\",\n \"0.518781\",\n \"0.5169619\",\n \"0.5164741\",\n \"0.515414\",\n \"0.5152327\",\n \"0.5147482\",\n \"0.5147482\",\n \"0.51425546\",\n \"0.5141276\",\n \"0.51398236\",\n \"0.5138008\",\n \"0.51377904\",\n \"0.5134723\",\n \"0.5133375\",\n \"0.5125691\",\n \"0.51228416\",\n \"0.5088475\",\n \"0.50811976\",\n \"0.50692284\",\n \"0.5064841\",\n \"0.50565135\",\n \"0.5050606\",\n \"0.50430864\",\n \"0.5024439\",\n \"0.5020901\",\n \"0.5009663\",\n \"0.4993434\",\n \"0.49921224\",\n \"0.49786246\",\n \"0.4970846\",\n \"0.49640474\",\n \"0.49605137\",\n \"0.4957253\",\n \"0.495697\",\n \"0.49477\",\n \"0.49458015\",\n \"0.49375254\",\n \"0.49374583\",\n \"0.492599\",\n \"0.49200788\",\n \"0.49160925\",\n \"0.49086112\",\n \"0.48947304\",\n \"0.4890608\",\n \"0.48844343\",\n \"0.48822334\",\n \"0.48809305\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62791127"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":84674,"cells":{"query":{"kind":"string","value":"Given K and N, r, w and b are calculated Then, given r, w and b, all generations' value and decision functions are calculated BACKWARD"},"document":{"kind":"string","value":"def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')"},"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 B(n, k):\n assert 0 < k <= n\n global lookup\n for index_y in range(len(lookup), n + 1):\n lookup.append([1])\n min_value = min(index_y, k)\n for index_x in range(min_value):\n if index_x < len(lookup[index_y - 1]) - 1:\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\n else:\n lookup[index_y].append(lookup[index_y - 1][index_x])\n return lookup[n][k]","def _compute_parameters(self, p, k):\n for i in range(self._.d + 1):\n p[0, i, i] = k[i]\n p[i, 0, i] = Integer(1)\n p[i, i, 0] = Integer(1)\n for i in range(self._.d):\n p[i+1, 1, i+1] = self._.a[i+1]\n p[i, 1, i+1] = self._.b[i]\n p[i+1, 1, i] = self._.c[i+1]\n for i in range(2, self._.d + 1):\n for j in range(1, self._.d + 1):\n for h in range(1, self._.d):\n p[h, i, j] = self._check_parameter(\n h, i, j,\n _simplify(_expand((\n self._.c[h] * p[h-1, i-1, j]\n + self._.b[h] * p[h+1, i-1, j]\n - self._.b[i-2] * p[h, i-2, j]\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\n ) / self._.c[i])))\n p[self._.d, i, j] = self._check_parameter(\n self._.d, i, j,\n _simplify(_expand((\n self._.c[self._.d] * p[self._.d-1, i-1, j]\n - self._.b[i-2] * p[self._.d, i-2, j]\n + (self._.a[self._.d] - self._.a[i-1])\n * p[self._.d, i-1, j]\n ) / self._.c[i])))","def question_14_and_15(gamma, K):\n rbf = RadialBiasFunction()\n wins = 0.0\n my_svm = svm.SVC(C=np.inf, kernel='rbf', gamma=gamma)\n for i in range(100):\n rbf.fit(gamma, K)\n my_svm = my_svm.fit(rbf.X, rbf.Y)\n svm_error = 1 - my_svm.score(rbf.test_X, rbf.test_Y)\n rbf_error = rbf.error(in_sample=False)\n if svm_error < rbf_error:\n wins += 1\n rbf.resample()\n return wins / 100","def _K_computations(self, X, X2):\r\n if self.ARD:\r\n pass\r\n else:\r\n if X2 is None:\r\n self._K_inner_prod = np.dot(X,X.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\r\n vec = np.diag(self._K_numer) + 1.\r\n self._K_denom = np.sqrt(np.outer(vec,vec))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\r\n else:\r\n self._K_inner_prod = np.dot(X,X2.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\r\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)","def stirling(k, r) :\n\n return sum((-1)**(r-i)*binomial(r, i)*i**k for i in range(r+1)) / math.factorial(r)","def compute(self, X, Y, n):\n inner_cv = KFold(5, shuffle=True, random_state=1673)\n\n print('-> grid searching and cross validation ...')\n for training, validation, j in self._k_fold_cross_validation(X, 5, n):\n\n x, y, valid_x, valid_y = X.loc[training, :], Y[training], X.loc[validation, :], Y[validation]\n x_features, valid_features = self.sat_features.loc[training, :], self.sat_features.loc[validation, :]\n\n if 'kNN' in self.model_list:\n parameters = {'n_neighbors': range(1, 18, 2)}\n model = KNeighborsRegressor(weights='distance')\n self.kNN = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\n\n res = self.kNN.fit(x, y).predict(valid_x)\n self.results['kNN'].append(list(res))\n self.scores['kNN'].append(R2(valid_y, res))\n\n if 'Kriging' in self.model_list:\n parameters = {\"kernel\": [RBF(l) for l in [[1, 1]]]}\n model = GaussianProcessRegressor(alpha=0.1, n_restarts_optimizer=0)\n self.Kriging = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\n\n res = self.Kriging.fit(x, y).predict(valid_x)\n self.results['Kriging'].append(list(res))\n self.scores['Kriging'].append(R2(valid_y, res))\n\n if 'RmSense' in self.model_list:\n parameters = {\"alpha\": [0.001, 0.01, 0.1, 1, 10, 100, 1000]}\n model = Ridge()\n self.RmSense = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\n #print('INFO: best alpha - ', self.RmSense.fit(x_features, y).best_params_)\n\n res = self.RmSense.fit(x_features, y).predict(valid_features)\n self.results['RmSense'].append(list(res))\n self.scores['RmSense'].append(R2(valid_y, res))\n\n if 'Ensamble' in self.model_list:\n res = (self.RmSense.predict(valid_features) + self.kNN.predict(valid_x)) / 2.\n self.results['Ensamble'].append(list(res))\n self.scores['Ensamble'].append(R2(valid_y, res))\n\n for m in self.model_list:\n print('score {}: {}'.format(m, np.mean(self.scores[m])))","def rasm_mode(self, K, MAX_ITER=40):\r\n #old_Ki_f = np.zeros((self.N, 1))\r\n\r\n #Start f's at zero originally of if we have gone off track, try restarting\r\n if self.old_Ki_f is None or self.bad_fhat:\r\n old_Ki_f = np.random.rand(self.N, 1)/50.0\r\n #old_Ki_f = self.Y\r\n f = np.dot(K, old_Ki_f)\r\n else:\r\n #Start at the old best point\r\n old_Ki_f = self.old_Ki_f.copy()\r\n f = self.f_hat.copy()\r\n\r\n new_obj = -np.inf\r\n old_obj = np.inf\r\n\r\n def obj(Ki_f, f):\r\n return -0.5*np.dot(Ki_f.T, f) + self.noise_model.logpdf(f, self.data, extra_data=self.extra_data)\r\n\r\n difference = np.inf\r\n epsilon = 1e-7\r\n #step_size = 1\r\n #rs = 0\r\n i = 0\r\n\r\n while difference > epsilon and i < MAX_ITER:\r\n W = -self.noise_model.d2logpdf_df2(f, self.data, extra_data=self.extra_data)\r\n\r\n W_f = W*f\r\n grad = self.noise_model.dlogpdf_df(f, self.data, extra_data=self.extra_data)\r\n\r\n b = W_f + grad\r\n W12BiW12Kb, _ = self._compute_B_statistics(K, W.copy(), np.dot(K, b))\r\n\r\n #Work out the DIRECTION that we want to move in, but don't choose the stepsize yet\r\n full_step_Ki_f = b - W12BiW12Kb\r\n dKi_f = full_step_Ki_f - old_Ki_f\r\n\r\n f_old = f.copy()\r\n def inner_obj(step_size, old_Ki_f, dKi_f, K):\r\n Ki_f = old_Ki_f + step_size*dKi_f\r\n f = np.dot(K, Ki_f)\r\n # This is nasty, need to set something within an optimization though\r\n self.tmp_Ki_f = Ki_f.copy()\r\n self.tmp_f = f.copy()\r\n return -obj(Ki_f, f)\r\n\r\n i_o = partial_func(inner_obj, old_Ki_f=old_Ki_f, dKi_f=dKi_f, K=K)\r\n #Find the stepsize that minimizes the objective function using a brent line search\r\n #The tolerance and maxiter matter for speed! Seems to be best to keep them low and make more full\r\n #steps than get this exact then make a step, if B was bigger it might be the other way around though\r\n #new_obj = sp.optimize.minimize_scalar(i_o, method='brent', tol=1e-4, options={'maxiter':5}).fun\r\n new_obj = sp.optimize.brent(i_o, tol=1e-4, maxiter=10)\r\n f = self.tmp_f.copy()\r\n Ki_f = self.tmp_Ki_f.copy()\r\n\r\n #Optimize without linesearch\r\n #f_old = f.copy()\r\n #update_passed = False\r\n #while not update_passed:\r\n #Ki_f = old_Ki_f + step_size*dKi_f\r\n #f = np.dot(K, Ki_f)\r\n\r\n #old_obj = new_obj\r\n #new_obj = obj(Ki_f, f)\r\n #difference = new_obj - old_obj\r\n ##print \"difference: \",difference\r\n #if difference < 0:\r\n ##print \"Objective function rose\", np.float(difference)\r\n ##If the objective function isn't rising, restart optimization\r\n #step_size *= 0.8\r\n ##print \"Reducing step-size to {ss:.3} and restarting optimization\".format(ss=step_size)\r\n ##objective function isn't increasing, try reducing step size\r\n #f = f_old.copy() #it's actually faster not to go back to old location and just zigzag across the mode\r\n #old_obj = new_obj\r\n #rs += 1\r\n #else:\r\n #update_passed = True\r\n\r\n #old_Ki_f = self.Ki_f.copy()\r\n\r\n #difference = abs(new_obj - old_obj)\r\n #old_obj = new_obj.copy()\r\n difference = np.abs(np.sum(f - f_old)) + np.abs(np.sum(Ki_f - old_Ki_f))\r\n #difference = np.abs(np.sum(Ki_f - old_Ki_f))/np.float(self.N)\r\n old_Ki_f = Ki_f.copy()\r\n i += 1\r\n\r\n self.old_Ki_f = old_Ki_f.copy()\r\n\r\n #Warn of bad fits\r\n if difference > epsilon:\r\n self.bad_fhat = True\r\n warnings.warn(\"Not perfect f_hat fit difference: {}\".format(difference))\r\n elif self.bad_fhat:\r\n self.bad_fhat = False\r\n warnings.warn(\"f_hat now perfect again\")\r\n\r\n self.Ki_f = Ki_f\r\n return f","def define_pseudo_potts_helper_functions(n, k):\n\n assert n>1\n assert k>1\n\n @njit\n def get_multipliers_r(r, multipliers, n=n, k=k):\n \"\"\"Return r's field and all couplings to spin r.\n\n Parameters\n ----------\n r : int\n multipliers : ndarray\n All fields and couplings concatenated together.\n\n Returns\n -------\n ndarray\n Relevant multipliers.\n list\n Index of where multipliers appear in full multipliers array.\n \"\"\"\n \n ix = [r+n*i for i in range(k)]\n multipliersr = np.zeros(k-1+n)\n for i in range(k):\n multipliersr[i] = multipliers[r+n*i]\n\n # fill in the couplings\n ixcounter = k\n for i in range(n):\n if i!=r:\n if i<r:\n ix.append( sub_to_ind(n, i, r) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n else:\n ix.append( sub_to_ind(n, r, i) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n ixcounter += 1\n return multipliersr, ix\n\n @njit\n def calc_observables_r(r, X, n=n, k=k):\n \"\"\"Return the observables relevant for calculating the conditional probability of\n spin r.\n\n Parameters\n ----------\n r : int\n Spin index.\n X : ndarray\n Data samples of dimensions (n_samples, n_dim).\n\n Returns\n -------\n ndarray\n observables\n list of ndarray\n observables if spin r were to occupy all other possible states\n ndarray\n Each col details the occupied by spin r in each array of the previous return\n value, i.e., the first col of this array tells me what r has been changed to\n in the first array in the above list.\n \"\"\"\n\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n # keep another copy of observables where the spin iterates thru all other possible states\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n for i in range(k-1)]\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\n \n # for each data sample in X\n for rowix in range(X.shape[0]):\n counter = 0\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\n for i in range(k):\n if X[rowix,r]==i:\n obs[rowix,i] = 1\n else:\n otherobs[counter][rowix,i] = 1\n otherstates[rowix,counter] = i\n counter += 1\n ixcounter = k\n \n for i in range(n-1):\n for j in range(i+1,n):\n if i==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\n kcounter += 1\n ixcounter += 1\n elif j==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\n kcounter += 1\n ixcounter += 1\n return obs, otherobs, otherstates\n\n return get_multipliers_r, calc_observables_r","def learn(self,k=10):\n \n gradients = {}\n for i in range(k):\n\n #create TILDE(R) tree object\n tree_i = TILDE(typ=\"regression\",score=\"WV\",max_depth=self.max_depth)\n\n #subsample negatives if too many for each tree\n sampled_neg = deepcopy(self.neg)\n if len(self.neg) > 2*len(self.pos):\n sampled_neg = sample(self.neg,2*len(self.pos))\n\n #compute gradients as I-P\n for ex in self.examples:\n p = sigmoid(self.examples[ex])\n if ex in self.pos:\n gradients[ex] = 1-p\n elif ex in sampled_neg:\n gradients[ex] = 0-p\n\n #fit tree on gradients\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\n \n #recompute example values as previous example value + tree_i value\n for ex in self.examples:\n tree_i_value = tree_i.infer(self.data,ex)\n self.examples[ex] += 0.01*tree_i_value\n\n #add tree to boosted_trees\n self.boosted_trees.append(tree_i)","def MCS(n,k):\n\tglobal dict_all\n\tdict_val=copy.deepcopy(dict_all)\n\t#start_time = time.time()\n\tfinal = {}\t\t\t\t\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\n\tseq = []\t\t\t\t\t\t# Store the count with no duplication\n\tfor i in range(n):\n\t\tleaf={}\t\t\t\t\t\t# leaf is the dictionary to store the random value of each leaf\n\t\t#count=0\n\t\tfor i in leaves:\n\t\t\tleaf[i] = choice([0,1])\n\t\t\tdict_val[i]=leaf[i]\n\t\t\t#count += leaf[i]\n\t\tresult = Cal_FT(dict_val)\t\n\t\t'''\n\t\tif result:\n\t\t\tcutset = []\n\t\t\tfor i in leaves:\n\t\t\t\tcutset.append(str(leaf[i]))\n\t\t\tcutset=\"\".join(cutset)\n\t\t\tif cutset not in final:\n\t\t\t\tfinal[cutset]=count\n\tfinal_sorted=sorted(zip(final.values(),final.keys())) \t\t\t\t#Order the cutset by its count\n\tfor i in range(k):\t\t\t\t\t\t\t\t\t\t\t\t\t#Print the first k result\n\t\tcutset=list(final_sorted[i][1])\n\t\tresult=[]\n\t\tfor index in range(len(cutset)):\n\t\t\tif cutset[index] is \"1\":\n\t\t\t\tresult.append(leaves[index])\n\t\tprint result\n\t#end_time=time.time()\n\t#print \"Running time is\", end_time-start_time\n\t'''","def T_step_value_iteration(self,R, T):\n U1 = dict([(s, 0) for s in self.states])\n self._prepare_post_cache()\n policy = dict([(s, set()) for s in self.states])\n t = T\n while t > 0:\n U = U1.copy()\n delta = 0\n for s in self.states:\n U1[s] = max([sum([self.prob_delta(s,a,s1) * (U[s1] + R[s, a,s1])\n for s1 in self.post(s, a)])]\n for a in self.available(s))[0]\n delta = max(delta, abs(U1[s] - U[s]))\n t = t - 1\n print t\n for s in self.states:\n Vmax = dict()\n for a in self.available(s):\n Vmax[a] = [sum([self.prob_delta(s,a,s1) * (U[s1] + R[s, a,s1])\n for s1 in self.post(s, a)])][0]\n maxV = max(Vmax.values())\n for a in Vmax.keys():\n if Vmax[a] == maxV:\n policy[s].add(a)\n return U, policy","def time_path_iteration(params=params, S=3, T=50, weight=0.3, tol=1e-12, maxiter=100):\n ss_output = get_SS()\n b_ss = ss_output['b_ss']\n b_init = np.array([0, 0.8 * b_ss[0], 1.1 * b_ss[1]]) # t=0\n\n # Guess transition path, finishes at steady_state\n Kguess = np.linspace(b_init.sum(), ss_output['K_ss'], T)\n\n s = 1\n K_dynamic = Kguess\n b_current = np.zeros((S,T)) # initialize array to store savings decisions\n b_current[:,0] = b_init\n\n # Update b_path until convergence\n its = 0\n ee_diff = 7.0\n while ee_diff > tol and its < maxiter:\n its += 1\n w_dynamic = find_w(L=params['labor_supply'].sum(), K=K_dynamic)\n r_dynamic = find_r(L=params['labor_supply'].sum(), K=K_dynamic)\n for t in range(T-2):\n\n #solve for b32, savings decision of middle-aged in first period\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_current[:,t], s, t)\n b_current[s+1,t+1] = opt.root(ee_err_1, 0, args=ee_param).x\n\n # solve for b22, b33, savings decision of young gen in middle/old generations\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_init, s, t)\n b_current[s,t+1], b_current[s+1, t+2]= opt.root(ee_err_23, [0,0], args=ee_param).x\n # fill in table\n b_current[s,T-1] = b_current[s,T-2]\n\n # Check for convergence\n K_prime = b_current.sum(axis=0)\n ee_diff = (K_prime - K_dynamic).max()\n\n# rc_diff = production(K_prime, L=params['labor_supply'].sum())\n# - Ct = (1 + r_dynamic) * ()\n# - np.roll(K_prime, len(K_prime)-1)\n# - (1 - delta) * K_prime\n\n print('Iteration number: ', its, 'Current EE difference: ', ee_diff)\n # update new capital path\n K_dynamic = weight * K_prime + (1-weight) * K_dynamic\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), Kguess, 'r--',lw=0.7, label='Kguess')\n plt.plot(range(T), K_dynamic , label='Capital Path Solution')\n plt.title('Transition Path of Aggregate Capital')\n plt.xlabel('Time period')\n plt.ylabel('Aggregate Capital')\n plt.legend()\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), r_dynamic, 'g-o',label='Interest rate Path Solution')\n plt.title('Transition Path of Aggregate Interest rate')\n plt.xlabel('Time period')\n plt.ylabel('Interest Rate')\n plt.legend()\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), w_dynamic, 'k-o',label='Wage Path Solution')\n plt.title('Transition Path of Wages')\n plt.xlabel('Time period')\n plt.ylabel('Wages')\n plt.legend()\n\n return K_dynamic","def fn(k, i, j):\n if not (0 <= i < N and 0 <= j < N): return 0\n if k == 0: return 1 \n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))","def dynamic_iteration(k, n):\n # If only one egg remains, n attempts must be made to find the correct floor.\n if k == 1:\n return n\n # Lookup table for previous solutions.\n W = [[0 for y in range(n + 1)] for x in range(k)]\n # Initialize the first row.\n for i in range(n + 1):\n W[0][i] = i\n # Start on second row, working downward.\n for i in range(1, k):\n # Calculate values for each cell.\n for j in range(1, n + 1):\n W[i][j] = min((max(W[i][j - x], W[i - 1][x - 1]) for x in range(1, j + 1))) + 1\n # Return the result.\n return W[k - 1][n]","def generate_good(self, m, n, rank, mu=2, ka=2):\n sr = random.random()\n s = []\n s.append(sr)\n for r in range(rank-1):\n newele = s[-1] * (1 + ka * random.random() / (rank-1))\n s.append(newele)\n s.reverse()\n \n # best_u = None\n # best_mu0 = 0\n # while best_mu0 == 0:\n # for _ in range(10):\n # A = np.random.rand(m,m)\n # A = scipy.linalg.orth(A)\n # u = A[:, :rank]\n # mu0 = self.compute_mu(u, m, rank)\n # print(\"mu0 : \", mu0)\n # if mu0 <= mu and mu0 >= best_mu0:\n # best_mu0 = mu0\n # best_u = u\n # print(\"mu0 for u:\", best_mu0)\n # # print(u.T @ u)\n \n # best_v = None\n # best_mu0 = 0\n # while best_mu0 == 0:\n # for _ in range(10):\n # B = np.random.rand(n,n)\n # B = scipy.linalg.orth(B)\n # v = B[:, :rank]\n # mu0 = self.compute_mu(v, n, rank)\n # print(\"mu0 : \", mu0)\n # if mu0 <= mu and mu0 >= best_mu0:\n # best_mu0 = mu0\n # best_v = v\n # print(\"mu0 for v:\", best_mu0)\n # u = best_u\n # v = best_v\n\n for _ in range(100):\n A = np.random.rand(m,m)\n A = scipy.linalg.orth(A)\n u = A[:, :rank]\n mu0 = self.compute_mu(u, m, rank)\n print(\"mu0 : \", mu0)\n if mu0 <= mu:\n break\n print(\"mu0 for u:\", mu0) \n\n for _ in range(10):\n B = np.random.rand(n,n)\n B = scipy.linalg.orth(B)\n v = B[:, :rank]\n mu0 = self.compute_mu(v, n, rank)\n print(\"mu0 : \", mu0)\n if mu0 <= mu:\n break\n print(\"mu0 for both:\", mu0)\n\n matrix = np.dot(u*s, v.T)\n \n kappa = s[0] / s[-1]\n print(\"kappa=\", kappa)\n \n ss = np.copy(s)\n for k in range(rank):\n ss[k] = s[k] / s[0]\n \n max_entry = np.max(np.abs(np.outer(u[:,:rank], v.T[:rank,:])))\n mu1 = max_entry * math.sqrt(m * n / rank)\n print(\"mu1=\", mu1)\n \n return matrix","def learn(self,k=10):\n \n gradients = {}\n for i in range(k):\n\n #create TILDE(R) tree object\n tree_i = TILDE(typ=\"regression\",score=\"WV\",max_depth=self.max_depth)\n\n #subsample negatives if too many for each tree\n sampled_neg = deepcopy(self.neg)\n if len(self.neg) > 2*len(self.pos):\n sampled_neg = sample(self.neg,2*len(self.pos))\n\n #compute gradients using LMNN loss function\n for ex in self.examples:\n gradient = self.compute_gradient(ex,\n self.pos,\n self.neg,\n self.examples)\n gradients[ex] = gradient\n\n\n #fit tree on gradients\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\n \n #recompute example values as previous example value - gamma*tree_i value\n for ex in self.examples:\n tree_i_value = tree_i.infer(self.data,ex)\n self.examples[ex] -= 0.01*tree_i_value #learning rate\n \n #add tree to boosted_trees\n self.boosted_trees.append(tree_i)","def boundary_op_n(v):\r\n h = list(v.dic.keys())[0]\r\n p = len(h) - 1\r\n s = P_chains([],[])\r\n if (p != 0) and (isinstance(h, str) != True) and (isinstance(h, frozenset) != True) and (isinstance(h, ImmutableMatrix) != True):\r\n if (is_int(list(v.dic.keys())) == True):\r\n for u in v.dic.keys():\r\n c = 0\r\n for i in u: \r\n w = list(u)[:]\r\n w.remove(i)\r\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**c) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n else:\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n return s\r\n else:\r\n aux = P_chains([],[])\r\n D = {}\r\n ct = 0\r\n st = []\r\n for u in v.dic.keys():\r\n for x in u:\r\n if x not in st:\r\n st.append(x)\r\n for i in st:\r\n D[tuple([ct])] = i\r\n ct = ct + 1\r\n for u in v.dic.keys():\r\n w2 = []\r\n for x in u:\r\n for y in list(D.keys()):\r\n if (x == D[y]):\r\n w2.append(y)\r\n aux = aux + P_chains([tuple(w2)],[v.dic[u]]) \r\n v = aux\r\n for u in v.dic.keys():\r\n c = 0\r\n for i in u: \r\n w = list(u)[:]\r\n w.remove(i)\r\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**c) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n else:\r\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\r\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\r\n s = s - s1\r\n else:\r\n s = s + s1\r\n c = c+1\r\n s2 = P_chains([],[])\r\n for u in s.dic.keys():\r\n w2=[]\r\n for i in u:\r\n w2.append(D[i])\r\n s2 = s2 + P_chains([tuple(w2)],[s.dic[u]])\r\n \r\n return s2\r\n else:\r\n return s","def recursion_step(value_n, r_grid, discount):\n\n n = value_n.shape[0]\n r_len = r_grid.shape[0]\n value_n_minus_1 = np.zeros([n - 1, r_len]) # Value function length reduced by 1\n gittins_n_minus_1 = np.zeros(n - 1) # Value function length reduced by 1\n for k in range(0, n - 1):\n a = k + 1 # a in range [1,n-1]\n b = n - k - 1 # b in range [1,n-1]\n value_n_minus_1[k, :] = np.maximum((r_grid / float(1 - discount)),\n (a / float(n)) * (1 + discount * value_n[k + 1, :]) +\n (b / float(n)) * discount * value_n[k, :]\n )\n try:\n # Find first index where Value = (Value of Safe Arm)\n idx_git = np.argwhere((r_grid / float(1 - discount)) == value_n_minus_1[k, :]).flatten()\n gittins_n_minus_1[k] = 0.5 * (r_grid[idx_git[0]] + r_grid[idx_git[0] - 1]) # Take average\n except:\n print(\"Error in finding Gittins index\")\n\n return gittins_n_minus_1, value_n_minus_1","def obrien_fleming_adjust_n(n, K, alpha, power):\n\n if not isinstance(n, int) or n < 1:\n raise ValueError('n must be an integer greater than 1.')\n\n if not isinstance(K, int) or K < 1 or K > 10:\n raise ValueError('K must be an integer between 1 and 10.')\n\n if alpha not in [0.01, 0.05, 0.1]:\n raise ValueError('alpha must be 0.01, 0.05, or 0.1.')\n\n if power not in [0.8, 0.9]:\n raise ValueError('power must be 0.8, or 0.9.')\n\n factors = {\n \"0.8\": {\n \"0.01\": [1.000, 1.001, 1.007, 1.011, 1.015, 1.017, 1.019, 1.021, 1.022, 1.024],\n \"0.05\": [1.000, 1.008, 1.017, 1.024, 1.028, 1.032, 1.035, 1.037, 1.038, 1.040],\n \"0.1\": [1.000, 1.016, 1.027, 1.035, 1.040, 1.044, 1.047, 1.049, 1.051, 1.053],\n },\n \"0.9\": {\n \"0.01\": [1.000, 1.001, 1.006, 1.010, 1.014, 1.016, 1.018, 1.020, 1.021, 1.022],\n \"0.05\": [1.000, 1.007, 1.016, 1.022, 1.026, 1.030, 1.032, 1.034, 1.036, 1.037],\n \"0.1\": [1.000, 1.014, 1.025, 1.032, 1.037, 1.041, 1.044, 1.046, 1.048, 1.049],\n },\n }\n return math.ceil(n * factors[str(power)][str(alpha)][K - 1])","def fn(n, k):\n if k == 1: return n \n if n == 0: return 0 \n ans = inf \n for x in range(1, n+1): \n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\n return ans","def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n max_cp = 1\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 max_cp += w_inpIdx*X0[inpIdx]\n # saving values\n layerEq[inpIdx] = X0[inpIdx]\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\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]/kdT[layeridx-1][inpIdx])\n layerEq[inpIdx] = x_eq\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 max_cp += firstComplex + Inhib2/E0*x_eq\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],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n max_cp += Inhib2/E0*x_eq\n return max_cp","def __kappa_mle(self, k, R):\n return (iv(1, k) / iv(0, k)) - R","def _conditional_z(K, alpha, beta, n_mk, n_kt, m, t, beta_sum, n_k):\n probability = \\\n (alpha + n_mk[m, :]) * ((beta[t] + n_kt[:, t]) / (beta_sum + n_k))\n probability /= np.sum(probability)\n assert(np.all(probability >= 0.))\n assert(1.0 - 1e-6 < np.sum(probability) < 1.0 + 1e-6)\n assert(len(probability) == K)\n return np.random.choice(K, p=probability)","def hidden_markov_conditional_s_N(traj, fitness=0, N_w=50_000, resolution=25, alpha=0.01):\n \n # Step 1: compute range of reasonable initial clone sizes based on data alone\n # Beta function\n beta_p_conf_int = beta.ppf(q=[alpha, 1-alpha],\n a=traj.iloc[0].AO+1,\n b=(traj.iloc[0].DP\n - traj.iloc[0].AO\n + 1))\n\n # List of binomial p ranges and clone_size_ranges\n beta_p_range = np.linspace(beta_p_conf_int[0],\n min(beta_p_conf_int[1], 0.5),\n resolution)\n\n # Transform p values to clone sizes\n init_range = distributions.vaf_to_clone_size(v=beta_p_range,\n N_w=N_w)\n\n # initialise clone size ranges of starting birth and death processes\n bd_init_ranges = [(init_range[0], init_range[-1])]\n\n # Compute first term of recursion\n recursive_prob = y_1_cond(init_range, traj.iloc[0], N_w)\n\n previous_x_range = init_range\n\n for i in range(1,len(traj)):\n \n next_x_range = find_range (traj, i, bd_init_ranges, fitness, N_w, alpha, resolution)\n\n recursive_prob = np.array([y_k_cond(x, traj.iloc[i], recursive_prob, previous_x_range,\n fitness, N_w) for x in next_x_range])\n previous_x_range = next_x_range\n\n probability = np.trapz(x=previous_x_range, y=recursive_prob)\n return probability","def tourney_prob(k, N, m):\n\n if N < m:\n print \"The second argument cannot be smaller than the third one.\"\n sys.exit()\n\n if m < 1 or k <= 0:\n return 0.0\n elif m == 1:\n return 1.0 / N\n else:\n return float(N - k) * m / (N * (m - 1)) * tourney_prob(k, N - 1, m - 1)","def _compute_B_statistics(self, K, W, a):\r\n if not self.noise_model.log_concave:\r\n #print \"Under 1e-10: {}\".format(np.sum(W < 1e-6))\r\n W[W < 1e-10] = 1e-10 # FIXME-HACK: This is a hack since GPy can't handle negative variances which can occur\r\n # If the likelihood is non-log-concave. We wan't to say that there is a negative variance\r\n # To cause the posterior to become less certain than the prior and likelihood,\r\n # This is a property only held by non-log-concave likelihoods\r\n\r\n\r\n #W is diagonal so its sqrt is just the sqrt of the diagonal elements\r\n W_12 = np.sqrt(W)\r\n B = np.eye(self.N) + W_12*K*W_12.T\r\n L = jitchol(B)\r\n\r\n W12BiW12a = W_12*dpotrs(L, np.asfortranarray(W_12*a), lower=1)[0]\r\n ln_B_det = 2*np.sum(np.log(np.diag(L)))\r\n return W12BiW12a, ln_B_det","def _step(self) -> Dict[str, tf.Tensor]:\n\n # Pull out the data needed for updates/priorities.\n inputs = next(self._iterator)\n\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\n keys, probs = inputs.info[:2]\n\n with tf.GradientTape() as tape:\n # Evaluate our networks.\n # `qv` means quantile values, `tau` is same as quantile\n # Shape: [B, num_quantiles]\n tau_tm1 = tf.random.uniform(\n shape=[tf.shape(o_tm1)[0], self._num_tau_samples],\n minval=0., maxval=1., dtype=tf.float32)\n tau_t = tf.random.uniform(\n shape=[tf.shape(o_t)[0], self._num_tau_prime_samples],\n minval=0., maxval=1., dtype=tf.float32)\n tau_for_selector = tf.random.uniform(\n shape=[tf.shape(o_t)[0], self._num_quantile_samples],\n minval=0., maxval=1., dtype=tf.float32)\n # Shape: [B, A, num_quantiles]\n qv_tm1 = self._network(o_tm1, tau_tm1)\n qv_t = self._target_network(o_t, tau_t)\n if self._double_dqn:\n q_t_selector = tf.reduce_mean(\n self._network(o_t, tau_for_selector), axis=-1)\n else:\n q_t_selector = tf.reduce_mean(\n self._target_network(o_t, tau_for_selector), axis=-1)\n\n # Shape: [B]\n a_t = tf.argmax(q_t_selector, axis=1, output_type=tf.int32)\n\n # The rewards and discounts have to have the same type as network values.\n r_t = tf.clip_by_value(tf.cast(r_t, qv_tm1.dtype), -1., 1.)\n d_t = tf.cast(d_t, qv_tm1.dtype) * tf.cast(self._discount, qv_tm1.dtype)\n\n # Calculate actions value distribution\n qv_a_tm1 = slice_with_actions(qv_tm1, a_tm1) # [B, num_quantiles]\n\n # Scale and shift time-t distribution atoms by discount and reward.\n qv_a_t = slice_with_actions(qv_t, a_t) # [B, num_quantiles]\n # Shape: [B, num_quantiles]\n target = tf.stop_gradient(r_t[:, None] + d_t[:, None] * qv_a_t)\n\n # Calculate quantile huber loss\n # Shape: [B, num_quantiles, num_quantiles]\n bellman_errors = target[:, None, :] - qv_a_tm1[:, :, None]\n\n # Compute the loss.\n # Shape: [B, num_quantiles, num_quantiles]\n huber_loss = losses.huber(bellman_errors, self._kappa)\n\n # Shape: [B, num_quantiles, num_quantiles]\n # Unlike QR-DQN, we directly use taus outputted by network as \\hat{\\tau}\n quantile_huber_loss = (tf.abs(tau_tm1[..., None] - tf.stop_gradient(\n tf.cast(bellman_errors < 0, tf.float32))) * huber_loss) / self._kappa\n\n # Shape: [B]\n loss = tf.reduce_mean(tf.reduce_sum(quantile_huber_loss, axis=2), axis=1)\n td_errors = tf.identity(loss)\n\n # Get the importance weights.\n importance_weights = 1. / probs # [B]\n importance_weights **= self._importance_sampling_exponent\n importance_weights /= tf.reduce_max(importance_weights)\n\n # Reweight.\n loss *= tf.cast(importance_weights, loss.dtype) # [B]\n loss = tf.reduce_mean(loss, axis=[0]) # []\n\n # Do a step of SGD.\n gradients = tape.gradient(loss, self._network.trainable_variables)\n self._optimizer.apply(\n gradients, self._network.trainable_variables)\n\n # Update the priorities in the replay buffer.\n if self._replay_client:\n priorities = tf.cast(tf.sqrt(td_errors + 1e-10), tf.float64)\n self._replay_client.update_priorities(\n table=adders.DEFAULT_PRIORITY_TABLE, keys=keys, priorities=priorities)\n\n # Periodically update the target network.\n if tf.math.mod(self._num_steps, self._target_update_period) == 0:\n trfl.update_target_variables(\n target_variables=self._target_network.variables,\n source_variables=self._network.variables)\n self._num_steps.assign_add(1)\n\n # Report loss & statistics for logging.\n fetches = {\n 'loss': loss,\n }\n\n return fetches","def get_learning_gradients(self, k=1, \n l1=0.0, l2=0.0, \n sparse_lambda=0., sparse_p=0.01, \n waste_cutoff=1e-2,\n waste_reduction=False):\n updates = {}\n self.waste_reduction_nbsize = sharedX(1.0, name='waste_reduction_nbsize')\n\n print '*********************************'\n print '*********************************'\n print '** waste_reduction = ', waste_reduction\n print '*********************************'\n print '*********************************'\n \n ### compute positive phase ###\n ph_mean, ph_sample = self.sample_h_given_v(self.input, temper=False)\n\n ### compute negative phase ###\n [nh_samples, nv_samples, beta, mixstat, E], sampling_updates = self.get_sampling_updates(k=k)\n updates.update(sampling_updates)\n\n if self.n_beta.value > 1:\n # after all this... swap bottom temperature samples into T=1 minibatch\n nv_samples, E = self.pt_swap_t1_sample(nv_samples, E, mixstat)\n updates[self._buffer] = T.set_subtensor(self._buffer[:self.n_chain_total], nv_samples)\n updates[self._E] = T.set_subtensor(self._E[:self.n_chain_total], E)\n\n # (optionally) perform waste reduction on parallel chains\n if waste_reduction:\n chain_end, weights, wr_nbsize = \\\n pt_waste_reduction(nv_samples, beta, mixstat, E, \n cut_off=waste_cutoff, batch_size=self.batch_size)\n updates[self.waste_reduction_nbsize] = wr_nbsize\n\n # define cost function\n cost = T.mean(self.free_energy(self.input)) - \\\n T.sum(weights*self.free_energy(chain_end)) / self.t_batch_size\n gconstant = [chain_end, weights]\n else:\n chain_end = nv_samples[:self.batch_size]\n # define cost function\n cost = T.mean(self.free_energy(self.input)) - T.mean(self.free_energy(chain_end))\n gconstant = [chain_end]\n\n if l1: cost += l1 * T.sum(abs(self.W))\n if l2: cost += l2 * T.sum(self.W**2)\n \n # We must not compute the gradient through the gibbs sampling \n gparams = T.grad(cost, self.params, consider_constant=gconstant)\n\n grads = {}\n # constructs the update dictionary\n for gparam, param in zip(gparams, self.params):\n grads[param] = gparam\n \n # modify hidden biases according to the sparsity regularization term of Lee07\n if sparse_lambda:\n sparse_cost = sparse_lambda * T.sum((sparse_p - T.mean(ph_mean, axis=0))**2)\n grads[self.hbias] += T.grad(sparse_cost, self.hbias)\n\n return grads, updates","def regularize_bwd(X, y, mu0, mu1, v1, nz, K, verbose=False):\n \n if verbose: sss=0#print '\\ncompute bath between mu=%.4f and mu=%.4f'%(mu0, mu1)\n \n n, m = X.shape\n X_nz = np.atleast_2d(X[:, nz])\n b = np.dot(X.T, y)\n G = np.dot(X.T, X)\n \n nbr = 0\n mu = mu0\n trans_type = -1\n trans_sign = 0\n trans_ind = -1\n if verbose: nbr=0#print 'initial active features =', nz\n \n while mu > mu1:\n \n # find the breakpoints where coefficients become zero\n b_nz = b[nz]\n Kv1 = np.dot(K, v1)\n Kb_nz = np.dot(K, b_nz)\n mu_0 = Kb_nz / Kv1\n \n # find the breakpoints where new coefficients become active\n z = np.setdiff1d(np.arange(m), nz)\n X_z = np.atleast_2d(X[:, z])\n b_z = b[z]\n M = G[np.ix_(z, nz)]\n MKb_nz = np.dot(M, Kb_nz)\n MKv1 = np.dot(M, Kv1)\n mu_1 = (b_z - MKb_nz) / (1 - MKv1)\n mu_m1 = (b_z - MKb_nz) / (-1 - MKv1)\n \n if trans_type > 0: mu_0[-1] = mu1\n mu_0[mu_0 >= mu] = mu1\n if len(mu_0) > 0: \n mu_0_argmax = mu_0.argmax()\n mu_0_max = mu_0[mu_0_argmax][0]\n else:\n mu_0_max = mu1\n if trans_type == 0:\n if trans_sign == 1: mu_1[np.where(z == trans_ind)[0]] = mu1 - 1\n else: mu_m1[np.where(z == trans_ind)[0]] = mu1 - 1\n mu_1[mu_1 >= mu] = mu1\n if len(mu_1) > 0: \n mu_1_argmax = mu_1.argmax()\n mu_1_max = mu_1[mu_1_argmax][0]\n else:\n mu_1_max = mu1\n mu_m1[mu_m1 >= mu] = mu1\n if len(mu_m1) > 0: \n mu_m1_argmax = mu_m1.argmax()\n mu_m1_max = mu_m1[mu_m1_argmax][0]\n else:\n mu_m1_max = mu1\n \n # compute the breakpoint\n mu_br_all = np.array([mu_0_max, mu_1_max, mu_m1_max])\n trans_type = mu_br_all.argmax()\n mu_br = mu_br_all[trans_type]\n \n if mu_br > mu1:\n \n nbr += 1\n mu = mu_br\n \n if trans_type == 0: # an element of theta(t) goes to zero\n trans_ind = nz[mu_0_argmax]\n trans_sign = v1[mu_0_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is inactive'%(mu, trans_ind)\n nzind = range(len(nz))\n rr=np.where(nz==trans_ind)[0][0]\n #print 'longa:',len(nz),len(nzind),len(v1)\n #print 'c:',nz.index(trans_ind)\n nzind=np.delete(nzind,rr)#nzind=np.delete(nzind,np.where(nzind==nz.index(trans_ind)))#nzind.remove(nz.index(trans_ind))\n v1 = v1[nzind]\n nz=np.delete(nz,rr)#nz=np.delete(nz,np.where(nz==trans_ind))#nz.remove(trans_ind)\n #print 'longa2:',len(nz),len(nzind),len(v1)\n X_nz = X[:, nz]\n K = invupdatered(K, mu_0_argmax)\n else: # new active element\n if trans_type == 1: # it is positive\n trans_ind = z[mu_1_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is positive'%(mu, trans_ind)\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\n v1 = np.vstack([v1, 1])\n else: # it is negative\n trans_ind = z[mu_m1_argmax]\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is negative'%(mu, trans_ind)\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\n v1 = np.vstack([v1, -1])\n X_new = np.atleast_2d(X[:, trans_ind]).T\n K = invupdateapp(K, np.dot(X_nz.T, X_new), np.dot(X_new.T, X_nz), \n np.dot(X_new.T, X_new))\n X_nz = X[:, nz]\n \n else: # compute solution at mu1\n \n if verbose: sss=0#print 'compute solution at mu =', mu1\n theta_nz = Kb_nz - mu1*Kv1\n mu = mu1\n \n return theta_nz, nz, K, nbr","def _reparam(self):\n\n k_fe, k_re, k_re2 = self.k_fe, self.k_re, self.k_re2\n k_tot = k_fe + k_re2\n ix = np.tril_indices(self.k_re)\n\n lin = []\n for k in range(k_fe):\n e = np.zeros(k_tot)\n e[k] = 1\n lin.append(e)\n for k in range(k_re2):\n lin.append(np.zeros(k_tot))\n\n quad = []\n for k in range(k_tot):\n quad.append(np.zeros((k_tot, k_tot)))\n ii = np.tril_indices(k_re)\n ix = [(a,b) for a,b in zip(ii[0], ii[1])]\n for i1 in range(k_re2):\n for i2 in range(k_re2):\n ix1 = ix[i1]\n ix2 = ix[i2]\n if (ix1[1] == ix2[1]) and (ix1[0] <= ix2[0]):\n ii = (ix2[0], ix1[0])\n k = ix.index(ii)\n quad[k_fe+k][k_fe+i2, k_fe+i1] += 1\n for k in range(k_tot):\n quad[k] = 0.5*(quad[k] + quad[k].T)\n\n return lin, quad","def _K_computations(self, X, X2):\r\n # First extract times and indices.\r\n self._extract_t_indices(X, X2)\r\n\r\n self._K_compute_eq()\r\n self._K_compute_ode_eq()\r\n if X2 is None:\r\n self._K_eq_ode = self._K_ode_eq.T\r\n else:\r\n self._K_compute_ode_eq(transpose=True)\r\n self._K_compute_ode()\r\n\r\n if X2 is None:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\r\n else:\r\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\r\n\r\n # Reorder values of blocks for placing back into _K_dvar.\r\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\r\n np.hstack((self._K_ode_eq, self._K_ode))))\r\n self._K_dvar = self._K_dvar[self._rorder, :]\r\n self._K_dvar = self._K_dvar[:, self._rorder2]\r\n \r\n \r\n if X2 is None:\r\n # Matrix giving scales of each output\r\n self._scale = np.zeros((self._t.size, self._t.size))\r\n code=\"\"\"\r\n for(int i=0;i<N; i++){\r\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\r\n for(int j=0; j<i; j++){\r\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\r\n scale_mat[i+j*N] = scale_mat[j+i*N];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index = self._scale, self.B, self._index\r\n N, output_dim = self._t.size, self.output_dim\r\n weave.inline(code,['index',\r\n 'scale_mat', 'B',\r\n 'N', 'output_dim'])\r\n else:\r\n self._scale = np.zeros((self._t.size, self._t2.size))\r\n code = \"\"\"\r\n for(int i=0; i<N; i++){\r\n for(int j=0; j<N2; j++){\r\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\r\n }\r\n }\r\n \"\"\"\r\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\r\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\r\n weave.inline(code, ['index', 'index2',\r\n 'scale_mat', 'B',\r\n 'N', 'N2', 'output_dim'])","def __init__(self):\n self.n=0\n self.K=0\n self.tuple_data=False\n self.optimal=0","def define_potts_helper_functions(k):\n\n @njit\n def calc_observables(X, k=k):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n\n Returns\n -------\n ndarray\n Dimensions (n_samples, n_observables).\n \"\"\"\n\n n = X.shape[1]\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\n \n # average orientation (magnetization)\n # note that fields for the third state are often set to 0\n counter = 0\n for i in range(k):\n for j in range(n):\n Y[:,counter] = X[:,j]==i\n counter += 1\n \n # pairwise correlations\n for i in range(n-1):\n for j in range(i+1, n):\n Y[:,counter] = X[:,i]==X[:,j]\n counter += 1\n \n return Y\n\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n multipliers : ndarray of dtype np.float64\n\n Returns\n -------\n ndarray\n Energies of each observable.\n \"\"\"\n\n return -calc_observables(X, k).dot(multipliers)\n\n def mch_approximation(sample, dlamda, calc_e=calc_e):\n \"\"\"Function for making MCH approximation step for Potts model.\n \n Parameters\n ----------\n sample : ndarray\n Of dimensions (n_sample, n_spins).\n dlamda : ndarray\n Change in parameters.\n \n Returns\n -------\n ndarray\n Predicted correlations.\n \"\"\"\n\n dE = calc_e(sample, dlamda)\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \n assert not ((predsisj<0).any() or\n (predsisj>(1+1e-10)).any()),\"Predicted values are beyond limits, (%E,%E)\"%(predsisj.min(),\n predsisj.max())\n return predsisj\n\n return calc_e, calc_observables, mch_approximation","def cuttingStockKantorovich(w, q, B):\n\n model = Model(\"Naive Cutting Stock\")\n m = max(w)*max(q) # m rolls\n n = len(q) # n orders \n y = {}\n for j in range(m):\n y[j] = model.addVar(name = \"y[%s]\" % j, vtype=\"BINARY\")\n \n x = {}\n for j in range(m):\n for i in range(n):\n x[i,j] = model.addVar(name = \"x[%s,%s]\" %(i,j), lb = 0, vtype=\"INTEGER\")\n model.addCons(x[i,j] <= q[i]*y[j])\n\n for i in range(n):\n model.addCons(quicksum(x[i,j] for j in range(m)) == q[i])\n\n for j in range(m):\n model.addCons((quicksum(w[i]*x[i,j] for i in range(n)) <= B))\n\n model.setObjective(quicksum(y[j] for j in range(m)), \"minimize\")\n model.hideOutput()\n model.optimize()\n\n return model.getObjVal()","def bfgs_method(x0, eps=1e-6, H0=np.eye(18),c1=1e-4):\n k = 0 # initialize num of outer iterations.\n inner_k = 0 # initialize inner k iteration.\n old_xk = None\n alpha_original = 1\n alpha = np.copy(alpha_original)\n xk = x0 # intitialize x.\n Hk = H0 # initialize H, positive definite matrix.\n I = np.eye(len(x0)) # idenitity matrix of 2 by 2.\n\n alpha_vec = []\n f_vec = []\n grad_vec = []\n inner_k = []\n conv_c = []\n\n while np.linalg.norm(rosen_der(xk)) > eps:\n pk = -Hk @ rosen_der(xk)\n\n xk_next = xk + alpha * pk\n ink = 0\n print(xk)\n while rosen(xk_next) > rosen(xk) + c1 * alpha * (pk.T @ rosen_der(xk)):\n \"\"\" find a step size that will satisfy Armijo-Goldstein inequality. Modify alpha. \"\"\"\n alpha = 0.1* alpha\n xk_next = xk + alpha * pk\n ink += 1\n\n inner_k.append(abs(int(ink)))\n\n xk_next = xk + alpha * pk\n\n sk = xk_next - xk\n\n yk = rosen_der(xk_next) - rosen_der(xk)\n\n rho = 1 / (yk.T @ sk)\n\n Hk = np.copy((I - rho * sk @ yk.T) @ Hk @ (I - rho * yk @ sk.T) + rho * sk @ sk.T)\n\n old_xk = np.copy(xk)\n xk = np.copy(xk_next)\n\n alpha_vec.append(alpha)\n f_vec.append(rosen(xk))\n grad_vec.append(np.linalg.norm(rosen_der(xk)))\n alpha = np.copy(alpha_original)\n print(f_vec[-1])\n\n k += 1\n\n return xk, k, inner_k, alpha_vec, f_vec, grad_vec","def build_graph(self, values, values_mask, keys_mask, keys, use_mask=True):\n\n with vs.variable_scope(\"CoAttn\"):\n\n print('value_vec_size is: ', self.value_vec_size)\n print('num_values size is: ', values.shape[1])\n print('num_keys size is: ', keys.shape[1])\n print('value_vec_size is (key):', keys.shape[2])\n # Declare variable \n W = tf.get_variable(\"W\", shape = (self.value_vec_size, self.value_vec_size), \\\n initializer = tf.contrib.layers.xavier_initializer())\n b = tf.get_variable(\"b\", shape = (self.value_vec_size), initializer = tf.constant_initializer(0))\n\n # Compute projected question hidden states\n\n Q = tf.tanh(tf.tensordot(values, W, 1) + tf.reshape(b, [1, 1, self.value_vec_size])) # (batch_size, num_values, value_vec_size)\n\n\n Q = concat_sentinel('question_sentinel', Q, self.value_vec_size) # (batch_size, num_values, value_vec_size)\n # Q = tf.nn.dropout(Q, self.keep_prob)\n print('Q shape is: ', Q.shape)\n # sentinel = tf.get_variable(name='question_sentinel', shape=tf.shape(Q)[2], \\\n # initializer=tf.contrib.layers.xavier_initializer(), dtype = tf.float32)\n # sentinel = tf.tile(sentinel, [tf.shape(original_tensor)[0], 1, 1])\n # concat_tensor = tf.concat([original_tensor, sentinel], 2)\n\n print('Q shape is: ', Q.shape)\n D = keys # (batch_size, num_keys, value_vec_size)\n D = concat_sentinel('document_sentinel', D, self.value_vec_size)\n # D = tf.nn.dropout(D, self.keep_prob)\n\n # key = document, value = question here\n ### End your code here to implement 'Sentinel Vector'\n # Compute affinity matrix L\n L = tf.matmul(D, tf.transpose(Q, perm=[0, 2, 1])) # shape (batch_size, num_keys, num_values)\n\n # Compute Context-to-Question (C2Q) Attention, we obtain C2Q attention outputs\n if use_mask:\n print('tf.shape(values)[0] is: ', tf.shape(values)[0])\n print('tf.ones([tf.shape(values)[0], 1] is ', tf.ones([tf.shape(values)[0], 1], dtype=tf.int32))\n values_mask = tf.expand_dims(tf.concat([values_mask, tf.ones([tf.shape(values)[0], 1], dtype=tf.int32)], axis=1), 1)\n print \"value_mask shape:\", values_mask.shape\n print \"L shape:\", L.shape\n _, A_D = masked_softmax(L, mask=values_mask, dim=2) #(batch_size, num_keys, num_values)\n else:\n A_D = tf.nn.softmax(L, dim=-1)\n\n C2Q_Attn = tf.matmul(A_D, Q) # (batch_size, num_keys, value_vec_size)\n print('C2Q_Attn shapeis ', C2Q_Attn.shape)\n\n # Compute Question-to-Context (Q2C) Attention, we obtain Q2C attention outputs\n if use_mask:\n keys_mask = tf.expand_dims(tf.concat([keys_mask, tf.ones([tf.shape(keys)[0], 1], dtype=tf.int32)], axis=1), 1)\n print \"key_mask shape:\", keys_mask.shape\n print \"L shape:\", L.shape\n _, A_Q = masked_softmax(tf.transpose(L, perm=[0, 2, 1]), mask=keys_mask, dim=-1) # (batch_size, num_values, num_keys)\n else:\n A_Q = tf.nn.softmax(tf.transpose(L, perm=[0, 2, 1]), dim=2)\n\n Q2C_Attn = tf.matmul(A_Q, D) # (batch_size, num_values, key_vec_size)\n print('Q2C_Attn shapeis ', Q2C_Attn.shape)\n\n # Compute second-level attention outputs S\n S = tf.matmul(A_D, Q2C_Attn) # (batch_size, num_keys, value_vec_size)\n print('S size is: ', S.shape)\n\n # Concatenate C2Q_Attn and S:\n C_D = tf.concat([D, C2Q_Attn, S], 2) # (batch_size, num_keys, 3 * value_vec_size)\n # C_D = tf.nn.dropout(C_D, self.keep_prob)\n print('co_context size is: ', C_D.shape)\n\n # co_input = tf.concat([tf.transpose(D, perm = [0, 2, 1]), C_D], 1)\n # print('co_input size is: ', co_input.shape)\n size = int(self.value_vec_size)\n \n if self.device == 'gpu':\n bidirection_rnn = tf.contrib.cudnn_rnn.CudnnLSTM(1, size, 3*size, dropout=0.2, direction=cudnn_rnn_ops.CUDNN_RNN_BIDIRECTION, dtype=tf.float32)\n C_D = tf.transpose(C_D, perm=[1, 0, 2])\n print 'C_D shape', C_D.shape\n input_h = tf.zeros([2, tf.shape(values)[0], size])\n input_c = tf.zeros([2, tf.shape(values)[0], size])\n params = tf.get_variable(\"RNN\", shape=(estimate_cudnn_parameter_size(3*self.value_vec_size, size, 2)),\n initializer=tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\n \n U, _, _ = bidirection_rnn(C_D, input_h, input_c, params)\n#\n print 'U shape:', U.shape\n U = tf.transpose(U, perm=[1, 0, 2])\n\n else:\n (u_fw_out, u_bw_out), _ = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), cell_bw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), \n inputs=C_D, dtype = tf.float32)\n U = tf.concat([u_fw_out, u_bw_out], 2)\n\n U = tf.nn.dropout(U[:,:-1, :], self.keep_prob)\n # U = tf.nn.dropout(U, self.keep_prob)\n print('U shape is: ', U.shape)\n \n return U,A_D,A_Q","def learn_MAP(self,knowledge,k=10):\n \n gradients = {}\n for i in range(k):\n\n #create TILDE(R) tree object\n tree_i = TILDE(typ=\"regression\",score=\"WV\",max_depth=self.max_depth)\n\n #subsample negatives if too many for each tree\n sampled_neg = deepcopy(self.neg)\n if len(self.neg) > 2*len(self.pos):\n sampled_neg = sample(self.neg,2*len(self.pos))\n\n #compute gradients as I-P\n for ex in self.examples:\n parameter = knowledge.calculate_parameter(self.data,\n ex,\n self.examples[ex])\n p = sigmoid(self.examples[ex])\n if ex in self.pos:\n gradients[ex] = 1-p - parameter\n elif ex in sampled_neg:\n gradients[ex] = 0-p - parameter\n\n #fit tree on gradients\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\n \n #recompute example values as previous example value + tree_i value\n for ex in self.examples:\n tree_i_value = tree_i.infer(self.data,ex)\n self.examples[ex] += tree_i_value\n\n #add tree to boosted_trees\n self.boosted_trees.append(tree_i)","def F(N,k=0) :\n accum = 0.0\n for i in xrange(1,N+1-k) :\n accum += (1.0+F(N-1,k+i-1))/N\n return accum","def train(self, data, labels, validationData, validationLabels):\n \n # -- calls the classify method to evaluate performance \n # -- OUR CODE HERE\n \n legalLabels = labels\n self.legalLabels = legalLabels\n trainingData = validationData\n trainingLabels = validationLabels\n \n kCorrect = util.Counter()\n self.conditionalProb = []\n \n \n self.prior = util.Counter()\n for label in labels:\n self.prior[label] += 1.0\n self.prior.normalize()\n #for label in self.prior:\n # self.prior[label]/=len(trainingLabels)\n \n \"\"\"\n print \"legal labels are \", len(legalLabels)\n print \"kgrid is \", kgrid\n print \"the legal labels are.... \", legalLabels\n \"\"\"\n \n import time\n \n condprobForK = {}\n \n # -- iterate through each k in kgrid... should we be doing this?\n # -- won't this affect the cond prob tables? :(\n k = 0.5\n #print \"working on k = \",k,\" in kgrid\"\n \n # -- reset the conditonal prob table\n # -- each time we go through a different k...\n self.conditionalProb = {}\n \n # -- go through each label and initialize the Counter for that label (the cond prob table)\n for label in legalLabels:\n self.conditionalProb[label] = util.Counter()\n \n # -- go through each piece of training data and train the tables on it \n for dataNum in range(len(trainingData)):\n \n # -- identify which label we're using... not sure if this is correct\n label = trainingLabels[dataNum] # 0 or like 9 or 2\n \n # -- iterate through each pixel and update the conditional prob counter for that label\n for pixel in trainingData[dataNum]:\n \n if pixel is \"moreThanOneConnBlackRegions\":\n #print \"Number is :: \", label, \" and has \", trainingData[dataNum][pixel]\n assert 1 is 1\n \n on_off = trainingData[dataNum][pixel] * 1.0\n self.conditionalProb[label][pixel] += on_off * 1.0\n \n # -- now we go through and add k to each of the conditional probabilities\n # -- note that we do so for each label and every single pixel\n for label in legalLabels:\n for pixel in self.conditionalProb[label]: \n # -- add the k value \n self.conditionalProb[label][pixel] += k * 1.0\n assert self.conditionalProb[label][pixel] >= k # -- sanity check that it should be at least k\n self.conditionalProb[label][pixel] /= (self.prior[label] * len(trainingLabels) + k*2)\n \n \n \n # -- END OUR CODE","def _k(self, T):\n RT = Rgas * T\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))","def f(X_,K_):\r\n return max(exp(X_)-K_,0)","def dealer_probs():\n # Pdf of any current hand (value, hard) and final value; p(v_f | v_c) where v_f = final value, v_c = current value\n probabilities = {}\n\n # End nodes: (value, True) for value >= 17 and (value, False) for value > 17\n # Dependencies (in order of increasing requirements):\n # Hard values, value >= 11, possiblity of bust, no possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value\n # Soft values, 17 >= value >= 11 (value, False) depends on (value', False) for 17 >= value' > value, (value', True) for 17 > value' > 11\n # Hard values, 11 > value >= 2 , no possibility of bust, possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value and (value', False) for 17 >= value' > 13\n\n\n # End nodes\n for value in xrange(17, 22):\n probabilities[(value, True)] = {value: 1.0}\n if value == 17: continue # on soft 17, dealer will still hit\n probabilities[(value, False)] = {value: 1.0}\n\n # Hard values, 17 > value >= 11, possibility of bust, no possibility of going soft with an ace\n for value in xrange(16, 10, -1):\n probabilities[(value, True)] = {}\n current_prob = probabilities[(value, True)]\n for next_card in xrange(1, min(10, 21-value)+1):\n next_prob = probabilities[(value + next_card, True)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n # Soft values, 17 >= value >= 11\n for value in xrange(17, 10, -1):\n probabilities[(value, False)] = {}\n current_prob = probabilities[(value, False)]\n for next_card in xrange(1, 11):\n next_value = value + next_card\n hard = False\n if next_value > 21:\n next_value -= 10\n hard = True\n next_prob = probabilities[(next_value, hard)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n # Hard values, 11 > value >= 2, no possibility of bust, possibility of going soft with an ace\n for value in xrange(10, 1, -1):\n probabilities[(value, True)] = {}\n current_prob = probabilities[(value, True)]\n for next_card in xrange(2, 12):\n next_value = value + next_card\n hard = (next_card != 11)\n next_prob = probabilities[(next_value, hard)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n return probabilities","def value_iteration(P, nS, nA, gamma=0.9, tol=1e-3):\n\n\tvalue_function = np.zeros(nS)\n\tpolicy = np.zeros(nS, dtype=int)\n\tmax_num_iterations = 2000\n\n\t############################\n\t# YOUR IMPLEMENTATION HERE #\n\n\tfor i in range(max_num_iterations):\n\t\tprevious_value_function = np.copy(value_function)\n\t\tfor s in range(nS):\t# for each state\n\t\t\tq_values = np.zeros(nA)\n\t\t\tfor action in range(nA):\t# for each action\n\t\t\t\tq_value = 0\n\t\t\t\tfor transition in P[s][action]:\t# for every possible transition\n\t\t\t\t\tprobability = transition[0]\n\t\t\t\t\treward = transition[2]\n\t\t\t\t\tnext_state = transition[1]\n\t\t\t\t\tvalue_next_state = previous_value_function[next_state]\n\n\t\t\t\t\t# print(\"probability: \" + str(probability) + \"reward: \" + str(reward) + \"value next state: \" + str(value_next_state))\n\n\t\t\t\t\tq_value += probability * (reward + gamma * value_next_state)\n\t\t\t\t\n\t\t\t\tq_values[action] = q_value\n\n\t\t\tvalue_function[s] = np.amax(q_values)\t# the value is the max of these q values\n\t\t\t# extract policy\n\t\t\tpolicy[s] = np.argmax(q_values)\n\n\t\t# find the maximum difference between the previous value function and the current value function\n\t\tdifArray = np.subtract(value_function, previous_value_function)\n\t\tfor x in range(nS):\n\t\t\tdifArray[x] = abs(difArray[x])\n\t\tmaxDif = np.amax(difArray)\n\n\t\tif (maxDif < tol):\n\t\t\tprint(\"optimal policy found at iteration \" + str(i + 1))\n\t\t\tbreak\n\n\t############################\n\treturn value_function, policy","def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 4th order calculation\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\n \n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n\n # Calculate truncation error between 5th and 4th order\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\n \n # Compare eps to emin and emax and update h accordingly\n if np.max(eps) < emin:\n if h*2.0 < hmax:\n h *= 2.0\n new_v = new_v5\n new_r = new_r5 \n \n if np.max(eps) > emax:\n if h/2.0 > hmin:\n h /= 2.0\n print h\n # Error too large, call rk_adaptive again with smaller h\n if recur < recurmax:\n recur += 1\n rk_adaptive(accel,m,r,h,v,recur)\n new_v = new_v5\n new_r = new_r5\n \n else:\n new_v = new_v5\n new_r = new_r5\n \n return new_v, new_r, h","def generate_pn2kc_weights(nb_pn, nb_kc, min_pn=10, max_pn=20, aff_pn2kc=None, nb_trials=100000, baseline=25000,\r\n rnd=np.random.RandomState(2018), dtype=np.float32):\r\n\r\n dispersion = np.zeros(nb_trials)\r\n best_pn2kc = None\r\n\r\n for trial in range(nb_trials):\r\n pn2kc = np.zeros((nb_pn, nb_kc), dtype=dtype)\r\n\r\n if aff_pn2kc is None or aff_pn2kc <= 0:\r\n vaff_pn2kc = rnd.randint(min_pn, max_pn + 1, size=nb_pn)\r\n else:\r\n vaff_pn2kc = np.ones(nb_pn) * aff_pn2kc\r\n\r\n # go through every kenyon cell and select a nb_pn PNs to make them afferent\r\n for i in range(nb_pn):\r\n pn_selector = rnd.permutation(nb_kc)\r\n pn2kc[i, pn_selector[:vaff_pn2kc[i]]] = 1\r\n\r\n # This selections mechanism can be used to restrict the distribution of random connections\r\n # compute the sum of the elements in each row giving the number of KCs each PN projects to.\r\n pn2kc_sum = pn2kc.sum(axis=0)\r\n dispersion[trial] = pn2kc_sum.max() - pn2kc_sum.min()\r\n # pn_mean = pn2kc_sum.mean()\r\n\r\n # Check if the number of projections per PN is balanced (min max less than baseline)\r\n # if the dispersion is below the baseline accept the sample\r\n if dispersion[trial] <= baseline: return pn2kc\r\n\r\n # cache the pn2kc with the least dispersion\r\n if best_pn2kc is None or dispersion[trial] < dispersion[:trial].min():\r\n best_pn2kc = pn2kc\r\n\r\n # if non of the samples have dispersion lower than the baseline,\r\n # return the less dispersed one\r\n return best_pn2kc","def _goalFunction(D, G, U, K, n, m):\n J = 0\n for k in range(K):\n for i in range(n):\n u = U[i][k] ** m\n d = _extendedDissimilarity(D, G[k], i)\n J += u * d\n return J","def rk5(accel,m,r,h,v):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n \n return new_v5, new_r5","def n_choose_k(N,K):\n return factorial(N) // (factorial(N - K) * factorial(K))","def Q_credit_checkers(s_grid, s_n, g_n, a_m, s_m, s_others, t_obs, v_obs,\n f1=4, k1=[3,5], f2=6, k2=[3,3],\n n_h1_1=128, n_h1_2=32, n_h2=32, stage=2, bias=True):\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\n concated = tf.concat( [conv, s_n, g_n, a_m, conv_o, v_obs], axis=1 )\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\n W_branch1_h2 = get_variable(\"W_branch1_h2\", [n_h1_1, n_h2])\n\n list_mult = []\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\n\n if stage > 1:\n with tf.variable_scope(\"stage-2\"):\n concated2 = tf.concat( [s_m, s_others], axis=1 )\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\n list_mult.append(tf.matmul(others, W_branch2_h2))\n\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\n \n return out","def n_choose_kv(newK):\n values = np.zeros((1,newK+1))\n ks = np.arange(newK+1)\n \n for i in range(newK+1):\n values[i] = scipy.misc.comb(newK, ks[i])\n\n return values","def binary_dec(A,n_iter = 1000):\n\n\t### Initialization ###\n\n\tp, q = np.shape(A)\n\t### B : to be changed\n\tB = np.eye(p)\n \t###\n\tC = bin_random_mat(p,q)\n\tlist_dist = []\n\tB_argmin = B\n\tC_argmin = C\n\n\n\n\n\t## temperature ##\n\tT_n = np.log(np.arange(2,n_iter+2,1))\n\t#T_n = np.arange(2,n_iter+2,1)\n\tfor i in range(n_iter):\n\t## update ##\n\t\tC_0 = np.matrix(C)\n\t\tlist_dist =np.append( list_dist, V_potential(np.dot(B,C_0),A) )\n\t\tif V_potential(np.dot(B_argmin,C_argmin),A) == 0:\n\t\t\tbreak\n\t########## transition #############\n\t# Here we take 2 steps independent(for B and for C respectively)\n\t# We could also use metropolis hasting kernel.\n\n\t\tC_iter = np.matrix(Metropolis_transition_C(C))\n\t\n\n\t\tB_iter = B[np.random.permutation(np.arange(p))]\n\t\t\n\t\tif np.random.uniform(0,1,1) < \\\n\t\t\t\tnp.exp(-1./T_n[i]*( V_potential(np.dot(B_iter,C_iter), A)\\\n\t\t\t\t - V_potential(np.dot(B,C_0),A) ) ):\n\t\t\tC = C_iter\n\t\t\tB = B_iter\n\t######### end of transition ##############\n\n\t\t\tif V_potential(np.dot(B,C),A) < np.min(list_dist):\n\t\t\t\t\n\t\t\t\tB_argmin = B\n\t\t\t\tC_argmin = np.matrix(C)\n\t\t\t# print i+1\n\t\t\t# print V_potential(np.dot(B_argmin,C_argmin),A)\n\t\t\t# print C_argmin\n\t\t\t# print '\\n'\n\n\treturn list_dist,B_argmin, C_argmin","def combinations(n, k):\r\n return exp(gammaln(n + 1) - gammaln(k + 1) - gammaln(n - k + 1))","def solveForModeB1(X, M, n, maxInner, epsilon, tol,sita,Y1, lambta2):\n # Pi(n) = [A(N) kr A(N-1) kr ... A(n+1) kr A(n-1) kr .. A(1)]^T\n Pi = tensorTools.calculatePi(X, M, n)\n #print 'Pi size', Pi.shape\n #print 'pi='+str(Pi)\n #print(M.U[n])\n for iter in range(maxInner):\n # Phi = (X(n) elem-div (B Pi)) Pi^T\n #print X.vals.shape,X.shape\n #print X.vals.flatten().shape\n Phi = tensorTools.calculatePhi(X, M.U[n], Pi, n, epsilon=epsilon)\n #print('phi'+str(Phi))\n #print(Phi)\n # check for convergence that min(B(n), E - Phi(n)) = 0 [or close]\n kktModeViolation = np.max(np.abs(np.minimum(M.U[n], 1-Phi).flatten()))\n if (kktModeViolation < tol):\n break\n\n B=M.U[n]\n #print B.shape\n colNorm = np.apply_along_axis(np.linalg.norm, 0, B, 1)\n zeroNorm = np.where(colNorm == 0)[0]\n colNorm[zeroNorm] = 1\n B = B / colNorm[np.newaxis, :]\n tm=np.hstack((np.ones((B.shape[0],1)),B))\n Y1=Y1.reshape((Y1.shape[0],1))\n\n derive=-1.0*lambta2/B.shape[0]*np.dot((Y1-np.dot(tm,sita)),sita.T)\n #print derive.shape\n #print np.multiply(M.U[n],derive[:,1:]).shape\n #print np.multiply(M.U[n],Phi).shape\n M.U[n] = np.array(np.multiply(M.U[n],Phi))-np.array((np.multiply(M.U[n],derive[:,1:])))\n\n #print 'after'\n #print M.U[n][0]\n #print(\" Mode={0}, Inner Iter={1}, KKT violation={2}\".format(n, iter, kktModeViolation))\n return M, Phi, iter, kktModeViolation","def method_2d(knots,y_n,num):\n cv_iter = 10 # number of iteration for cross-validation \n GSV = np.zeros((cv_iter,cv_iter))\n# tr = np.zeros((cv_iter,cv_iter))\n# fun =np.zeros((cv_iter,cv_iter))\n lam_x = np.linspace(0,0.2,cv_iter)\n lam_y = np.linspace(0,0.2,cv_iter)\n num_knots = len(knots)\n linear_knots = knots[1:num_knots-1]\n num_knots = num_knots-4\n znam = np.zeros((num_knots))\n basis = np.zeros((num,num_knots))\n basis_1 = np.zeros((num,num_knots))\n basis_deriative = np.zeros((num,num_knots))\n basis_deriative_1 = np.zeros((num,num_knots))\n S = np.zeros((num_knots,num_knots,num))\n vs = BsplineVectorSpace(2, knots)\n vs_1 = BsplineVectorSpace(1, linear_knots)\n I_i = np.eye(num_knots)\n for i in xrange(0,num_knots):\n basis[:,i] = vs.basis_der(i,0)(np.linspace(0,1,num))\n basis_deriative[:,i] = vs.basis_der(i,1)(np.linspace(0,1,num))/num\n basis_1[:,i] = vs_1.basis_der(i,0)(np.linspace(0,1,num))\n basis_deriative_1[:,i] = vs_1.basis_der(i,1)(np.linspace(0,1,num))/num\n B = abs(basis_deriative-basis_1)\n S = np.zeros((num_knots,num_knots,num))\n k = np.zeros((num_knots,num_knots,num))\n for i in xrange(num_knots):\n for j in xrange(num_knots):\n S[i,j,:] = B[:,i]*B[:,j]\n k[i,j,:] =basis_deriative_1[:,i] * basis_deriative_1[:,j]\n S_int = np.zeros((num_knots,num_knots))\n k_int = np.zeros((num_knots,num_knots))\n for i in xrange(num_knots):\n for j in xrange(num_knots):\n S_int[i,j] = integrate.trapz(S[i,j,:])\n k_int[i,j] = integrate.trapz(k[i,j,:])\n basis_product = np.kron(basis,basis)\n S_x = np.kron(S_int,I_i)\n S_y = np.kron(I_i,S_int)\n K_x = np.kron(k_int,I_i)\n K_y = np.kron(I_i,k_int)\n for i in xrange(cv_iter):\n for j in xrange(cv_iter):\n influence_matrix = np.dot(np.dot(basis_product,(np.linalg.inv(np.dot(np.transpose(\n basis_product),basis_product)+lam_x[i]*S_x+lam_y[j]*S_y+lam_x[i]* K_x+lam_y[j]*K_y))),np.transpose(basis_product))\n for k in xrange(num_knots):\n znam[k] =(1-influence_matrix[k,k])**2\n tr = np.sum(znam)\n fun = np.sum((y_n-np.dot(influence_matrix,y_n))**2)\n GSV[i,j] =fun/(num*tr)\n print i,j\n a,b = np.unravel_index(GSV.argmin(), GSV.shape)\n# a = np.argmin(np.argmin(GSV,axis = 0))\n# b = np.argmin(np.argmin(GSV,axis = 1))\n lamb_x = lam_x[a]\n lamb_y = lam_y[b]\n print lamb_x,lamb_y\n model_fit = np.dot(np.dot(np.dot(basis_product,(np.linalg.inv(np.dot(np.transpose(\n basis_product),basis_product)+lamb_x*S_x+lamb_y*S_y+lamb_x* K_x+lamb_y*K_y))),np.transpose(basis_product)),y_n)\n return model_fit,GSV","def trainAndTune(self, trainingData, trainingLabels, validationData, validationLabels, kgrid):\n\n\tself.conditional_prob_table = util.Counter()\n\tself.prior_distribution_prob_table = util.Counter()\n\tself.conditional_prob = {}\n\tself.prior_distribution_prob = {}\n\titeration = 0 # use to symbolize which k value we are for storage in dict, since k is a float\n\t\n\t#iterate through all k values to obtain best probabilities prior/cond\n\tfor k in kgrid:\n\t\tprint \"K value: \", k, \" Iteration: \", iteration\n\t\t# helper function to calculate prior dist prob and conditional prob\n\t\tself.trainAndTuneHelper(trainingData, trainingLabels, k) \n\t\t# Set weights in tables before next iteration, save all data to choose highest probabilities at the end\n\t\tself.conditional_prob_table[iteration] = self.conditional_prob \n\t\tself.prior_distribution_prob_table[iteration] = self.prior_distribution_prob\n\t\titeration += 1 #represents k value since k is a float \n\t\t\n\t# Assign highest conditional probability and prior distribution probability, pull from dictionaries\n\tself.conditional_prob = self.conditional_prob_table[max(self.conditional_prob_table, key=self.conditional_prob_table.get)]\n\tself.prior_distribution_prob = self.prior_distribution_prob_table[max(self.prior_distribution_prob_table, key=self.prior_distribution_prob_table.get)]","def brute_force_inference(self):\n\n counter = 0\n for k, v in self.vs.items():\n if not v.observed:\n counter += 1\n\n Z = 0.0\n for config_lst in it.product([0, 1], repeat=counter * self.N):\n config = np.asarray(config_lst)\n\n # set values\n counter = 0\n for k, v in self.vs.items():\n if not v.observed:\n val = config[counter*self.N:(counter+1)*self.N]\n v.b = val\n counter += 1\n \n # get scores\n config_score = 1.0\n for k, f in self.fs.items():\n vecs = [e.v.b for e in f.edges]\n score = exp(dot(dot(vecs[0], f.tp.F), vecs[1]))\n config_score *= score\n\n Z += config_score\n print \"Z\", Z","def __init__(self, k):\n self.k = k\n self.N = 2**self.k","def _step(self) -> Dict[str, tf.Tensor]:\n\n # Pull out the data needed for updates/priorities.\n inputs = next(self._iterator)\n\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\n keys, probs = inputs.info[:2]\n\n with tf.GradientTape() as tape:\n # Evaluate our networks.\n # `qv` means quantile values\n # Shape: [B, A, num_quantiles]\n qv_tm1 = self._network(o_tm1)\n qv_t = self._target_network(o_t) # [B, A, num_quantiles]\n q_t_selector = tf.reduce_mean(\n self._network(o_t) if self._double_dqn else self._target_network(o_t),\n axis=-1)\n\n # Shape: [B]\n a_t = tf.argmax(q_t_selector, axis=1, output_type=tf.int32)\n\n # The rewards and discounts have to have the same type as network values.\n r_t = tf.clip_by_value(tf.cast(r_t, qv_tm1.dtype), -1., 1.)\n d_t = tf.cast(d_t, qv_tm1.dtype) * tf.cast(self._discount, qv_tm1.dtype)\n\n # Calculate actions value distribution\n qv_a_tm1 = slice_with_actions(qv_tm1, a_tm1) # [B, num_quantiles]\n\n # Scale and shift time-t distribution atoms by discount and reward.\n qv_a_t = slice_with_actions(qv_t, a_t) # [B, num_quantiles]\n # Shape: [B, num_quantiles]\n target = tf.stop_gradient(r_t[:, None] + d_t[:, None] * qv_a_t)\n\n # Calculate quantile huber loss\n # Shape: [B, num_quantiles, num_quantiles]\n bellman_errors = target[:, None, :] - qv_a_tm1[:, :, None]\n tau = tf.linspace(0.0, 1.0, self._num_quantiles + 1)\n tau_hat = ((tau[1:] + tau[:-1]) / 2.0)[None, :, None]\n\n # Compute the loss.\n # Shape: [B, num_quantiles, num_quantiles]\n # huber_loss_case_one = tf.cast(tf.abs(bellman_errors) <= self._kappa,\n # tf.float32) * 0.5 * bellman_errors ** 2\n # huber_loss_case_two = tf.cast(tf.abs(bellman_errors) > self._kappa,\n # tf.float32) * self._kappa * (\n # tf.abs(bellman_errors) - 0.5 * self._kappa)\n # huber_loss = huber_loss_case_one + huber_loss_case_two\n huber_loss = losses.huber(bellman_errors, self._kappa)\n\n # Shape: [B, num_quantiles, num_quantiles]\n quantile_huber_loss = (tf.abs(tau_hat - tf.stop_gradient(\n tf.cast(bellman_errors < 0, tf.float32))) * huber_loss) / self._kappa\n\n # Shape: [B]\n loss = tf.reduce_mean(tf.reduce_sum(quantile_huber_loss, axis=2), axis=1)\n td_errors = tf.identity(loss)\n\n # Get the importance weights.\n importance_weights = 1. / probs # [B]\n importance_weights **= self._importance_sampling_exponent\n importance_weights /= tf.reduce_max(importance_weights)\n\n # Reweight.\n loss *= tf.cast(importance_weights, loss.dtype) # [B]\n loss = tf.reduce_mean(loss, axis=[0]) # []\n\n # Do a step of SGD.\n gradients = tape.gradient(loss, self._network.trainable_variables)\n self._optimizer.apply(\n gradients, self._network.trainable_variables)\n\n # Update the priorities in the replay buffer.\n if self._replay_client:\n priorities = tf.cast(tf.sqrt(td_errors + 1e-10), tf.float64)\n self._replay_client.update_priorities(\n table=adders.DEFAULT_PRIORITY_TABLE, keys=keys, priorities=priorities)\n\n # Periodically update the target network.\n if tf.math.mod(self._num_steps, self._target_update_period) == 0:\n trfl.update_target_variables(\n target_variables=self._target_network.variables,\n source_variables=self._network.variables)\n self._num_steps.assign_add(1)\n\n # Report loss & statistics for logging.\n fetches = {\n 'loss': loss,\n }\n\n return fetches","def birank(W, u0=None, v0=None,\n alpha=0.85, beta=0.85, max_iter=200, tol=1.0e-4, verbose=False):\n # default initial vectors: 1/|U|, 1/|V|\n if u0 is None:\n u0=np.repeat(1 / W.shape[0], W.shape[0])\n if v0 is None:\n v0=np.repeat(1 / W.shape[1], W.shape[1])\n\n\n W = W.astype('float', copy=False)\n WT = W.T\n\n Ku = np.array(W.sum(axis=1)).flatten()\n Kv = np.array(W.sum(axis=0)).flatten()\n # avoid divided by zero issue\n Ku[np.where(Ku==0)] += 1\n Kv[np.where(Kv==0)] += 1\n\n Ku_ = spa.diags(1/Ku)\n Kv_ = spa.diags(1/Kv)\n\n Ku_bi = spa.diags(1/np.sqrt(Ku))\n Kv_bi = spa.diags(1/np.sqrt(Kv))\n Sv = Kv_bi.dot(WT).dot(Ku_bi)\n Su = Sv.T\n\n\n u_last = u0.copy()\n v_last = v0.copy()\n\n for i in range(max_iter):\n u = alpha * (Su.dot(v_last)) + (1-alpha) * u0\n v = beta * (Sv.dot(u_last)) + (1-beta) * v0\n\n err_u = np.absolute(u - u_last).sum()\n err_v = np.absolute(v - v_last).sum()\n \n if verbose:\n print(\n \"Iteration : {}; top error: {}; bottom error: {}\".format(\n i, err_u, err_v\n )\n )\n if err_v < tol and err_u < tol:\n break\n u_last = u\n v_last = v\n\n return u, v","def get_cost_updates(self, lr=0.1, k=1):\n\n # compute positive phase\n pre_sigmoid_ph, ph_mean, ph_sample = self.sample_h_given_v(self.input)\n\n # decide how to initialize persistent chain:\n # for CD, we use the newly generate hidden sample\n chain_start = ph_sample\n\n # perform actual negative phase\n # in order to implement CD-k/PCD-k we need to scan over the\n # function that implements one gibbs step k times.\n # Read Theano tutorial on scan for more information :\n # http://deeplearning.net/software/theano/library/scan.html\n # the scan will return the entire Gibbs chain\n\n # noinspection PyCallingNonCallable, PyUnusedLocal\n (\n [\n pre_sigmoid_nvs,\n nv_means,\n nv_samples,\n pre_sigmoid_nhs,\n nh_means,\n nh_samples\n ],\n updates\n ) = theano.scan(\n self.gibbs_hvh,\n # the None are place holders, saying that\n # chain_start is the initial state corresponding to the\n # 6th output\n outputs_info=[None, None, None, None, None, chain_start],\n n_steps=k\n )\n # determine gradients on RBM parameters\n # note that we only need the sample at the end of the chain\n chain_end = nv_samples[-1]\n\n cost = \\\n T.mean(self.free_energy(self.input)) - \\\n T.mean(self.free_energy(chain_end))\n\n regularization = \\\n (self.lmbda / 2.) * \\\n (T.mean(T.sum(T.sqr(self.hidden_layer.W), axis=1)))\n\n cost += regularization\n\n learning_rate = T.cast(0.01, dtype=DTYPES.FLOATX)\n\n # noinspection PyUnusedLocal\n def regulared(pidx, param):\n # We must not compute the gradient through the gibbs sampling\n grad = T.grad(cost, param, consider_constant=[chain_end])\n current_cost = learning_rate * grad\n updates[param] = param - current_cost\n\n def momentumed(pidx, param):\n if len(self.Ms) < pidx + 1:\n # initialize momentum for this element to zeros\n self.Ms.append(theano.shared(\n param.get_value() * 0.,\n broadcastable=param.broadcastable\n ))\n # self.Ms.append(theano.shared(0.))\n\n M_update = self.Ms[pidx]\n\n momentum = T.cast(self.momentum, dtype=DTYPES.FLOATX)\n mom = momentum * M_update\n\n grad = T.grad(\n cost,\n param,\n consider_constant=[chain_end]\n )\n\n v_prime = mom - learning_rate * grad\n w_prime = param + v_prime\n updates[M_update] = v_prime\n updates[param] = w_prime\n\n # noinspection PyUnusedLocal\n def rmsproped(pidx, param):\n # NOTE : matrix of learning rates\n if len(self.MSs) < pidx + 1:\n self.MSs.append(theano.shared(\n (param.get_value() * 0.) + 1,\n broadcastable=param.broadcastable\n ))\n\n # # NOTE: single scalar\n # if len(self.MSs) < pidx + 1:\n # self.MSs.append(theano.shared(1.))\n\n MS_update = self.MSs[pidx]\n\n grad = T.grad(cost, param, consider_constant=[chain_end])\n\n decay = T.cast(.9, dtype=DTYPES.FLOATX)\n one_minus_decay = T.cast(.1, dtype=DTYPES.FLOATX)\n\n # NOTE: matrix of learning weights\n current_rmsprop = \\\n (decay * MS_update) + \\\n (one_minus_decay * T.sqrt(T.sum(T.sqr(grad))))\n\n # # NOTE: single scalar\n # current_rmsprop = \\\n # (decay * MS_update) + \\\n # (one_minus_decay * T.mean(T.sqr(grad)))\n\n updates[MS_update] = current_rmsprop\n\n learning_rate = .1 / current_rmsprop\n # learning_rate = T.sqrt(\n # T.cast(current_rmsprop, dtype=DTYPES.FLOATX)\n # )\n # if True:\n # learning_rate = theano.printing.Print('lr')(learning_rate)\n\n updates[param] = param - (learning_rate * grad)\n # updates[param] = param - (grad / learning_rate)\n\n # constructs the update dictionary\n for pidx, param in enumerate(self.params):\n # regulared(pidx, param)\n momentumed(pidx, param)\n # rmsproped(pidx, param)\n\n # reconstruction cross-entropy is a better proxy for CD\n monitoring_cost = self.get_reconstruction_cost(\n pre_sigmoid_nvs[-1]\n )\n\n self.monitoring_cost = monitoring_cost\n self.updates = updates\n self.learning_rate = lr","def rk8(accel,m,r,h,v): \n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\n\n\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \n \n return new_v8,new_r8","def weiner_tf(H, K):\r\n\r\n W = (1 / H) * ((np.conjugate(H) * H) / ((np.conjugate(H) * H) + K))\r\n return W","def weighted_current(h,nk=400,fun=None):\n if fun is None:\n delta = 0.01\n def fun(e): return (-np.tanh(e/delta) + 1.0)/2.0\n jgs = np.zeros(h.intra.shape[0]) # current array\n hkgen = h.get_hk_gen() # generator\n fj = current_operator(h) # current operator\n ks = np.linspace(0.0,1.0,nk,endpoint=False) # k-points\n for k in ks: # loop\n hk = hkgen(k) # Hamiltonian\n (es,ws) = lg.eigh(hk) # diagonalize\n ws = ws.transpose() # transpose\n jk = fj(k) # get the generator\n for (e,w) in zip(es,ws): # loop\n weight = fun(e) # weight\n print(weight)\n d = np.conjugate(w)*ket_Aw(jk,w) # current density\n jgs += d.real*weight # add contribution\n# jgs += (np.abs(w)**2*weight).real # add contribution\n jgs /= nk # normalize\n print(\"Total current\",np.sum(jgs))\n np.savetxt(\"CURRENT1D.OUT\",np.matrix([range(len(jgs)),jgs]).T)","def B(self, s, t, n):\n\n if n == 0:\n return 1\n elif min(len(s), len(t)) < n:\n return 0\n if (s[:-1], t, n) in self.B_st.keys():\n B1 = self.B_st[(s[:-1], t, n)]\n else:\n B1 = self.B(s[:-1], t, n)\n #self.B_st[(s[:-1], t, n)] = B1\n if (s, t[:-1], n) in self.B_st.keys():\n B2 = self.B_st[(s, t[:-1], n)]\n else:\n B2 = self.B(s, t[:-1], n)\n #self.B_st[(s, t[:-1], n)] = B2 \n \n if (s[:-1], t[:-1], n) in self.B_st.keys():\n B3 = self.B_st[(s[:-1], t[:-1], n)]\n else:\n B3 = self.B(s[:-1], t[:-1], n)\n #self.B_st[(s[:-1], t[:-1], n)] = B3\n result = self.decay_param * (B1 + B2 - self.decay_param * B3)\n if s[-1] == t[-1]:\n if (s[:-1], t[:-1], n-1) in self.B_st.keys():\n B4 = self.B_st[(s[:-1], t[:-1], n-1)]\n else:\n B4 = self.B(s[:-1], t[:-1], n-1)\n #self.B_st[(s[:-1], t[:-1], n-1)] = B4\n result += (self.decay_param ** 2) * B4\n return result","def assertB(n, k):\n assert 0 <= k <= n\n return (factorial(n)//factorial(k))//factorial(n-k)","def compute_gp_parameters(K, K_star2, K_star, true_values, sigma_n=0.5):\r\n n = K.shape[0]\r\n d = 1 # Dimension\r\n f_bar_star = np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n ** 2) * np.eye(n)), true_values.reshape([n, d]))) #Prediction Function\r\n\r\n cov_f_star = K_star2 - np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n ** 2) * np.eye(n)), K_star.T)) # Covariance Function\r\n\r\n return (f_bar_star, cov_f_star)","def wabbits(n, k):\n a, b = 1, 1\n for i in range(3, n+1):\n a, b = b, a*k + b\n return b","def experiment(improved):\n\n N_list = [5 ,10 ,20]\n K_list = [3 , 7 ,9]\n P_list = [0.3 , 0.4 , 0.5 ,0.6 ,0.7]\n\n data = pandas.read_csv('train.csv')\n\n avg_list = []\n for i in range(0,len(N_list) * len(K_list) * len(P_list)):\n avg_list.append([0 , None])\n\n kf = KFold(n_splits=5, shuffle=True, random_state=209418441)\n rotation_index = 1\n for train_index, test_index in kf.split(data):\n\n train = data.iloc[train_index]\n test = data.iloc[test_index]\n index = 0\n for n in N_list:\n for k in K_list:\n for p in P_list:\n\n #print('testing for N= ',n,', K = ',k, 'P = ',p)\n KNN = forest.KNN_forest(N=n, K=k, P=p, data = train , improved=improved)\n success_rate = utls.tests.succ_rate_test.test(test,KNN.Classify)\n avg_list[index][0] += success_rate\n avg_list[index][1] = (n,k,p)\n #print(' rate is: ',avg_list[index][0]/rotation_index)\n index += 1\n rotation_index +=1\n\n\n\n best_option = max(avg_list,key= lambda x:x[0])\n #print(' ****** DONE ******')\n #print('best n,k,p are : ' , best_option[1] , ' with success rate: ' , best_option[0])\n\n return best_option[1]","def build(self):\n # weights to apply to training samples, updated on each\n # iteration of the boosting algo, normalised to 1\n sigWeights = np.ones(self.nSig, dtype=float)\n bkgWeights = np.ones(self.nBkg, dtype=float)\n reweight = 1.0/(np.sum(sigWeights)+np.sum(bkgWeights))\n sigWeights *= reweight\n bkgWeights *= reweight \n\n # Weight of each tree, strong classifers have higher weight\n self.treeWeights = np.zeros(self.ntrees, dtype=float)\n\n for i in xrange(self.ntrees):\n\n # build new tree\n newTree = Tree()\n newTree.load(self.sigData,self.bkgData,weights=(sigWeights,bkgWeights))\n newTree.build()\n self.dTrees.append(newTree) \n\n # evaluate trees\n # keep track of each event\n err = 0.0\n sigWrong = np.zeros(self.nSig)\n bkgWrong = np.zeros(self.nBkg)\n\n for j in range(self.nSig):\n if newTree.classify(np.array((self.sigData[j,])))<0:\n sigWrong[i]=1\n err+=sigWeights[j]\n\n for j in range(self.nBkg):\n if newTree.classify(np.array((self.bkgData[j,])))>0:\n bkgWrong[i]=1\n err+=bkgWeights[j]\n\n alpha = self.beta*math.log((1.0-err)/err)\n print err,alpha\n corFactor = math.exp(-alpha)\n wrongFactor = math.exp(alpha)\n\n if (err<1e-20 or err >= 0.5):\n print \"SOEMTHING WRONG!!\"\n\n self.treeWeights[i] = alpha\n\n # reweight training samples\n for j in range(self.nSig):\n if sigWrong[j]:\n sigWeights[j]*=wrongFactor\n else :\n sigWeights[j]*=corFactor\n\n for j in range(self.nBkg):\n if bkgWrong[j]:\n bkgWeights[j]*=wrongFactor\n else :\n bkgWeights[j]*=corFactor\n\n # normalise weights\n reweight = 1.0/(np.sum(sigWeights)+np.sum(bkgWeights))\n sigWeights *= reweight\n bkgWeights *= reweight","def policy_evaluation(P, nS, nA, policy, gamma=0.9, tol=1e-8):\n value_function = np.zeros(nS)\n ############################\n # YOUR IMPLEMENTATION HERE #\n def next_state_reward(P,state,action,gamma,value_function):\n sum_reward=0\n for p,nextS,r,boolean_v in P[state][action]:\n sum_reward+=p*( r + gamma* value_function[nextS])\n #print(sum_reward) \n return sum_reward\n\n while True:\n delta=0;\n for state in range(nS):\n new_value=0;\n for action in range(nA):\n sum_reward=next_state_reward(P,state,action,gamma,value_function)\n new_value+=policy[state][action]*sum_reward\n delta= max(delta, abs(new_value-value_function[state]))\n value_function[state] = new_value\n #print(value_function)\n if(delta < tol):\n break\n\n ############################\n return value_function","def dpsearch(points,k):\n\t#M = k\n\tpoints = np.sort(points,axis=0)\n\tL = len(points)\n\tM = k\n\tT = list(np.zeros(M+1,dtype='int'))\n\tT[0] = 0\t#first threshold is by default always set to index 0 in trellis graph.\n\tT[M] = L \t#last threshold is by default always set to last number in input points.\n\ttrellis_value = np.full((M+1,L+1),np.inf)\n\ttrellis_backpointer = np.full((M+1,L+1),np.inf)\n\n\t# Stage 1: m=1\t\n\tfor l in range(1,L-M+2):\n\t\ttrellis_value[1][l] = ((l-0)/float(L))*np.var(points[0:l])\n\t\ttrellis_backpointer[1][l] = 0\n\n\t\n\tif(M>2):\n\t\t# Stage 2: m=2 to m=M-1\n\t\tfor m in range(2,M):\n\t\t\tfor l in range(m,L-M+m+1):\n\t\t\t\t#finding optimal path\n\t\t\t\tJ_min = np.inf\n\t\t\t\tJ_temp = np.inf\n\t\t\t\tfor i in range(m-1,l):\n\t\t\t\t\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\n\t\t\t\t\tif J_temp < J_min:\n\t\t\t\t\t\tJ_min = J_temp\n\t\t\t\t\t\tptr = i\n\t\t\t\t\n\t\t\t\ttrellis_value[m][l],trellis_backpointer[m][l] = J_min,ptr\n\t\t\t\t\n\n\t# Stage 3: m=M\n\tm = M\n\tl = L\n\t#finding optimal path\n\tJ_min = np.inf\n\tJ_temp = np.inf\n\tfor i in range(m-1,l):\n\t\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\n\t\tif J_temp < J_min:\n\t\t\tJ_min = J_temp\n\t\t\tptr = i\n\n\t\n\ttrellis_value[M][L] = J_min\n\ttrellis_backpointer[M][L] = ptr\n\t\n\t\n\t# Backtracking\n\tl = L\n\tm = M\n\twhile m>=2:\n\t\tT[m-1] = int(trellis_backpointer[m][l])\n\t\tl = int(trellis_backpointer[m][l])\n\t\tm = m - 1\n\n\t#Assign cluster labels\n\tlabels = np.full(len(points),0)\n\tj = T[0]\n\tcounter = 0\n\tfor i in range(1,k+1):\n\t\tlabels[j:T[i]] = counter\n\t\tj = T[i]\n\t\tcounter += 1\n\n\n\treturn labels,T","def bisection(self,\n low_bound: float,\n up_bound: float,\n epsilon: float,\n n: int,\n Rmn: dict,\n ytm: dict) -> float:\n for i in range(100):\n y = (low_bound + up_bound) / 2\n if abs(Bootstrapping.f(self,y, n, Rmn, ytm)) < epsilon:\n ym = ytm[list(ytm.keys())[-1]]\n m = list(ytm.keys())[-1]\n for j in range(list(ytm.keys())[-1] + 1, n + 1):\n ytm[j] = ym + (y - ym) * (j - m) / (n - m)\n return ytm\n else:\n if Bootstrapping.f(self,y, n, Rmn, ytm) * Bootstrapping.f(self,up_bound, n, Rmn, ytm) < 0:\n low_bound = y\n elif Bootstrapping.f(self,y, n, Rmn, ytm) * Bootstrapping.f(self,low_bound, n, Rmn, ytm) < 0:\n up_bound = y","def VFI(method) :\n iteration=0 # Iteration Counter\n converged = 0 # Convergence Flag|\n \n#----- Initial Settings \n v_update = zeros(n_grid)\n v_func = empty(n_grid)\n k_next_vec = empty(n_grid)\n run_time = empty(2)\n \n def obj(k_next) :\n \"\"\"\n This function is used in value function iteration.\n It represents the objective function to be maximized for one node (state) of current capitals.\n Resulting value is maximized one corresponding to next period's capital as a maximizer. \n Next period's value is computed by interpolation.\n \n Input : k_next (next period's capital)\n \n Output : value_vec (maximized value resulting from choosing optimal capital in the next period)\n \"\"\" \n \n if method==1 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\n elif method==2 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\n elif method==3 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\n \n return value_vec\n\n#----- Value function iteration\n start = time.time() # start time\n while converged==0 :\n index = 0\n for k_current in k_grid :\n k_next = fminbound(obj,k_grid[0],k_grid[-1])\n v_func[index] = (-1) * obj(k_next)\n k_next_vec[index] = k_next\n index = index + 1\n dist = abs(max(v_func - v_update))\n if dist<tol :\n converged = 1\n v_k, g_k = v_func, k_next_vec\n v_update = v_func\n print \"Iteration : \",iteration,\"\",\"Distance : \",dist # convergence process\n iteration = iteration + 1\n v_func = empty(n_grid) \n k_next_vec = empty(n_grid)\n \n end = time.time() # end time\n run_time[0],run_time[1] = runtime_cal(start,end) # total running time\n \n return v_k, g_k, run_time, iteration","def FigA7(case):\n \n #set the parameter, arrays\n \n n_array=np.array([1,2,3])\n\n #set the result arrays\n if case==0:\n class_number=5\n elif case==1:\n class_number=6\n fate=np.zeros([class_number])#number of evolutionary fate\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\n \n time=np.linspace(0,100000, 1000000)\n loop=10**6\n \"\"\"\n 0 Co and/or Ch cannot survive in mono-culture\n 1 Co cannot invade\n 2 Only equilibrium of exclusion is stable\n 3 Only equilibrium of coexistence is stable\n 4 Two equilibria are UNstable\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\n \"\"\"\n for tri in range(np.size(n_array)):\n counter=0\n n=n_array[tri]\n print(str(\"Hill coefficient is %d\" %(n)))\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\n if case==0 or case==1:\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\n else:\n print(\"Error in case\")\n return 1\n \n for i in range(loop):\n if(i+1)%10000==0:\n print(i+1)\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\n #check whether r is positive or not\n if case==0:\n r1=rmax*(1-cr-cd)#rCO\n r2=rmax#sCH\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\n elif case==1:\n r1=rmax*(1-cd)#sCo\n r2=rmax*(1-cr)#rCh\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\n stab_e=0#initialize the falgs of stability\n stab_c=0\n if W0Co<0 or W0Ch<0:\n fate[0]+=1\n res=0\n else:\n #succeed in mono-culture \n init=np.array([T0,10**(-6)])\n if case==0: \n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\n x2s=solCh[-1,1]\n else:\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\n x2s=solCh[-1,1]\n \n #Evolutionary dynamics \n if case==0:\n K=Kr\n else:\n K=Ks\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\n #Co cannot invade\n fate[1]+=1\n res=1\n else:\n #Co can invade\n #calculate Tdagger Td and check whether coexist or exclude\n if case==0:\n #rCo vs sCh\n #in this case, at most one equilbrium is stable\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\n Td=tau**(1/n)\n if Td<Ts:\n #Co exclude Ch\n fate[2]+=1\n res=2\n else:\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #unstable coexistence nor exclusion\n fate[4]+=1\n res=4\n print(Td, x1d, x2d)\n else:\n #sCo vs rCh\n # in this case two equilibria can be stable at the same time\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\n if tau_m>Ts**n or tau_p<Ts**n:\n # cexclusion is stable\n stab_e=1\n # stability in coexistence \n if tau_p<0:\n stab_c=0\n else:\n Td=tau_p**(1/n)\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n stab_c=1\n #classify\n if stab_e==1 and stab_c==1:\n # two stable equilbria\n fate[5]+=1\n res=5\n elif stab_e==1 and stab_c==0:\n #only stable cexclusion\n fate[2]+=1\n res=2\n elif stab_e==0 and stab_c==1:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #both unstable\n fate[4]+=1\n res=4\n \n #save the results\n if counter==0:\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n #save the result with parameter values\n \n else:\n #add array of results\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n result=np.concatenate((result, R), axis=0)\n counter+=1\n \n #save csv file and graph\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \n print(fate)\n fate_matrix[tri,:]=fate \n if case==0: \n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\n else:\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\n Plot(case)","def find_new_kbl(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n z_u_r = self.grid_dict['z_u_r']\n\n #---> j loop\n for j in range(Ly):\n self.kbl[j] = N #initialize search at top\n\n # in fortran k=N-1,1,-1\n for k in range(N-1,0,-1):\n #INDEX MAP\n k_w = k\n k_r = k-1\n \n for j in range(Ly):\n if z_u_w[j,k_w] > z_u_w[j,N] - self.hbls[j]:\n self.kbl[j] = k_w","def iteration(self):\n T = self.generate_T()\n R = self.reproduce(T)\n self.P = self.choose_mi_best(R)\n #print(self.P)","def fn(n, k):\n if k == 0: return 1 \n if n <= 0 or k < 0: return 0 \n return fn(n-1, k) + fn(n, k-1) - fn(n-1, k-n)","def verhulst(nb_init, t0, tf, eps, methode, gamma, K) :\n f=lambda y,t : gamma*y*(1-y/K)\n Y=meth_epsilon(nb_init, t0, tf, eps, f, methode)\n return Y","def king2(r, n0, rc0, b0, n1, rc1, b1):\n return n0 * (1. + (r/rc0)**2)**b0 + n1 * (1. + (r/rc1)**2)**b1","def fn(n, k):\n if n <= k: return 0 # one mailbox for each house\n if k == 1: return mdist[0][n-1]\n ans = inf \n for nn in range(k-1, n): \n ans = min(ans, fn(nn, k-1) + mdist[nn][n-1])\n return ans","def decision_heatmaps(obs):\n global model\n assert obs > 4 and obs < 1788, \"Chosen observation is outside the range of the demonstration episode.\"\n saved_observations = np.load('saved_observations.npy')\n state = saved_observations[obs-3:obs+1]\n state_batch = np.expand_dims(state, axis=0)\n q_vals = model.compute_q_values(state)\n print(q_vals)\n decision = np.argmax(q_vals)\n print(decision)\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\n decision_node = model.model.output[:, decision]\n last_conv_layer = model.model.layers[3]\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\n pooled_grads = K.mean(grads, axis=(0,2,3))\n frame = Image.fromarray(state[-1])\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\n for i in range(64):\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\n\n heatmap = np.mean(conv_layer_output_value, axis=0)\n heatmap = np.maximum(heatmap, 0)\n heatmap /= np.max(heatmap)\n heatmap = cv2.resize(heatmap, (84, 84))\n heatmap = np.uint8(255 * heatmap)\n superimposed_img = heatmap * .3 + np.array(frame) * .35\n\n plt.xlabel(decision_encodings[decision])\n plt.imshow(superimposed_img, cmap='gray')\n plt.show()","def grid_search(self):\n\t\tchoice_apply_BN = [False] if self.debug else [False] # True, False\n\t\tchoice_apply_RD = [False] if self.debug else [False] # True, False\n\n\t\tchoice_layers = [3] if self.debug else [3] # 1, 2, 3, 4\n\t\tchoice_hd_hn_af = ['S'] if self.debug else ['R'] # 'R6' | 'RK' | 'S' activation function w.r.t. head hidden layers\n\t\tchoice_tl_af = ['S'] if self.debug else ['R'] # activation function for the last layer, sigmoid is suggested due to zero-prediction\n\t\tchoice_hd_hn_tl_af = None\n\n\t\tchoice_apply_tl_af = [True] # True, False\n\n\t\tif choice_hd_hn_tl_af is not None:\n\t\t\tfor BN, RD, num_layers, af, apply_tl_af in product(choice_apply_BN, choice_apply_RD, choice_layers,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t choice_hd_hn_tl_af, choice_apply_tl_af):\n\t\t\t\tffnns_para_dict = dict(FBN=False, BN=BN, RD=RD, num_layers=num_layers, HD_AF=af, HN_AF=af, TL_AF=af,\n\t\t\t\t\t\t\t\t\t apply_tl_af=apply_tl_af)\n\t\t\t\tsf_para_dict = dict()\n\t\t\t\tsf_para_dict['id'] = 'ffnns'\n\t\t\t\tsf_para_dict['ffnns'] = ffnns_para_dict\n\n\t\t\t\tself.sf_para_dict = sf_para_dict\n\t\t\t\tyield sf_para_dict\n\t\telse:\n\t\t\tfor BN, RD, num_layers, hd_hn_af, tl_af, apply_tl_af in product(choice_apply_BN, choice_apply_RD,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tchoice_layers, choice_hd_hn_af,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tchoice_tl_af, choice_apply_tl_af):\n\t\t\t\tffnns_para_dict = dict(FBN=False, BN=BN, RD=RD, num_layers=num_layers, HD_AF=hd_hn_af, HN_AF=hd_hn_af,\n\t\t\t\t\t\t\t\t\t TL_AF=tl_af, apply_tl_af=apply_tl_af)\n\t\t\t\tsf_para_dict = dict()\n\t\t\t\tsf_para_dict['id'] = 'ffnns'\n\t\t\t\tsf_para_dict['ffnns'] = ffnns_para_dict\n\n\t\t\t\tself.sf_para_dict = sf_para_dict\n\t\t\t\tyield sf_para_dict","def fn(n, k):\n if n == k: return 1\n if k == 0: return 0\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007","def prediction_aggregation(self, xt_s,mu_s,var_s, method='PoE', weighting='uniform', power=26):\n\n nt = xt_s.shape[0]\n mu = np.zeros([nt, self.C],dtype='float64')\n var = np.zeros([nt, self.C],dtype='float64')\n\n prior_var = self.experts[0].kernel(xt_s[0], xt_s[0])\n\n \n #Process each latent gp individually \n for j in range(self.C):\n \n mu_s_c = mu_s[:, :, j]\n var_s_c = var_s[:, :, j]\n \n weight_matrix = compute_weights(mu_s_c, var_s_c, power, weighting, prior_var)\n \n prec_s= 1/var_s_c\n\n if method == 'PoE':\n \n prec = tf.reduce_sum(prec_s, axis=0)\n \n\n if method == 'gPoE':\n \n weight_matrix = normalize_weights(weight_matrix)\n\n prec = tf.reduce_sum(weight_matrix * prec_s , axis=0)\n \n\n if method == 'BCM':\n \n prec = tf.reduce_sum(prec_s, axis=0) + (1 - self.M) / prior_var \n\n if method == 'rBCM':\n \n \n prec = tf.reduce_sum(weight_matrix * prec_s, axis=0) \\\n + (1 - tf.reduce_sum(weight_matrix, axis=0)) / prior_var\n \n \n \n if method != 'bar':\n \n var[:, j] = 1 / prec\n\n mu[:, j] = var[:, j] * tf.reduce_sum(weight_matrix * prec_s * mu_s_c, axis=0)\n \n else:\n \n weight_matrix = normalize_weights(weight_matrix)\n\n mu[:, j] = tf.reduce_sum(weight_matrix * mu_s_c, axis=0)\n var[:, j] = tf.reduce_sum(weight_matrix * var_s_c, axis=0)\n \n \n return self.lik_aggregation(mu, var)","def ACM_Kruskal(G):\n pass","def rk_step(fun, t, y, f, h, A, B, C, K):\n \n K[0] = f\n for s, (a, c) in enumerate(zip(A[1:], C[1:]), start=1):\n dy = np.dot(K[:s].T, a[:s]) * h\n K[s] = fun(t + c * h, y + dy)\n\n y_new = y + h * np.dot(K[:-1].T, B)\n f_new = fun(t + h, y_new)\n\n K[-1] = f_new\n\n return y_new, f_new","def _KF_gain(self, state_pred, covar_pred, sigma_points_pred, weights_c,\n z_pred, z_points_pred, R):\n diff_z = z_points_pred - z_pred[:, None, :]\n diff_z = tf.cast(diff_z, tf.float64)\n diff_z = tf.reshape(diff_z, [-1, self.dim_z])\n diff_z = self.context.correct_observation_diff(diff_z)\n diff_z = tf.reshape(diff_z,\n [self.batch_size, self.num_sigma, self.dim_z])\n diff_square = tf.matmul(diff_z[:, :, :, None], diff_z[:, :, None, :])\n S = tf.multiply(diff_square, tf.cast(weights_c[:, :, :, None],\n tf.float64))\n S = tf.cast(tf.reduce_sum(S, axis=1), tf.float32) + R\n S = self._make_valid(S)\n\n diff_state = sigma_points_pred - state_pred[:, None, :]\n diff_state = tf.reshape(diff_state, [-1, self.dim_x])\n diff_state = self.context.correct_state(diff_state)\n diff_state = tf.reshape(diff_state,\n [self.batch_size, self.num_sigma, self.dim_x])\n z_state = tf.matmul(tf.cast(diff_state[:, :, :, None], tf.float64),\n diff_z[:, :, None, :])\n z_state_covar = \\\n tf.reduce_sum(tf.multiply(z_state,\n tf.cast(weights_c[:, :, :, None],\n tf.float64)), axis=1)\n z_state_covar = tf.cast(z_state_covar, tf.float32)\n\n K = tf.matmul(z_state_covar, tf.linalg.inv(S))\n return K","def past_weight_grad_calculator2(xs, es, kp_x, kd_x, kp_e, kd_e, shapes):\n kp_x, kd_x, kp_e, kd_e = [as_floatx(k) for k in (kp_x, kd_x, kp_e, kd_e)]\n n_samples, n_in, n_out = shapes\n rx = kd_x/(kp_x+kd_x)\n re = kd_e/(kp_e+kd_e)\n\n xr = create_shared_variable(np.zeros((n_samples, n_in)))\n er = create_shared_variable(np.zeros((n_samples, n_out)))\n\n\n\n\n # xr_new = xr*rx + xs/(kp_x+kd_x)\n # er_new = er*re + es/(kp_e+kd_e)\n\n arr = rx*re/(1-rx*re)\n\n xr_new = xr*arr + xs/(kp_x+kd_x)\n er_new = er*arr + es/(kp_e+kd_e)\n\n xsum = create_shared_variable(np.zeros((n_samples, n_in)))\n esum = create_shared_variable(np.zeros((n_samples, n_out)))\n\n xsum_new = xsum+xr_new\n esum_new = esum+er_new\n\n x_nospikes = tt.eq(xs, 0)\n e_nospikes = tt.eq(es, 0)\n\n dw = xs.T.dot(esum_new) + xsum_new.T.dot(es)\n\n add_update(xr, xr_new)\n add_update(er, er_new)\n add_update(xsum, xsum_new*x_nospikes)\n add_update(esum, esum_new*e_nospikes)\n\n return xs.T.dot(er) + xr.T.dot(es)\n # return xr.T.dot(er)\n # return dw","def generateKNNobj():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n #tdata=b[:,8:28].copy()\n # indx with only M22 without zero order\n m22idx = np.concatenate((np.arange(29,48),np.arange(49,68)))\n tdata=b[:,m22idx].copy()\n #tdata=b[:,9:28].copy() # remove the zero order zernike, i.e. remove the mean of the M20\n #-standardize the data. use this information in future validation data too.\n tmean = tdata.mean(axis=0)\n tstd = tdata.std(axis=0)\n tdata = (tdata - tmean)/tstd\n ttpara=b[:,0:5].copy()\n tpara = b[:,0:5].copy()\n tpara[:,3] = ttpara[:,3]*np.cos(np.deg2rad(ttpara[:,4]))\n tpara[:,4] = ttpara[:,3]*np.sin(np.deg2rad(ttpara[:,4]))\n knn = nb.KNeighborsRegressor(algorithm='ball_tree',n_neighbors=15)\n knn.fit(tdata,tpara)\n p.dump(knn,open('finerGridKnnObj_M22_remMean.cp','w'),2)\n p.dump([tmean,tstd],open('finerGridStdConst_M22_remMean.cp','w'),2)\n #np.savetxt('finerGridStdConst.txt',np.array([tmean,tstd]),fmt='%f10.5',delimiter = ',')\n return 'It is done !'","def OutOfSampleExtension(self, P, k = 3):\n \n n_obs = P.shape[0]\n knn = []\n for obs in range(n_obs):\n x_obs = P[obs]\n # get nearest neighbors\n dist = pairwise_distances(np.vstack([self.X, x_obs]))\n knn_aux = np.argsort(dist[self.n:,:], axis = 1)[:, 1 : k + 1]\n knn.append(knn_aux[0]) \n knn = np.array(knn)\n # compute weights\n \n W = [] # Initialize nxn weight matrix\n for i in range(n_obs):\n x_i = P[i]\n G = [] # Local covariance matrix\n for j in range(k):\n x_j = self.X[knn[i][j]]\n G_aux = []\n for k_2 in range(k):\n x_k = self.X[knn[i][k_2]]\n gjk = np.dot((x_i - x_j), (x_i - x_k))\n G_aux.append(gjk)\n G.append(G_aux)\n G = np.array(G)\n G = G + self.reg*np.eye(*G.shape) # Regularization for G\n w = np.linalg.solve(G, np.ones((k))) # Calculate weights for x_i\n w = w / w.sum() # Normalize weights; sum(w)=1\n \n if self.verbose and i % 3 == 0:\n print('[INFO] Weights calculated for {} observations'.format(i + 1))\n \n W.append(w)\n \n W = np.array(W)\n y = []\n for i in range(n_obs):\n y_aux = W[i] @ self.Y[knn[i]]\n y.append(y_aux)\n y = np.array(y)\n return y","def initial_estimator(f, x, step,k):\n\n fx = f(x)\n\n if decide(fx > 0):\n sign1 = 1\n else:\n sign1 = -1\n k_step = k\n h = fx / derivative(f, x)\n\n for k1 in range(1, 50000):\n step = step + 1\n x_new = x - k_step * h\n k_step = k_step * 2 # make the k double in each iteration\n fx_new = f(x_new)\n if decide(fx_new > 0):\n sign2 = 1\n else:\n sign2 = -1\n\n if not (sign1 == sign2):\n return x_new, step\n\n print(\"limit need to Increase\")","def test_tpr_fwer_alex(self, syn_genomic_data, syn_labels, syn_labels_0based, syn_labels_cat, syn_fm, syn_idx, rep, syn_true_pvalues):\n\n window_length = 35\n best_params_montaez['n_snps'] = n_total_snps\n\n def combi_compute_pvalues(d, x, fm, l,filter_window_size,pf,ps,k):\n\n idx, pvalues, raw_weights = combi_method(d, x,fm, l,filter_window_size,pf,ps,k)\n pvalues_filled = np.ones(n_total_snps)\n pvalues_filled[idx] = pvalues\n raw_weights = postprocess_weights_without_avg(raw_weights, p_svm)\n\t\t\t\n # Map the raw weights to look like p-values between 0 and 1 (reverse order)\t\t\n # Figure out how 'wide' range is\n leftSpan = np.max(raw_weights) - np.min(raw_weights)\n\n # Convert the left range into a 0-1 range (float)\n valueScaled = (raw_weights - np.min(raw_weights)) / leftSpan\n\n # Reverse order\n raw_weights = 1 - valueScaled\t\n\t\t\t\n del d, l\n return pvalues_filled, raw_weights\n\n def challenger_compute_pvalues(d, x, l_0b, l, idx):\n is_only_zeros = False\n with tensorflow.Session().as_default():\n\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(l_0b[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n model.fit(x=x[idx.train], y=l_0b[idx.train], validation_data=(x[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'],class_weight=d_class_weights, callbacks=[ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),])\n\n model = iutils.keras.graph.model_wo_softmax(model)\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\n weights = analyzer.analyze(x).sum(0)\n\n if np.max(abs(weights)) < 0.005:\n fig, axes = plt.subplots(1)\n is_only_zeros = True\n axes.plot(np.absolute(weights).sum(axis=1))\n fig.savefig(os.path.join(IMG_DIR, 'test.png'))\n\n top_indices_sorted, _ = postprocess_weights(weights, top_k, window_length, p_svm, p_pnorm_filter)\n rawlrp_scores_now = postprocess_weights_without_avg(weights,p_svm)\n\t\t\t\t\n # Map the raw weights to look like p-values between 0 and 1 (reverse order)\t\t\n # Figure out how 'wide' range is\n leftSpan = np.max(rawlrp_scores_now) - np.min(rawlrp_scores_now)\n\n # Convert the left range into a 0-1 range (float)\n valueScaled = (rawlrp_scores_now - np.min(rawlrp_scores_now)) / leftSpan\n\n # Reverse order\n rawlrp_scores_now = 1 - valueScaled\t\t\t\t\t\n\t\t\t\t\n pvalues = chi_square(d[:, top_indices_sorted], l)\n pvalues_filled = np.ones(n_total_snps)\n pvalues_filled[top_indices_sorted] = pvalues\n del d, x, l\n\n return pvalues_filled, is_only_zeros, rawlrp_scores_now\n\n fm_2d = syn_fm(\"2d\")\n fm_3d = syn_fm(\"3d\")\n\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\n\n bla = Parallel(n_jobs=-1, require='sharedmem')(delayed(combi_compute_pvalues)(clf, syn_genomic_data[str(i)][:], fm_2d[str(i)][:], syn_labels[str(i)], 35, 2, 2, 30) for i in tqdm(range(rep)))\n raw_svmweights_per_run_combi = np.array(list(np.array(bla)[:, 1]))\n pvalues_per_run_combi = np.array(list(np.array(bla)[:, 0]))\n\n pvalues_per_run_rpvt = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(chi_square)(syn_genomic_data[str(i)][:], syn_labels[str(i)]) for i in tqdm(range(rep))))\n\n # len(thresholds) * len(window_sizes) * 10020\n abl = Parallel(n_jobs=-1, require='sharedmem')(delayed(challenger_compute_pvalues)(syn_genomic_data[str(i)][:], fm_3d[str(i)][:], syn_labels_cat[str(i)], syn_labels[str(i)], syn_idx[str(i)]) for i in tqdm(range(rep)))\n\n # Collect results\n pvalues_per_run_dense = np.array(list(np.array(abl)[:, 0]))\n rawlrp_scores_per_run_dense = np.array(list(np.array(abl)[:, 2]))\n \n # INNvestigate bugfix\n zeros_index = np.array(list(np.array(abl)[:, 1])) \n pvalues_per_run_combi = pvalues_per_run_combi[np.logical_not(zeros_index)]\n raw_svmweights_per_run_combi = raw_svmweights_per_run_combi[np.logical_not(zeros_index)]\n pvalues_per_run_dense = pvalues_per_run_dense[np.logical_not(zeros_index)]\n rawlrp_scores_per_run_dense = rawlrp_scores_per_run_dense[np.logical_not(zeros_index)]\n pvalues_per_run_rpvt = pvalues_per_run_rpvt[np.logical_not(zeros_index)]\n true_pvalues = syn_true_pvalues[np.logical_not(zeros_index)]\n\n # COMBI\n res_combi = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_combi, true_pvalues, threshold) for threshold in tqdm(thresholds)))\n tpr_combi, _, fwer_combi, precision_combi = res_combi.T\n\n # SVM weights\n res_rawsvm = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(raw_svmweights_per_run_combi, true_pvalues, threshold) for threshold in tqdm(thresholds)))\n tpr_rawsvm, _, fwer_rawsvm, precision_rawsvm = res_rawsvm.T\n\n # RPVT\n res_rpvt = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_rpvt, true_pvalues, threshold) for threshold in tqdm(thresholds)))\n\t\t\n tpr_rpvt, _, fwer_rpvt, precision_rpvt = res_rpvt.T\n\n # Plot\n fig, axes = plt.subplots(1,2)\n\n fig.set_size_inches(15, 9)\n ax1, ax2 = axes\n\n ax1.set_ylim(0, 0.7)\n ax1.set_xlim(0, 0.3)\n ax1.set_ylabel('True positive rate', fontsize=14)\n ax1.set_xlabel('Family-wise error rate', fontsize=14)\n ax2.set_ylabel('Precision', fontsize=14)\n ax2.set_xlabel('True positive rate', fontsize=14)\n\n # CURVES must stop somewhere\n tpr_rpvt_new = tpr_rpvt[tpr_rpvt < 1]\n fwer_rpvt = fwer_rpvt[tpr_rpvt < 1]\n precision_rpvt = precision_rpvt[tpr_rpvt < 1]\n tpr_rpvt = tpr_rpvt_new\n\n tpr_combi_new = tpr_combi[tpr_combi < 1]\n fwer_combi = fwer_combi[tpr_combi < 1]\n precision_combi = precision_combi[tpr_combi < 1]\t\n tpr_combi = tpr_combi_new\n\n tpr_rawsvm_new = tpr_rawsvm[tpr_rawsvm < 1]\n fwer_rawsvm = fwer_rawsvm[tpr_rawsvm < 1]\n precision_rawsvm = precision_rawsvm[tpr_rawsvm < 1]\n tpr_rawsvm = tpr_rawsvm_new\n\t\t\n # RPVT\n ax1.plot(fwer_rpvt, tpr_rpvt, label='RPVT', color='lightsteelblue', linewidth=2)\n ax2.plot(tpr_rpvt, precision_rpvt, color='lightsteelblue', label='RPVT', linewidth=2)\n\n # COMBI \n ax1.plot(fwer_combi, tpr_combi, color='darkblue', label='COMBI', linewidth=2)\n ax2.plot(tpr_combi, precision_combi, color='darkblue', label='COMBI', linewidth=2)\n \n # raw SVM weights\n ax1.plot(fwer_rawsvm, tpr_rawsvm, linestyle='--', color='darkblue', label='SVM weights', linewidth=2)\n ax2.plot(tpr_rawsvm, precision_rawsvm, linestyle='--', color='darkblue', label='SVM weights', linewidth=2)\n\n # DeepCOMBI + LRP scores\n res_dense = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_dense, true_pvalues, threshold) for threshold in tqdm(thresholds)))\n res_rawlrp_dense = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(rawlrp_scores_per_run_dense, true_pvalues, threshold) for threshold in tqdm(thresholds)))\n\n tpr_dense, _, fwer_dense, precision_dense = res_dense.T\n tpr_rawlrp_dense, _, fwer_rawlrp_dense, precision_rawlrp_dense = res_rawlrp_dense.T\n\n assert fwer_combi.max() <= 1 and fwer_combi.min() >= 0\n tpr_dense_new = tpr_dense[tpr_dense < 1]\n fwer_dense = fwer_dense[tpr_dense < 1]\n precision_dense = precision_dense[tpr_dense < 1]\n tpr_dense = tpr_dense_new\n\n tpr_rawlrp_dense_new = tpr_rawlrp_dense[tpr_rawlrp_dense < 1]\n fwer_rawlrp_dense = fwer_rawlrp_dense[tpr_rawlrp_dense < 1]\n precision_rawlrp_dense = precision_rawlrp_dense[tpr_rawlrp_dense < 1]\n tpr_rawlrp_dense = tpr_rawlrp_dense_new\n\n # DeepCOMBI\n ax1.plot(fwer_dense, tpr_dense, color='fuchsia', label='DeepCOMBI', linewidth=3)\n ax2.plot(tpr_dense, precision_dense, color='fuchsia', label='DeepCOMBI', linewidth=3)\n\n # LRP scores\n ax1.plot(fwer_rawlrp_dense, tpr_rawlrp_dense, color='fuchsia', linestyle='--', label='LRP scores', linewidth=2)\n ax2.plot(tpr_rawlrp_dense, precision_rawlrp_dense, color='fuchsia', linestyle='--', label='LRP scores', linewidth=2)\n\n ax1.legend(fontsize=14,loc= 'lower right')\n ax2.legend(fontsize=14, loc= 'lower right')\n fig.savefig(os.path.join(IMG_DIR, 'tpr_fwer_montaez_final1000_NAR.png'), bbox_inches='tight', dpi=300)\n print(np.sum(zeros_index))\n pdb.set_trace()\n\n # CURVES must stop somewhere\n #combi_fp = combi_fp[combi_fp < 80]\n #combi_tp = combi_tp[:len(combi_fp)]\n #deepcombi_fp = deepcombi_fp[deepcombi_fp < 80]\n #deepcombi_tp = deepcombi_tp[:len(deepcombi_fp)]","def eg_sk():\n\n rxs = []\n a = []\n b = []\n c = []\n d = []\n e = []\n f = []\n g = []\n h = []\n i = []\n j = []\n\n for _ in range(1000):\n a.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n b.append(utils.gaussian(10.1, 1))\n\n for _ in range(1000):\n c.append(utils.gaussian(20, 1))\n\n for _ in range(1000):\n d.append(utils.gaussian(30, 1))\n\n for _ in range(1000):\n e.append(utils.gaussian(30.1, 1))\n\n for _ in range(1000):\n f.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n g.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n h.append(utils.gaussian(40, 1))\n\n for _ in range(1000):\n i.append(utils.gaussian(40, 3))\n\n for _ in range(1000):\n j.append(utils.gaussian(10, 1))\n\n for k, v in enumerate([a, b, c, d, e, f, g, h, i, j]):\n rxs.append(creation.RX(v, \"rx{}\".format(k)))\n\n for rx in stats.tiles(stats.scottKnot(rxs)):\n print(\"\", rx[\"rank\"], rx[\"name\"], rx[\"show\"], sep=\"\\t\")","def falling(n, k):\n total, i = 1, 0\n if k==0: \n \treturn 1\n else: \n \twhile i < k: \n \t\ttotal = total * n \n \t\tn = n-1\n \t\ti = i+1\n \treturn total","def main(N,N_p,T,lb,ub,prob,N_vars,F_min,F_const,P_c_min,P_c_max):\n\n lb,ub,f,fu,D,U,P = initDE(N_p,lb,ub,prob)\n if N_p < 4:\n raise Exception(\"Sorry, there must be atleast a population of 4. Reccomended 20\")\n for t in np.arange(T):\n for i in np.arange(N_p):\n V = mutation(i,N_p,t,T,P,N_vars,F_min,F_const)\n\n U=crossover(f,P_c_min,P_c_max,i,D,V,P,U)\n\n for j in np.arange(N_p): \n N,f,P = boundgreed(N,j,U,P,f,fu,ub,lb,prob)\n\t\n\t\t#if N == 500:\n\t\t\t#break\n best_of_f= min(f)\n globopt = P[f.argmin()]\n return N,best_of_f, globopt[:N_vars]","def valueIteration(P,R,gamma,theta,initial_v,max_iter=1e8):\n print('Running value iteration ...')\n\n def one_step_lookahead(s, V):\n \"\"\"\n :param state: current state\n :param v: current value estimator\n :return: A, list of optimal action values under current value estimator\n \"\"\"\n num_a = num_actions\n num_S = num_states\n\n A = np.zeros(num_a)\n\n for a in range(num_a):\n for s_prime in range(num_S):\n A[a] += P[s, a, s_prime] * (R[s, a, s_prime] + gamma * V[s_prime])\n return A\n \n # initialization\n v = initial_v \n num_states, num_actions = P.shape[:2]\n k = 0 \n best_actions = [0] * num_states\n delta = 1000\n\n while delta > theta and k <= max_iter:\n delta = 0\n k += 1\n for s in range(num_states):\n action_values = one_step_lookahead(s, v)\n best_action_value = np.max(action_values)\n delta = max(delta, np.abs(best_action_value - v[s]))\n v[s] = best_action_value\n print(delta)\n\n for s in range(num_states):\n A = one_step_lookahead(s, v)\n best_actions[s] = np.argmax(A)\n\n\n print('number of iterations:', k)\n return best_actions, v","def determine_offer_tuple_NN(nn, ti, ca, eps, eps_ran, revenues, A, arrival_probabilities, preference_weights, no_purchase_preference):\n\n\n # opportunity costs\n opp_costs = 1.0*np.zeros_like(revenues)\n for pro in products:\n if functools.reduce(operator.or_, ca - A[:, pro] < 0):\n # set opp costs to infty if not enough capacity for product\n opp_costs[pro] = np.inf\n else:\n # calculate opportunity costs via Bellman: V(t+1, c) - V(t+1, c-A[i])\n t_df = pd.DataFrame([np.zeros(T + 1)] * 1)\n t_df.columns = [\"t\" + str(i) for i in t_df.columns]\n t_df.iloc[0, ti+1] = 1\n\n cs_unsold = {}\n for h in resources:\n c_df = pd.DataFrame([np.zeros(T +1)] * 1)\n c_df.columns = [\"c-h\" + str(h) + \"-t\" + str(i) for i in c_df.columns]\n c_df.iloc[0, ti+1] = ca[h]\n cs_unsold[h] = c_df\n\n cs_sold = {}\n for h in resources:\n c_df = pd.DataFrame([np.zeros(T + 1)] * 1)\n c_df.columns = [\"c-h\" + str(h) + \"-t\" + str(i) for i in c_df.columns]\n c_df.iloc[0, ti + 1] = ca[h] - A[h, pro]\n cs_sold[h] = c_df\n\n X_unsold = pd.concat([t_df, *[cs_unsold[h] for h in resources]], axis=1)\n X_sold = pd.concat([t_df, *[cs_sold[h] for h in resources]], axis=1)\n\n opp_costs[pro] = nn.predict(X_unsold) - nn.predict(X_sold)\n\n # epsilon greedy strategy - offer no products\n if eps_ran < eps / 2:\n return tuple(np.zeros_like(revenues))\n\n # epsilon greedy strategy - offer all products\n if eps_ran < eps:\n offer_tuple = np.ones_like(revenues)\n offer_tuple[opp_costs == np.inf] = 0 # one resource not available => don't offer product\n return tuple(offer_tuple)\n\n # setup\n offer_tuple = np.zeros_like(revenues)\n\n # line 1\n s_prime = revenues - opp_costs > 0\n if all(np.invert(s_prime)):\n return tuple(offer_tuple)\n\n # line 2-3\n # offer_sets_to_test has in each row an offer set, we want to test\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\n offer_sets_to_test += offer_tuple\n offer_sets_to_test = (offer_sets_to_test > 0)\n\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\n arrival_probabilities, preference_weights, no_purchase_preference)\n\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1\n s_prime = s_prime & offer_tuple == 0\n v_s = np.amax(value_marginal)\n\n # line 4\n while True:\n # 4a\n # offer_sets_to_test has in each row an offer set, we want to test\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\n offer_sets_to_test += offer_tuple\n offer_sets_to_test = (offer_sets_to_test > 0)\n\n # 4b\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\n arrival_probabilities, preference_weights, no_purchase_preference)\n\n if np.amax(value_marginal) >= v_s:\n v_s = np.amax(value_marginal)\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1 # to get 1 for product offered\n s_prime = (s_prime - offer_tuple) == 1 # only those products remain, that are neither in the offer_tuple\n if all(offer_tuple == 1):\n break\n else:\n break\n return tuple(offer_tuple)","def _update_samples_weight(self):\n m, n = 0, self.u.shape[0]\n T = self.u.shape[1]\n N = n + T\n d_0 = matrix(self.d_0.reshape(n, 1))\n\n # Linear Inequallity Constraints, Gx <= h\n G = matrix(-1 * np.eye(N))\n h = matrix(np.zeros(shape=(N, 1)))\n\n # Linear Equality Constraints, Ax = b\n A = matrix(np.concatenate((np.ones(shape=(T, 1)), np.zeros(shape=(n, 1))), axis=0).T)\n b = matrix(1.0)\n\n def F(x=None, z=None):\n if x is None: return 0, matrix(0.5, (N, 1))\n w = x[:T, :]\n phi = x[T:, :]\n reg_inv = 1 / self.reg\n\n weighted_u = np.dot(self.u, w) # n x 1\n scores = -1 * reg_inv * (weighted_u + phi) # n x 1\n\n # Numeric correction\n scores -= max(scores)\n\n # Auxilliaries\n weighted_scores_exp = np.multiply(d_0, np.exp(scores))\n sum_weighted_scores_exp = np.sum(weighted_scores_exp)\n sum_weighted_scores_exp_square = sum_weighted_scores_exp ** 2\n squared_weighted_scores_exp = np.square(weighted_scores_exp)\n weighted_scores_exp_mults = np.dot(weighted_scores_exp, weighted_scores_exp.T)\n uw_mult = np.multiply(self.u, weighted_scores_exp)\n uw_mult_sum = np.sum(np.multiply(self.u, weighted_scores_exp), axis=0)\n\n f = self.reg * np.log(sum_weighted_scores_exp) + self.kappa * np.sum(phi) # f(x)\n\n dfdw = -1 * uw_mult_sum.T / sum_weighted_scores_exp\n dfdphi = (-1 * weighted_scores_exp / sum_weighted_scores_exp) + self.kappa\n Df = np.concatenate((dfdw, dfdphi), axis=0) # Gradient\n\n mf = matrix(f)\n mDf = matrix(Df.T)\n if z is None:\n return mf, mDf\n # Assumes d_0 is uniform\n H = np.zeros(shape=(N, N)) # Hessian\n dfdwiwi = np.zeros(shape=(T, 1))\n dfdphiiphij = -1 * reg_inv * (np.tril(weighted_scores_exp_mults)) / sum_weighted_scores_exp_square\n dfdphiiphii = reg_inv * (np.multiply(weighted_scores_exp,\n sum_weighted_scores_exp - weighted_scores_exp) / sum_weighted_scores_exp_square)\n # dfdwiwj, dfwiphij are zeros\n dfdphiiwj = reg_inv * ((\n uw_mult * sum_weighted_scores_exp - weighted_scores_exp * uw_mult_sum) / sum_weighted_scores_exp_square)\n\n H[T:, T:] = dfdphiiphij\n H[T:, :T] = dfdphiiwj\n H_diagonal = np.concatenate((dfdwiwi, dfdphiiphii), axis=0)\n np.fill_diagonal(H, H_diagonal)\n\n mH = matrix(z[0] * H)\n return mf, mDf, mH\n\n prev_w = self.w\n prev_slacks = self.slacks\n try:\n wphi = solvers.cp(F, G=G, h=h, A=A, b=b)['x']\n self.w = wphi[:T, :]\n self.slacks = wphi[T:, :]\n except Exception as e: # Catch rank errors and continue to next iteration\n self.slacks = prev_slacks\n self.w = prev_w\n try:\n self.w = np.concatenate((self.w, [[1 / (len(self.w) + 1)]]), axis=0)\n except:\n self.w = np.concatenate((self.w, [1 / (len(self.w) + 1)]), axis=0)\n self.w /= np.sum(self.w)\n\n scores = ((-1 / self.reg) * np.squeeze(np.asarray(np.dot(self.u, self.w) + self.slacks))) + np.log(\n self.d_0) # Update according to Equation (6)\n return self.softmax(scores)","def beam_search(X, u, w, b, relLabels):\n\n candidate_paths = [[] for _ in range(10)] # contains the candidate label sets\n candidate_vals =[[] for _ in range(10)] # contains the label values (-1/1) for each candidate set\n candidate_scores = [0. for _ in range(10)]\n min_score = -1000\n\n iter = 0\n start = 0\n while True:\n # print(\"Iter: \", iter)\n intermediate_paths = {}\n # intermediate_paths_val = []\n interim_scores = []\n hash_table = {}\n\n cnt_paths = 0\n for cp in range(5):\n labels_curr = candidate_paths[cp]\n labels_val_curr = candidate_vals[cp]\n scores_curr = candidate_scores[cp]\n Y = -np.ones((10, 1))\n for lv in range(len(labels_val_curr)):\n Y[labels_curr[lv]] = labels_val_curr[lv]\n\n for l in range(10):\n candidate_interim = labels_curr[:]\n candidate_vals_interim = labels_val_curr[:]\n # if l in labels_curr:\n # continue\n\n temp_relLabels = []\n for lc in range(len(labels_curr)):\n temp_relLabels.extend(relLabels[labels_curr[lc]])\n\n # temp_relLabels = np.array(list(set(temp_relLabels)))\n temp_relLabels = np.array(list(set(relLabels[l]).intersection(set(labels_curr))))\n model_pos = returnModelVal(X, Y, 1.0, u[l], u[l], b[l][0], np.array(temp_relLabels))\n candidate_interim.append(l)\n\n if model_pos < 0:\n # print('hello')\n candidate_vals_interim.append(-1)\n interim_scores.append(-model_pos)\n else:\n candidate_vals_interim.append(1)\n interim_scores.append(model_pos)\n\n hash_table[cnt_paths] = candidate_interim\n intermediate_paths[cnt_paths] = candidate_vals_interim\n cnt_paths += 1\n # For the first iteration, just iterate once - all labels in one iteration\n if start == 0:\n start = 1\n break\n\n temp_paths = intermediate_paths\n interim_zip = zip(intermediate_paths, interim_scores)\n sorted_scores = sorted(interim_zip, key=lambda x: x[1], reverse=True)[:5]\n intermediate_paths, scores = zip(*sorted_scores)\n\n temp_cand = []\n temp_val = []\n for i in range(len(intermediate_paths)):\n temp_cand.append(hash_table[intermediate_paths[i]])\n temp_val.append(temp_paths[intermediate_paths[i]])\n # candidate_scores[i] += scores[i]\n\n candidate_paths = temp_cand\n candidate_vals = temp_val\n print(candidate_paths)\n print(candidate_vals)\n # print(scores)\n # candidate_scores = scores\n\n # Exit condition from loop\n # if max(interim_scores) < min_score:\n # break\n #\n # min_score = min(interim_scores)\n\n iter += 1\n if iter > 5:\n break\n\n candidate_dict = {}\n for i in range(5):\n for c in range(len(candidate_paths[i])):\n if candidate_paths[i][c] not in candidate_dict:\n candidate_dict[candidate_paths[i][c]] = candidate_vals[i][c]\n elif candidate_dict[candidate_paths[i][c]] != 2:\n if candidate_dict[candidate_paths[i][c]] != candidate_vals[i][c]:\n candidate_dict[candidate_paths[i][c]] = 2.\n\n print(candidate_dict)\n exit()\n return candidate_dict","def get_wm_ws_Gx_bot(self):\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \n z_u_r = self.grid_dict['z_u_r']\n z_u_w = self.grid_dict['z_u_w']\n [Ly,N] = self.b.shape\n #---> j-loop\n for j in range(Ly): \n self.kbl[j] = N # initialize search\n #-> end j-loop\n\n #--> k-loop\n for k in range(N-1,0,-1):\n k_w = k\n k_r = k-1\n # --> j loop \n for j in range(Ly):\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\n self.kbl[j] = k_w\n\n #--> end k\n # --> end j\n\n\n '''\n Compute nondimenisonal shape function coefficeints Gx() by\n matching values and vertical derivatives of interior mixing\n coefficients at hbbl (sigma=1)\n '''\n\n self.Gm1_bot = np.zeros([Ly])\n self.dGm1_dS_bot = np.zeros([Ly])\n self.Gt1_bot = np.zeros([Ly])\n self.dGt1_dS_bot = np.zeros([Ly]) \n self.Av_bl_bot = np.zeros([Ly])\n self.dAv_bl_bot = np.zeros([Ly]) \n self.cff_up_bot = np.zeros([Ly])\n self.cff_dn_bot = np.zeros([Ly])\n\n\n\n\n\n self.wm_bot = np.zeros([Ly])\n self.ws_bot = np.zeros([Ly]) \n\n # CALCULATE ustar for the bottom based on bototm velocities\n \n \n \n # CALCULATE r_D\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \n u = self.u\n v_upts = TTTW_func.v2u(self.v)\n \n ubar = np.mean(u,axis=1)\n vbar = np.mean(v_upts,axis=1)\n\n # --> j loop\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n if self.CD_SWITCH:\n # DEPTH AVERAGED APPROACH\n uref = u[j,0]\n vref = v_upts[j,0]\n ustar2 = self.C_D * (uref**2 + vref**2)\n else:\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n\n self.wm_bot[j] = wm\n self.ws_bot[j] = ws\n \n k_w = self.kbl[j] \n z_bl = z_u_w[j,0] + self.hbbl[j]\n\n if z_bl < z_u_w[j,k_w-1]:\n k_w = k_w-1\n\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl_bot[j] = Av_bl\n self.dAv_bl_bot[j] = dAv_bl\n\n\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\n\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])"],"string":"[\n \"def B(n, k):\\n assert 0 < k <= n\\n global lookup\\n for index_y in range(len(lookup), n + 1):\\n lookup.append([1])\\n min_value = min(index_y, k)\\n for index_x in range(min_value):\\n if index_x < len(lookup[index_y - 1]) - 1:\\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\\n else:\\n lookup[index_y].append(lookup[index_y - 1][index_x])\\n return lookup[n][k]\",\n \"def _compute_parameters(self, p, k):\\n for i in range(self._.d + 1):\\n p[0, i, i] = k[i]\\n p[i, 0, i] = Integer(1)\\n p[i, i, 0] = Integer(1)\\n for i in range(self._.d):\\n p[i+1, 1, i+1] = self._.a[i+1]\\n p[i, 1, i+1] = self._.b[i]\\n p[i+1, 1, i] = self._.c[i+1]\\n for i in range(2, self._.d + 1):\\n for j in range(1, self._.d + 1):\\n for h in range(1, self._.d):\\n p[h, i, j] = self._check_parameter(\\n h, i, j,\\n _simplify(_expand((\\n self._.c[h] * p[h-1, i-1, j]\\n + self._.b[h] * p[h+1, i-1, j]\\n - self._.b[i-2] * p[h, i-2, j]\\n + (self._.a[h] - self._.a[i-1]) * p[h, i-1, j]\\n ) / self._.c[i])))\\n p[self._.d, i, j] = self._check_parameter(\\n self._.d, i, j,\\n _simplify(_expand((\\n self._.c[self._.d] * p[self._.d-1, i-1, j]\\n - self._.b[i-2] * p[self._.d, i-2, j]\\n + (self._.a[self._.d] - self._.a[i-1])\\n * p[self._.d, i-1, j]\\n ) / self._.c[i])))\",\n \"def question_14_and_15(gamma, K):\\n rbf = RadialBiasFunction()\\n wins = 0.0\\n my_svm = svm.SVC(C=np.inf, kernel='rbf', gamma=gamma)\\n for i in range(100):\\n rbf.fit(gamma, K)\\n my_svm = my_svm.fit(rbf.X, rbf.Y)\\n svm_error = 1 - my_svm.score(rbf.test_X, rbf.test_Y)\\n rbf_error = rbf.error(in_sample=False)\\n if svm_error < rbf_error:\\n wins += 1\\n rbf.resample()\\n return wins / 100\",\n \"def _K_computations(self, X, X2):\\r\\n if self.ARD:\\r\\n pass\\r\\n else:\\r\\n if X2 is None:\\r\\n self._K_inner_prod = np.dot(X,X.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\\r\\n vec = np.diag(self._K_numer) + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec,vec))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\\r\\n else:\\r\\n self._K_inner_prod = np.dot(X,X2.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\\r\\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\",\n \"def stirling(k, r) :\\n\\n return sum((-1)**(r-i)*binomial(r, i)*i**k for i in range(r+1)) / math.factorial(r)\",\n \"def compute(self, X, Y, n):\\n inner_cv = KFold(5, shuffle=True, random_state=1673)\\n\\n print('-> grid searching and cross validation ...')\\n for training, validation, j in self._k_fold_cross_validation(X, 5, n):\\n\\n x, y, valid_x, valid_y = X.loc[training, :], Y[training], X.loc[validation, :], Y[validation]\\n x_features, valid_features = self.sat_features.loc[training, :], self.sat_features.loc[validation, :]\\n\\n if 'kNN' in self.model_list:\\n parameters = {'n_neighbors': range(1, 18, 2)}\\n model = KNeighborsRegressor(weights='distance')\\n self.kNN = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\\n\\n res = self.kNN.fit(x, y).predict(valid_x)\\n self.results['kNN'].append(list(res))\\n self.scores['kNN'].append(R2(valid_y, res))\\n\\n if 'Kriging' in self.model_list:\\n parameters = {\\\"kernel\\\": [RBF(l) for l in [[1, 1]]]}\\n model = GaussianProcessRegressor(alpha=0.1, n_restarts_optimizer=0)\\n self.Kriging = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\\n\\n res = self.Kriging.fit(x, y).predict(valid_x)\\n self.results['Kriging'].append(list(res))\\n self.scores['Kriging'].append(R2(valid_y, res))\\n\\n if 'RmSense' in self.model_list:\\n parameters = {\\\"alpha\\\": [0.001, 0.01, 0.1, 1, 10, 100, 1000]}\\n model = Ridge()\\n self.RmSense = GridSearchCV(estimator=model, param_grid=parameters, cv=inner_cv, scoring=r2)\\n #print('INFO: best alpha - ', self.RmSense.fit(x_features, y).best_params_)\\n\\n res = self.RmSense.fit(x_features, y).predict(valid_features)\\n self.results['RmSense'].append(list(res))\\n self.scores['RmSense'].append(R2(valid_y, res))\\n\\n if 'Ensamble' in self.model_list:\\n res = (self.RmSense.predict(valid_features) + self.kNN.predict(valid_x)) / 2.\\n self.results['Ensamble'].append(list(res))\\n self.scores['Ensamble'].append(R2(valid_y, res))\\n\\n for m in self.model_list:\\n print('score {}: {}'.format(m, np.mean(self.scores[m])))\",\n \"def rasm_mode(self, K, MAX_ITER=40):\\r\\n #old_Ki_f = np.zeros((self.N, 1))\\r\\n\\r\\n #Start f's at zero originally of if we have gone off track, try restarting\\r\\n if self.old_Ki_f is None or self.bad_fhat:\\r\\n old_Ki_f = np.random.rand(self.N, 1)/50.0\\r\\n #old_Ki_f = self.Y\\r\\n f = np.dot(K, old_Ki_f)\\r\\n else:\\r\\n #Start at the old best point\\r\\n old_Ki_f = self.old_Ki_f.copy()\\r\\n f = self.f_hat.copy()\\r\\n\\r\\n new_obj = -np.inf\\r\\n old_obj = np.inf\\r\\n\\r\\n def obj(Ki_f, f):\\r\\n return -0.5*np.dot(Ki_f.T, f) + self.noise_model.logpdf(f, self.data, extra_data=self.extra_data)\\r\\n\\r\\n difference = np.inf\\r\\n epsilon = 1e-7\\r\\n #step_size = 1\\r\\n #rs = 0\\r\\n i = 0\\r\\n\\r\\n while difference > epsilon and i < MAX_ITER:\\r\\n W = -self.noise_model.d2logpdf_df2(f, self.data, extra_data=self.extra_data)\\r\\n\\r\\n W_f = W*f\\r\\n grad = self.noise_model.dlogpdf_df(f, self.data, extra_data=self.extra_data)\\r\\n\\r\\n b = W_f + grad\\r\\n W12BiW12Kb, _ = self._compute_B_statistics(K, W.copy(), np.dot(K, b))\\r\\n\\r\\n #Work out the DIRECTION that we want to move in, but don't choose the stepsize yet\\r\\n full_step_Ki_f = b - W12BiW12Kb\\r\\n dKi_f = full_step_Ki_f - old_Ki_f\\r\\n\\r\\n f_old = f.copy()\\r\\n def inner_obj(step_size, old_Ki_f, dKi_f, K):\\r\\n Ki_f = old_Ki_f + step_size*dKi_f\\r\\n f = np.dot(K, Ki_f)\\r\\n # This is nasty, need to set something within an optimization though\\r\\n self.tmp_Ki_f = Ki_f.copy()\\r\\n self.tmp_f = f.copy()\\r\\n return -obj(Ki_f, f)\\r\\n\\r\\n i_o = partial_func(inner_obj, old_Ki_f=old_Ki_f, dKi_f=dKi_f, K=K)\\r\\n #Find the stepsize that minimizes the objective function using a brent line search\\r\\n #The tolerance and maxiter matter for speed! Seems to be best to keep them low and make more full\\r\\n #steps than get this exact then make a step, if B was bigger it might be the other way around though\\r\\n #new_obj = sp.optimize.minimize_scalar(i_o, method='brent', tol=1e-4, options={'maxiter':5}).fun\\r\\n new_obj = sp.optimize.brent(i_o, tol=1e-4, maxiter=10)\\r\\n f = self.tmp_f.copy()\\r\\n Ki_f = self.tmp_Ki_f.copy()\\r\\n\\r\\n #Optimize without linesearch\\r\\n #f_old = f.copy()\\r\\n #update_passed = False\\r\\n #while not update_passed:\\r\\n #Ki_f = old_Ki_f + step_size*dKi_f\\r\\n #f = np.dot(K, Ki_f)\\r\\n\\r\\n #old_obj = new_obj\\r\\n #new_obj = obj(Ki_f, f)\\r\\n #difference = new_obj - old_obj\\r\\n ##print \\\"difference: \\\",difference\\r\\n #if difference < 0:\\r\\n ##print \\\"Objective function rose\\\", np.float(difference)\\r\\n ##If the objective function isn't rising, restart optimization\\r\\n #step_size *= 0.8\\r\\n ##print \\\"Reducing step-size to {ss:.3} and restarting optimization\\\".format(ss=step_size)\\r\\n ##objective function isn't increasing, try reducing step size\\r\\n #f = f_old.copy() #it's actually faster not to go back to old location and just zigzag across the mode\\r\\n #old_obj = new_obj\\r\\n #rs += 1\\r\\n #else:\\r\\n #update_passed = True\\r\\n\\r\\n #old_Ki_f = self.Ki_f.copy()\\r\\n\\r\\n #difference = abs(new_obj - old_obj)\\r\\n #old_obj = new_obj.copy()\\r\\n difference = np.abs(np.sum(f - f_old)) + np.abs(np.sum(Ki_f - old_Ki_f))\\r\\n #difference = np.abs(np.sum(Ki_f - old_Ki_f))/np.float(self.N)\\r\\n old_Ki_f = Ki_f.copy()\\r\\n i += 1\\r\\n\\r\\n self.old_Ki_f = old_Ki_f.copy()\\r\\n\\r\\n #Warn of bad fits\\r\\n if difference > epsilon:\\r\\n self.bad_fhat = True\\r\\n warnings.warn(\\\"Not perfect f_hat fit difference: {}\\\".format(difference))\\r\\n elif self.bad_fhat:\\r\\n self.bad_fhat = False\\r\\n warnings.warn(\\\"f_hat now perfect again\\\")\\r\\n\\r\\n self.Ki_f = Ki_f\\r\\n return f\",\n \"def define_pseudo_potts_helper_functions(n, k):\\n\\n assert n>1\\n assert k>1\\n\\n @njit\\n def get_multipliers_r(r, multipliers, n=n, k=k):\\n \\\"\\\"\\\"Return r's field and all couplings to spin r.\\n\\n Parameters\\n ----------\\n r : int\\n multipliers : ndarray\\n All fields and couplings concatenated together.\\n\\n Returns\\n -------\\n ndarray\\n Relevant multipliers.\\n list\\n Index of where multipliers appear in full multipliers array.\\n \\\"\\\"\\\"\\n \\n ix = [r+n*i for i in range(k)]\\n multipliersr = np.zeros(k-1+n)\\n for i in range(k):\\n multipliersr[i] = multipliers[r+n*i]\\n\\n # fill in the couplings\\n ixcounter = k\\n for i in range(n):\\n if i!=r:\\n if i<r:\\n ix.append( sub_to_ind(n, i, r) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n else:\\n ix.append( sub_to_ind(n, r, i) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n ixcounter += 1\\n return multipliersr, ix\\n\\n @njit\\n def calc_observables_r(r, X, n=n, k=k):\\n \\\"\\\"\\\"Return the observables relevant for calculating the conditional probability of\\n spin r.\\n\\n Parameters\\n ----------\\n r : int\\n Spin index.\\n X : ndarray\\n Data samples of dimensions (n_samples, n_dim).\\n\\n Returns\\n -------\\n ndarray\\n observables\\n list of ndarray\\n observables if spin r were to occupy all other possible states\\n ndarray\\n Each col details the occupied by spin r in each array of the previous return\\n value, i.e., the first col of this array tells me what r has been changed to\\n in the first array in the above list.\\n \\\"\\\"\\\"\\n\\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n # keep another copy of observables where the spin iterates thru all other possible states\\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n for i in range(k-1)]\\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\\n \\n # for each data sample in X\\n for rowix in range(X.shape[0]):\\n counter = 0\\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\\n for i in range(k):\\n if X[rowix,r]==i:\\n obs[rowix,i] = 1\\n else:\\n otherobs[counter][rowix,i] = 1\\n otherstates[rowix,counter] = i\\n counter += 1\\n ixcounter = k\\n \\n for i in range(n-1):\\n for j in range(i+1,n):\\n if i==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\\n kcounter += 1\\n ixcounter += 1\\n elif j==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\\n kcounter += 1\\n ixcounter += 1\\n return obs, otherobs, otherstates\\n\\n return get_multipliers_r, calc_observables_r\",\n \"def learn(self,k=10):\\n \\n gradients = {}\\n for i in range(k):\\n\\n #create TILDE(R) tree object\\n tree_i = TILDE(typ=\\\"regression\\\",score=\\\"WV\\\",max_depth=self.max_depth)\\n\\n #subsample negatives if too many for each tree\\n sampled_neg = deepcopy(self.neg)\\n if len(self.neg) > 2*len(self.pos):\\n sampled_neg = sample(self.neg,2*len(self.pos))\\n\\n #compute gradients as I-P\\n for ex in self.examples:\\n p = sigmoid(self.examples[ex])\\n if ex in self.pos:\\n gradients[ex] = 1-p\\n elif ex in sampled_neg:\\n gradients[ex] = 0-p\\n\\n #fit tree on gradients\\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\\n \\n #recompute example values as previous example value + tree_i value\\n for ex in self.examples:\\n tree_i_value = tree_i.infer(self.data,ex)\\n self.examples[ex] += 0.01*tree_i_value\\n\\n #add tree to boosted_trees\\n self.boosted_trees.append(tree_i)\",\n \"def MCS(n,k):\\n\\tglobal dict_all\\n\\tdict_val=copy.deepcopy(dict_all)\\n\\t#start_time = time.time()\\n\\tfinal = {}\\t\\t\\t\\t\\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\\n\\tseq = []\\t\\t\\t\\t\\t\\t# Store the count with no duplication\\n\\tfor i in range(n):\\n\\t\\tleaf={}\\t\\t\\t\\t\\t\\t# leaf is the dictionary to store the random value of each leaf\\n\\t\\t#count=0\\n\\t\\tfor i in leaves:\\n\\t\\t\\tleaf[i] = choice([0,1])\\n\\t\\t\\tdict_val[i]=leaf[i]\\n\\t\\t\\t#count += leaf[i]\\n\\t\\tresult = Cal_FT(dict_val)\\t\\n\\t\\t'''\\n\\t\\tif result:\\n\\t\\t\\tcutset = []\\n\\t\\t\\tfor i in leaves:\\n\\t\\t\\t\\tcutset.append(str(leaf[i]))\\n\\t\\t\\tcutset=\\\"\\\".join(cutset)\\n\\t\\t\\tif cutset not in final:\\n\\t\\t\\t\\tfinal[cutset]=count\\n\\tfinal_sorted=sorted(zip(final.values(),final.keys())) \\t\\t\\t\\t#Order the cutset by its count\\n\\tfor i in range(k):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#Print the first k result\\n\\t\\tcutset=list(final_sorted[i][1])\\n\\t\\tresult=[]\\n\\t\\tfor index in range(len(cutset)):\\n\\t\\t\\tif cutset[index] is \\\"1\\\":\\n\\t\\t\\t\\tresult.append(leaves[index])\\n\\t\\tprint result\\n\\t#end_time=time.time()\\n\\t#print \\\"Running time is\\\", end_time-start_time\\n\\t'''\",\n \"def T_step_value_iteration(self,R, T):\\n U1 = dict([(s, 0) for s in self.states])\\n self._prepare_post_cache()\\n policy = dict([(s, set()) for s in self.states])\\n t = T\\n while t > 0:\\n U = U1.copy()\\n delta = 0\\n for s in self.states:\\n U1[s] = max([sum([self.prob_delta(s,a,s1) * (U[s1] + R[s, a,s1])\\n for s1 in self.post(s, a)])]\\n for a in self.available(s))[0]\\n delta = max(delta, abs(U1[s] - U[s]))\\n t = t - 1\\n print t\\n for s in self.states:\\n Vmax = dict()\\n for a in self.available(s):\\n Vmax[a] = [sum([self.prob_delta(s,a,s1) * (U[s1] + R[s, a,s1])\\n for s1 in self.post(s, a)])][0]\\n maxV = max(Vmax.values())\\n for a in Vmax.keys():\\n if Vmax[a] == maxV:\\n policy[s].add(a)\\n return U, policy\",\n \"def time_path_iteration(params=params, S=3, T=50, weight=0.3, tol=1e-12, maxiter=100):\\n ss_output = get_SS()\\n b_ss = ss_output['b_ss']\\n b_init = np.array([0, 0.8 * b_ss[0], 1.1 * b_ss[1]]) # t=0\\n\\n # Guess transition path, finishes at steady_state\\n Kguess = np.linspace(b_init.sum(), ss_output['K_ss'], T)\\n\\n s = 1\\n K_dynamic = Kguess\\n b_current = np.zeros((S,T)) # initialize array to store savings decisions\\n b_current[:,0] = b_init\\n\\n # Update b_path until convergence\\n its = 0\\n ee_diff = 7.0\\n while ee_diff > tol and its < maxiter:\\n its += 1\\n w_dynamic = find_w(L=params['labor_supply'].sum(), K=K_dynamic)\\n r_dynamic = find_r(L=params['labor_supply'].sum(), K=K_dynamic)\\n for t in range(T-2):\\n\\n #solve for b32, savings decision of middle-aged in first period\\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_current[:,t], s, t)\\n b_current[s+1,t+1] = opt.root(ee_err_1, 0, args=ee_param).x\\n\\n # solve for b22, b33, savings decision of young gen in middle/old generations\\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_init, s, t)\\n b_current[s,t+1], b_current[s+1, t+2]= opt.root(ee_err_23, [0,0], args=ee_param).x\\n # fill in table\\n b_current[s,T-1] = b_current[s,T-2]\\n\\n # Check for convergence\\n K_prime = b_current.sum(axis=0)\\n ee_diff = (K_prime - K_dynamic).max()\\n\\n# rc_diff = production(K_prime, L=params['labor_supply'].sum())\\n# - Ct = (1 + r_dynamic) * ()\\n# - np.roll(K_prime, len(K_prime)-1)\\n# - (1 - delta) * K_prime\\n\\n print('Iteration number: ', its, 'Current EE difference: ', ee_diff)\\n # update new capital path\\n K_dynamic = weight * K_prime + (1-weight) * K_dynamic\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), Kguess, 'r--',lw=0.7, label='Kguess')\\n plt.plot(range(T), K_dynamic , label='Capital Path Solution')\\n plt.title('Transition Path of Aggregate Capital')\\n plt.xlabel('Time period')\\n plt.ylabel('Aggregate Capital')\\n plt.legend()\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), r_dynamic, 'g-o',label='Interest rate Path Solution')\\n plt.title('Transition Path of Aggregate Interest rate')\\n plt.xlabel('Time period')\\n plt.ylabel('Interest Rate')\\n plt.legend()\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), w_dynamic, 'k-o',label='Wage Path Solution')\\n plt.title('Transition Path of Wages')\\n plt.xlabel('Time period')\\n plt.ylabel('Wages')\\n plt.legend()\\n\\n return K_dynamic\",\n \"def fn(k, i, j):\\n if not (0 <= i < N and 0 <= j < N): return 0\\n if k == 0: return 1 \\n return 1/8*sum(fn(k-1, i+ii, j+jj) for ii, jj in ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2, 1)))\",\n \"def dynamic_iteration(k, n):\\n # If only one egg remains, n attempts must be made to find the correct floor.\\n if k == 1:\\n return n\\n # Lookup table for previous solutions.\\n W = [[0 for y in range(n + 1)] for x in range(k)]\\n # Initialize the first row.\\n for i in range(n + 1):\\n W[0][i] = i\\n # Start on second row, working downward.\\n for i in range(1, k):\\n # Calculate values for each cell.\\n for j in range(1, n + 1):\\n W[i][j] = min((max(W[i][j - x], W[i - 1][x - 1]) for x in range(1, j + 1))) + 1\\n # Return the result.\\n return W[k - 1][n]\",\n \"def generate_good(self, m, n, rank, mu=2, ka=2):\\n sr = random.random()\\n s = []\\n s.append(sr)\\n for r in range(rank-1):\\n newele = s[-1] * (1 + ka * random.random() / (rank-1))\\n s.append(newele)\\n s.reverse()\\n \\n # best_u = None\\n # best_mu0 = 0\\n # while best_mu0 == 0:\\n # for _ in range(10):\\n # A = np.random.rand(m,m)\\n # A = scipy.linalg.orth(A)\\n # u = A[:, :rank]\\n # mu0 = self.compute_mu(u, m, rank)\\n # print(\\\"mu0 : \\\", mu0)\\n # if mu0 <= mu and mu0 >= best_mu0:\\n # best_mu0 = mu0\\n # best_u = u\\n # print(\\\"mu0 for u:\\\", best_mu0)\\n # # print(u.T @ u)\\n \\n # best_v = None\\n # best_mu0 = 0\\n # while best_mu0 == 0:\\n # for _ in range(10):\\n # B = np.random.rand(n,n)\\n # B = scipy.linalg.orth(B)\\n # v = B[:, :rank]\\n # mu0 = self.compute_mu(v, n, rank)\\n # print(\\\"mu0 : \\\", mu0)\\n # if mu0 <= mu and mu0 >= best_mu0:\\n # best_mu0 = mu0\\n # best_v = v\\n # print(\\\"mu0 for v:\\\", best_mu0)\\n # u = best_u\\n # v = best_v\\n\\n for _ in range(100):\\n A = np.random.rand(m,m)\\n A = scipy.linalg.orth(A)\\n u = A[:, :rank]\\n mu0 = self.compute_mu(u, m, rank)\\n print(\\\"mu0 : \\\", mu0)\\n if mu0 <= mu:\\n break\\n print(\\\"mu0 for u:\\\", mu0) \\n\\n for _ in range(10):\\n B = np.random.rand(n,n)\\n B = scipy.linalg.orth(B)\\n v = B[:, :rank]\\n mu0 = self.compute_mu(v, n, rank)\\n print(\\\"mu0 : \\\", mu0)\\n if mu0 <= mu:\\n break\\n print(\\\"mu0 for both:\\\", mu0)\\n\\n matrix = np.dot(u*s, v.T)\\n \\n kappa = s[0] / s[-1]\\n print(\\\"kappa=\\\", kappa)\\n \\n ss = np.copy(s)\\n for k in range(rank):\\n ss[k] = s[k] / s[0]\\n \\n max_entry = np.max(np.abs(np.outer(u[:,:rank], v.T[:rank,:])))\\n mu1 = max_entry * math.sqrt(m * n / rank)\\n print(\\\"mu1=\\\", mu1)\\n \\n return matrix\",\n \"def learn(self,k=10):\\n \\n gradients = {}\\n for i in range(k):\\n\\n #create TILDE(R) tree object\\n tree_i = TILDE(typ=\\\"regression\\\",score=\\\"WV\\\",max_depth=self.max_depth)\\n\\n #subsample negatives if too many for each tree\\n sampled_neg = deepcopy(self.neg)\\n if len(self.neg) > 2*len(self.pos):\\n sampled_neg = sample(self.neg,2*len(self.pos))\\n\\n #compute gradients using LMNN loss function\\n for ex in self.examples:\\n gradient = self.compute_gradient(ex,\\n self.pos,\\n self.neg,\\n self.examples)\\n gradients[ex] = gradient\\n\\n\\n #fit tree on gradients\\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\\n \\n #recompute example values as previous example value - gamma*tree_i value\\n for ex in self.examples:\\n tree_i_value = tree_i.infer(self.data,ex)\\n self.examples[ex] -= 0.01*tree_i_value #learning rate\\n \\n #add tree to boosted_trees\\n self.boosted_trees.append(tree_i)\",\n \"def boundary_op_n(v):\\r\\n h = list(v.dic.keys())[0]\\r\\n p = len(h) - 1\\r\\n s = P_chains([],[])\\r\\n if (p != 0) and (isinstance(h, str) != True) and (isinstance(h, frozenset) != True) and (isinstance(h, ImmutableMatrix) != True):\\r\\n if (is_int(list(v.dic.keys())) == True):\\r\\n for u in v.dic.keys():\\r\\n c = 0\\r\\n for i in u: \\r\\n w = list(u)[:]\\r\\n w.remove(i)\\r\\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**c) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n else:\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n return s\\r\\n else:\\r\\n aux = P_chains([],[])\\r\\n D = {}\\r\\n ct = 0\\r\\n st = []\\r\\n for u in v.dic.keys():\\r\\n for x in u:\\r\\n if x not in st:\\r\\n st.append(x)\\r\\n for i in st:\\r\\n D[tuple([ct])] = i\\r\\n ct = ct + 1\\r\\n for u in v.dic.keys():\\r\\n w2 = []\\r\\n for x in u:\\r\\n for y in list(D.keys()):\\r\\n if (x == D[y]):\\r\\n w2.append(y)\\r\\n aux = aux + P_chains([tuple(w2)],[v.dic[u]]) \\r\\n v = aux\\r\\n for u in v.dic.keys():\\r\\n c = 0\\r\\n for i in u: \\r\\n w = list(u)[:]\\r\\n w.remove(i)\\r\\n if (orientation_function(tuple(tuple_sorted(tuple(w))),tuple(w),p) == True):\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**c) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n else:\\r\\n s1 = P_chains([tuple(tuple_sorted(tuple(w)))],[abs(v.dic[u])])\\r\\n if (np.sign((v.dic[u])*(-1)**(c+1)) < 0):\\r\\n s = s - s1\\r\\n else:\\r\\n s = s + s1\\r\\n c = c+1\\r\\n s2 = P_chains([],[])\\r\\n for u in s.dic.keys():\\r\\n w2=[]\\r\\n for i in u:\\r\\n w2.append(D[i])\\r\\n s2 = s2 + P_chains([tuple(w2)],[s.dic[u]])\\r\\n \\r\\n return s2\\r\\n else:\\r\\n return s\",\n \"def recursion_step(value_n, r_grid, discount):\\n\\n n = value_n.shape[0]\\n r_len = r_grid.shape[0]\\n value_n_minus_1 = np.zeros([n - 1, r_len]) # Value function length reduced by 1\\n gittins_n_minus_1 = np.zeros(n - 1) # Value function length reduced by 1\\n for k in range(0, n - 1):\\n a = k + 1 # a in range [1,n-1]\\n b = n - k - 1 # b in range [1,n-1]\\n value_n_minus_1[k, :] = np.maximum((r_grid / float(1 - discount)),\\n (a / float(n)) * (1 + discount * value_n[k + 1, :]) +\\n (b / float(n)) * discount * value_n[k, :]\\n )\\n try:\\n # Find first index where Value = (Value of Safe Arm)\\n idx_git = np.argwhere((r_grid / float(1 - discount)) == value_n_minus_1[k, :]).flatten()\\n gittins_n_minus_1[k] = 0.5 * (r_grid[idx_git[0]] + r_grid[idx_git[0] - 1]) # Take average\\n except:\\n print(\\\"Error in finding Gittins index\\\")\\n\\n return gittins_n_minus_1, value_n_minus_1\",\n \"def obrien_fleming_adjust_n(n, K, alpha, power):\\n\\n if not isinstance(n, int) or n < 1:\\n raise ValueError('n must be an integer greater than 1.')\\n\\n if not isinstance(K, int) or K < 1 or K > 10:\\n raise ValueError('K must be an integer between 1 and 10.')\\n\\n if alpha not in [0.01, 0.05, 0.1]:\\n raise ValueError('alpha must be 0.01, 0.05, or 0.1.')\\n\\n if power not in [0.8, 0.9]:\\n raise ValueError('power must be 0.8, or 0.9.')\\n\\n factors = {\\n \\\"0.8\\\": {\\n \\\"0.01\\\": [1.000, 1.001, 1.007, 1.011, 1.015, 1.017, 1.019, 1.021, 1.022, 1.024],\\n \\\"0.05\\\": [1.000, 1.008, 1.017, 1.024, 1.028, 1.032, 1.035, 1.037, 1.038, 1.040],\\n \\\"0.1\\\": [1.000, 1.016, 1.027, 1.035, 1.040, 1.044, 1.047, 1.049, 1.051, 1.053],\\n },\\n \\\"0.9\\\": {\\n \\\"0.01\\\": [1.000, 1.001, 1.006, 1.010, 1.014, 1.016, 1.018, 1.020, 1.021, 1.022],\\n \\\"0.05\\\": [1.000, 1.007, 1.016, 1.022, 1.026, 1.030, 1.032, 1.034, 1.036, 1.037],\\n \\\"0.1\\\": [1.000, 1.014, 1.025, 1.032, 1.037, 1.041, 1.044, 1.046, 1.048, 1.049],\\n },\\n }\\n return math.ceil(n * factors[str(power)][str(alpha)][K - 1])\",\n \"def fn(n, k):\\n if k == 1: return n \\n if n == 0: return 0 \\n ans = inf \\n for x in range(1, n+1): \\n ans = min(ans, 1 + max(fn(x-1, k-1), fn(n-x, k)))\\n return ans\",\n \"def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n max_cp = 1\\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 max_cp += w_inpIdx*X0[inpIdx]\\n # saving values\\n layerEq[inpIdx] = X0[inpIdx]\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\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]/kdT[layeridx-1][inpIdx])\\n layerEq[inpIdx] = x_eq\\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 max_cp += firstComplex + Inhib2/E0*x_eq\\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],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n max_cp += Inhib2/E0*x_eq\\n return max_cp\",\n \"def __kappa_mle(self, k, R):\\n return (iv(1, k) / iv(0, k)) - R\",\n \"def _conditional_z(K, alpha, beta, n_mk, n_kt, m, t, beta_sum, n_k):\\n probability = \\\\\\n (alpha + n_mk[m, :]) * ((beta[t] + n_kt[:, t]) / (beta_sum + n_k))\\n probability /= np.sum(probability)\\n assert(np.all(probability >= 0.))\\n assert(1.0 - 1e-6 < np.sum(probability) < 1.0 + 1e-6)\\n assert(len(probability) == K)\\n return np.random.choice(K, p=probability)\",\n \"def hidden_markov_conditional_s_N(traj, fitness=0, N_w=50_000, resolution=25, alpha=0.01):\\n \\n # Step 1: compute range of reasonable initial clone sizes based on data alone\\n # Beta function\\n beta_p_conf_int = beta.ppf(q=[alpha, 1-alpha],\\n a=traj.iloc[0].AO+1,\\n b=(traj.iloc[0].DP\\n - traj.iloc[0].AO\\n + 1))\\n\\n # List of binomial p ranges and clone_size_ranges\\n beta_p_range = np.linspace(beta_p_conf_int[0],\\n min(beta_p_conf_int[1], 0.5),\\n resolution)\\n\\n # Transform p values to clone sizes\\n init_range = distributions.vaf_to_clone_size(v=beta_p_range,\\n N_w=N_w)\\n\\n # initialise clone size ranges of starting birth and death processes\\n bd_init_ranges = [(init_range[0], init_range[-1])]\\n\\n # Compute first term of recursion\\n recursive_prob = y_1_cond(init_range, traj.iloc[0], N_w)\\n\\n previous_x_range = init_range\\n\\n for i in range(1,len(traj)):\\n \\n next_x_range = find_range (traj, i, bd_init_ranges, fitness, N_w, alpha, resolution)\\n\\n recursive_prob = np.array([y_k_cond(x, traj.iloc[i], recursive_prob, previous_x_range,\\n fitness, N_w) for x in next_x_range])\\n previous_x_range = next_x_range\\n\\n probability = np.trapz(x=previous_x_range, y=recursive_prob)\\n return probability\",\n \"def tourney_prob(k, N, m):\\n\\n if N < m:\\n print \\\"The second argument cannot be smaller than the third one.\\\"\\n sys.exit()\\n\\n if m < 1 or k <= 0:\\n return 0.0\\n elif m == 1:\\n return 1.0 / N\\n else:\\n return float(N - k) * m / (N * (m - 1)) * tourney_prob(k, N - 1, m - 1)\",\n \"def _compute_B_statistics(self, K, W, a):\\r\\n if not self.noise_model.log_concave:\\r\\n #print \\\"Under 1e-10: {}\\\".format(np.sum(W < 1e-6))\\r\\n W[W < 1e-10] = 1e-10 # FIXME-HACK: This is a hack since GPy can't handle negative variances which can occur\\r\\n # If the likelihood is non-log-concave. We wan't to say that there is a negative variance\\r\\n # To cause the posterior to become less certain than the prior and likelihood,\\r\\n # This is a property only held by non-log-concave likelihoods\\r\\n\\r\\n\\r\\n #W is diagonal so its sqrt is just the sqrt of the diagonal elements\\r\\n W_12 = np.sqrt(W)\\r\\n B = np.eye(self.N) + W_12*K*W_12.T\\r\\n L = jitchol(B)\\r\\n\\r\\n W12BiW12a = W_12*dpotrs(L, np.asfortranarray(W_12*a), lower=1)[0]\\r\\n ln_B_det = 2*np.sum(np.log(np.diag(L)))\\r\\n return W12BiW12a, ln_B_det\",\n \"def _step(self) -> Dict[str, tf.Tensor]:\\n\\n # Pull out the data needed for updates/priorities.\\n inputs = next(self._iterator)\\n\\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\\n keys, probs = inputs.info[:2]\\n\\n with tf.GradientTape() as tape:\\n # Evaluate our networks.\\n # `qv` means quantile values, `tau` is same as quantile\\n # Shape: [B, num_quantiles]\\n tau_tm1 = tf.random.uniform(\\n shape=[tf.shape(o_tm1)[0], self._num_tau_samples],\\n minval=0., maxval=1., dtype=tf.float32)\\n tau_t = tf.random.uniform(\\n shape=[tf.shape(o_t)[0], self._num_tau_prime_samples],\\n minval=0., maxval=1., dtype=tf.float32)\\n tau_for_selector = tf.random.uniform(\\n shape=[tf.shape(o_t)[0], self._num_quantile_samples],\\n minval=0., maxval=1., dtype=tf.float32)\\n # Shape: [B, A, num_quantiles]\\n qv_tm1 = self._network(o_tm1, tau_tm1)\\n qv_t = self._target_network(o_t, tau_t)\\n if self._double_dqn:\\n q_t_selector = tf.reduce_mean(\\n self._network(o_t, tau_for_selector), axis=-1)\\n else:\\n q_t_selector = tf.reduce_mean(\\n self._target_network(o_t, tau_for_selector), axis=-1)\\n\\n # Shape: [B]\\n a_t = tf.argmax(q_t_selector, axis=1, output_type=tf.int32)\\n\\n # The rewards and discounts have to have the same type as network values.\\n r_t = tf.clip_by_value(tf.cast(r_t, qv_tm1.dtype), -1., 1.)\\n d_t = tf.cast(d_t, qv_tm1.dtype) * tf.cast(self._discount, qv_tm1.dtype)\\n\\n # Calculate actions value distribution\\n qv_a_tm1 = slice_with_actions(qv_tm1, a_tm1) # [B, num_quantiles]\\n\\n # Scale and shift time-t distribution atoms by discount and reward.\\n qv_a_t = slice_with_actions(qv_t, a_t) # [B, num_quantiles]\\n # Shape: [B, num_quantiles]\\n target = tf.stop_gradient(r_t[:, None] + d_t[:, None] * qv_a_t)\\n\\n # Calculate quantile huber loss\\n # Shape: [B, num_quantiles, num_quantiles]\\n bellman_errors = target[:, None, :] - qv_a_tm1[:, :, None]\\n\\n # Compute the loss.\\n # Shape: [B, num_quantiles, num_quantiles]\\n huber_loss = losses.huber(bellman_errors, self._kappa)\\n\\n # Shape: [B, num_quantiles, num_quantiles]\\n # Unlike QR-DQN, we directly use taus outputted by network as \\\\hat{\\\\tau}\\n quantile_huber_loss = (tf.abs(tau_tm1[..., None] - tf.stop_gradient(\\n tf.cast(bellman_errors < 0, tf.float32))) * huber_loss) / self._kappa\\n\\n # Shape: [B]\\n loss = tf.reduce_mean(tf.reduce_sum(quantile_huber_loss, axis=2), axis=1)\\n td_errors = tf.identity(loss)\\n\\n # Get the importance weights.\\n importance_weights = 1. / probs # [B]\\n importance_weights **= self._importance_sampling_exponent\\n importance_weights /= tf.reduce_max(importance_weights)\\n\\n # Reweight.\\n loss *= tf.cast(importance_weights, loss.dtype) # [B]\\n loss = tf.reduce_mean(loss, axis=[0]) # []\\n\\n # Do a step of SGD.\\n gradients = tape.gradient(loss, self._network.trainable_variables)\\n self._optimizer.apply(\\n gradients, self._network.trainable_variables)\\n\\n # Update the priorities in the replay buffer.\\n if self._replay_client:\\n priorities = tf.cast(tf.sqrt(td_errors + 1e-10), tf.float64)\\n self._replay_client.update_priorities(\\n table=adders.DEFAULT_PRIORITY_TABLE, keys=keys, priorities=priorities)\\n\\n # Periodically update the target network.\\n if tf.math.mod(self._num_steps, self._target_update_period) == 0:\\n trfl.update_target_variables(\\n target_variables=self._target_network.variables,\\n source_variables=self._network.variables)\\n self._num_steps.assign_add(1)\\n\\n # Report loss & statistics for logging.\\n fetches = {\\n 'loss': loss,\\n }\\n\\n return fetches\",\n \"def get_learning_gradients(self, k=1, \\n l1=0.0, l2=0.0, \\n sparse_lambda=0., sparse_p=0.01, \\n waste_cutoff=1e-2,\\n waste_reduction=False):\\n updates = {}\\n self.waste_reduction_nbsize = sharedX(1.0, name='waste_reduction_nbsize')\\n\\n print '*********************************'\\n print '*********************************'\\n print '** waste_reduction = ', waste_reduction\\n print '*********************************'\\n print '*********************************'\\n \\n ### compute positive phase ###\\n ph_mean, ph_sample = self.sample_h_given_v(self.input, temper=False)\\n\\n ### compute negative phase ###\\n [nh_samples, nv_samples, beta, mixstat, E], sampling_updates = self.get_sampling_updates(k=k)\\n updates.update(sampling_updates)\\n\\n if self.n_beta.value > 1:\\n # after all this... swap bottom temperature samples into T=1 minibatch\\n nv_samples, E = self.pt_swap_t1_sample(nv_samples, E, mixstat)\\n updates[self._buffer] = T.set_subtensor(self._buffer[:self.n_chain_total], nv_samples)\\n updates[self._E] = T.set_subtensor(self._E[:self.n_chain_total], E)\\n\\n # (optionally) perform waste reduction on parallel chains\\n if waste_reduction:\\n chain_end, weights, wr_nbsize = \\\\\\n pt_waste_reduction(nv_samples, beta, mixstat, E, \\n cut_off=waste_cutoff, batch_size=self.batch_size)\\n updates[self.waste_reduction_nbsize] = wr_nbsize\\n\\n # define cost function\\n cost = T.mean(self.free_energy(self.input)) - \\\\\\n T.sum(weights*self.free_energy(chain_end)) / self.t_batch_size\\n gconstant = [chain_end, weights]\\n else:\\n chain_end = nv_samples[:self.batch_size]\\n # define cost function\\n cost = T.mean(self.free_energy(self.input)) - T.mean(self.free_energy(chain_end))\\n gconstant = [chain_end]\\n\\n if l1: cost += l1 * T.sum(abs(self.W))\\n if l2: cost += l2 * T.sum(self.W**2)\\n \\n # We must not compute the gradient through the gibbs sampling \\n gparams = T.grad(cost, self.params, consider_constant=gconstant)\\n\\n grads = {}\\n # constructs the update dictionary\\n for gparam, param in zip(gparams, self.params):\\n grads[param] = gparam\\n \\n # modify hidden biases according to the sparsity regularization term of Lee07\\n if sparse_lambda:\\n sparse_cost = sparse_lambda * T.sum((sparse_p - T.mean(ph_mean, axis=0))**2)\\n grads[self.hbias] += T.grad(sparse_cost, self.hbias)\\n\\n return grads, updates\",\n \"def regularize_bwd(X, y, mu0, mu1, v1, nz, K, verbose=False):\\n \\n if verbose: sss=0#print '\\\\ncompute bath between mu=%.4f and mu=%.4f'%(mu0, mu1)\\n \\n n, m = X.shape\\n X_nz = np.atleast_2d(X[:, nz])\\n b = np.dot(X.T, y)\\n G = np.dot(X.T, X)\\n \\n nbr = 0\\n mu = mu0\\n trans_type = -1\\n trans_sign = 0\\n trans_ind = -1\\n if verbose: nbr=0#print 'initial active features =', nz\\n \\n while mu > mu1:\\n \\n # find the breakpoints where coefficients become zero\\n b_nz = b[nz]\\n Kv1 = np.dot(K, v1)\\n Kb_nz = np.dot(K, b_nz)\\n mu_0 = Kb_nz / Kv1\\n \\n # find the breakpoints where new coefficients become active\\n z = np.setdiff1d(np.arange(m), nz)\\n X_z = np.atleast_2d(X[:, z])\\n b_z = b[z]\\n M = G[np.ix_(z, nz)]\\n MKb_nz = np.dot(M, Kb_nz)\\n MKv1 = np.dot(M, Kv1)\\n mu_1 = (b_z - MKb_nz) / (1 - MKv1)\\n mu_m1 = (b_z - MKb_nz) / (-1 - MKv1)\\n \\n if trans_type > 0: mu_0[-1] = mu1\\n mu_0[mu_0 >= mu] = mu1\\n if len(mu_0) > 0: \\n mu_0_argmax = mu_0.argmax()\\n mu_0_max = mu_0[mu_0_argmax][0]\\n else:\\n mu_0_max = mu1\\n if trans_type == 0:\\n if trans_sign == 1: mu_1[np.where(z == trans_ind)[0]] = mu1 - 1\\n else: mu_m1[np.where(z == trans_ind)[0]] = mu1 - 1\\n mu_1[mu_1 >= mu] = mu1\\n if len(mu_1) > 0: \\n mu_1_argmax = mu_1.argmax()\\n mu_1_max = mu_1[mu_1_argmax][0]\\n else:\\n mu_1_max = mu1\\n mu_m1[mu_m1 >= mu] = mu1\\n if len(mu_m1) > 0: \\n mu_m1_argmax = mu_m1.argmax()\\n mu_m1_max = mu_m1[mu_m1_argmax][0]\\n else:\\n mu_m1_max = mu1\\n \\n # compute the breakpoint\\n mu_br_all = np.array([mu_0_max, mu_1_max, mu_m1_max])\\n trans_type = mu_br_all.argmax()\\n mu_br = mu_br_all[trans_type]\\n \\n if mu_br > mu1:\\n \\n nbr += 1\\n mu = mu_br\\n \\n if trans_type == 0: # an element of theta(t) goes to zero\\n trans_ind = nz[mu_0_argmax]\\n trans_sign = v1[mu_0_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is inactive'%(mu, trans_ind)\\n nzind = range(len(nz))\\n rr=np.where(nz==trans_ind)[0][0]\\n #print 'longa:',len(nz),len(nzind),len(v1)\\n #print 'c:',nz.index(trans_ind)\\n nzind=np.delete(nzind,rr)#nzind=np.delete(nzind,np.where(nzind==nz.index(trans_ind)))#nzind.remove(nz.index(trans_ind))\\n v1 = v1[nzind]\\n nz=np.delete(nz,rr)#nz=np.delete(nz,np.where(nz==trans_ind))#nz.remove(trans_ind)\\n #print 'longa2:',len(nz),len(nzind),len(v1)\\n X_nz = X[:, nz]\\n K = invupdatered(K, mu_0_argmax)\\n else: # new active element\\n if trans_type == 1: # it is positive\\n trans_ind = z[mu_1_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is positive'%(mu, trans_ind)\\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\\n v1 = np.vstack([v1, 1])\\n else: # it is negative\\n trans_ind = z[mu_m1_argmax]\\n if verbose: sss=0#print 'transition point :: mu = %.4f :: feature %d is negative'%(mu, trans_ind)\\n nz=np.append(nz,trans_ind)#nz.append(trans_ind)\\n v1 = np.vstack([v1, -1])\\n X_new = np.atleast_2d(X[:, trans_ind]).T\\n K = invupdateapp(K, np.dot(X_nz.T, X_new), np.dot(X_new.T, X_nz), \\n np.dot(X_new.T, X_new))\\n X_nz = X[:, nz]\\n \\n else: # compute solution at mu1\\n \\n if verbose: sss=0#print 'compute solution at mu =', mu1\\n theta_nz = Kb_nz - mu1*Kv1\\n mu = mu1\\n \\n return theta_nz, nz, K, nbr\",\n \"def _reparam(self):\\n\\n k_fe, k_re, k_re2 = self.k_fe, self.k_re, self.k_re2\\n k_tot = k_fe + k_re2\\n ix = np.tril_indices(self.k_re)\\n\\n lin = []\\n for k in range(k_fe):\\n e = np.zeros(k_tot)\\n e[k] = 1\\n lin.append(e)\\n for k in range(k_re2):\\n lin.append(np.zeros(k_tot))\\n\\n quad = []\\n for k in range(k_tot):\\n quad.append(np.zeros((k_tot, k_tot)))\\n ii = np.tril_indices(k_re)\\n ix = [(a,b) for a,b in zip(ii[0], ii[1])]\\n for i1 in range(k_re2):\\n for i2 in range(k_re2):\\n ix1 = ix[i1]\\n ix2 = ix[i2]\\n if (ix1[1] == ix2[1]) and (ix1[0] <= ix2[0]):\\n ii = (ix2[0], ix1[0])\\n k = ix.index(ii)\\n quad[k_fe+k][k_fe+i2, k_fe+i1] += 1\\n for k in range(k_tot):\\n quad[k] = 0.5*(quad[k] + quad[k].T)\\n\\n return lin, quad\",\n \"def _K_computations(self, X, X2):\\r\\n # First extract times and indices.\\r\\n self._extract_t_indices(X, X2)\\r\\n\\r\\n self._K_compute_eq()\\r\\n self._K_compute_ode_eq()\\r\\n if X2 is None:\\r\\n self._K_eq_ode = self._K_ode_eq.T\\r\\n else:\\r\\n self._K_compute_ode_eq(transpose=True)\\r\\n self._K_compute_ode()\\r\\n\\r\\n if X2 is None:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t.shape[0]))\\r\\n else:\\r\\n self._K_dvar = np.zeros((self._t.shape[0], self._t2.shape[0]))\\r\\n\\r\\n # Reorder values of blocks for placing back into _K_dvar.\\r\\n self._K_dvar = np.vstack((np.hstack((self._K_eq, self._K_eq_ode)),\\r\\n np.hstack((self._K_ode_eq, self._K_ode))))\\r\\n self._K_dvar = self._K_dvar[self._rorder, :]\\r\\n self._K_dvar = self._K_dvar[:, self._rorder2]\\r\\n \\r\\n \\r\\n if X2 is None:\\r\\n # Matrix giving scales of each output\\r\\n self._scale = np.zeros((self._t.size, self._t.size))\\r\\n code=\\\"\\\"\\\"\\r\\n for(int i=0;i<N; i++){\\r\\n scale_mat[i+i*N] = B[index[i]+output_dim*(index[i])];\\r\\n for(int j=0; j<i; j++){\\r\\n scale_mat[j+i*N] = B[index[i]+output_dim*index[j]];\\r\\n scale_mat[i+j*N] = scale_mat[j+i*N];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index = self._scale, self.B, self._index\\r\\n N, output_dim = self._t.size, self.output_dim\\r\\n weave.inline(code,['index',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'output_dim'])\\r\\n else:\\r\\n self._scale = np.zeros((self._t.size, self._t2.size))\\r\\n code = \\\"\\\"\\\"\\r\\n for(int i=0; i<N; i++){\\r\\n for(int j=0; j<N2; j++){\\r\\n scale_mat[i+j*N] = B[index[i]+output_dim*index2[j]];\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n scale_mat, B, index, index2 = self._scale, self.B, self._index, self._index2\\r\\n N, N2, output_dim = self._t.size, self._t2.size, self.output_dim\\r\\n weave.inline(code, ['index', 'index2',\\r\\n 'scale_mat', 'B',\\r\\n 'N', 'N2', 'output_dim'])\",\n \"def __init__(self):\\n self.n=0\\n self.K=0\\n self.tuple_data=False\\n self.optimal=0\",\n \"def define_potts_helper_functions(k):\\n\\n @njit\\n def calc_observables(X, k=k):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n\\n Returns\\n -------\\n ndarray\\n Dimensions (n_samples, n_observables).\\n \\\"\\\"\\\"\\n\\n n = X.shape[1]\\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\\n \\n # average orientation (magnetization)\\n # note that fields for the third state are often set to 0\\n counter = 0\\n for i in range(k):\\n for j in range(n):\\n Y[:,counter] = X[:,j]==i\\n counter += 1\\n \\n # pairwise correlations\\n for i in range(n-1):\\n for j in range(i+1, n):\\n Y[:,counter] = X[:,i]==X[:,j]\\n counter += 1\\n \\n return Y\\n\\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n multipliers : ndarray of dtype np.float64\\n\\n Returns\\n -------\\n ndarray\\n Energies of each observable.\\n \\\"\\\"\\\"\\n\\n return -calc_observables(X, k).dot(multipliers)\\n\\n def mch_approximation(sample, dlamda, calc_e=calc_e):\\n \\\"\\\"\\\"Function for making MCH approximation step for Potts model.\\n \\n Parameters\\n ----------\\n sample : ndarray\\n Of dimensions (n_sample, n_spins).\\n dlamda : ndarray\\n Change in parameters.\\n \\n Returns\\n -------\\n ndarray\\n Predicted correlations.\\n \\\"\\\"\\\"\\n\\n dE = calc_e(sample, dlamda)\\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \\n assert not ((predsisj<0).any() or\\n (predsisj>(1+1e-10)).any()),\\\"Predicted values are beyond limits, (%E,%E)\\\"%(predsisj.min(),\\n predsisj.max())\\n return predsisj\\n\\n return calc_e, calc_observables, mch_approximation\",\n \"def cuttingStockKantorovich(w, q, B):\\n\\n model = Model(\\\"Naive Cutting Stock\\\")\\n m = max(w)*max(q) # m rolls\\n n = len(q) # n orders \\n y = {}\\n for j in range(m):\\n y[j] = model.addVar(name = \\\"y[%s]\\\" % j, vtype=\\\"BINARY\\\")\\n \\n x = {}\\n for j in range(m):\\n for i in range(n):\\n x[i,j] = model.addVar(name = \\\"x[%s,%s]\\\" %(i,j), lb = 0, vtype=\\\"INTEGER\\\")\\n model.addCons(x[i,j] <= q[i]*y[j])\\n\\n for i in range(n):\\n model.addCons(quicksum(x[i,j] for j in range(m)) == q[i])\\n\\n for j in range(m):\\n model.addCons((quicksum(w[i]*x[i,j] for i in range(n)) <= B))\\n\\n model.setObjective(quicksum(y[j] for j in range(m)), \\\"minimize\\\")\\n model.hideOutput()\\n model.optimize()\\n\\n return model.getObjVal()\",\n \"def bfgs_method(x0, eps=1e-6, H0=np.eye(18),c1=1e-4):\\n k = 0 # initialize num of outer iterations.\\n inner_k = 0 # initialize inner k iteration.\\n old_xk = None\\n alpha_original = 1\\n alpha = np.copy(alpha_original)\\n xk = x0 # intitialize x.\\n Hk = H0 # initialize H, positive definite matrix.\\n I = np.eye(len(x0)) # idenitity matrix of 2 by 2.\\n\\n alpha_vec = []\\n f_vec = []\\n grad_vec = []\\n inner_k = []\\n conv_c = []\\n\\n while np.linalg.norm(rosen_der(xk)) > eps:\\n pk = -Hk @ rosen_der(xk)\\n\\n xk_next = xk + alpha * pk\\n ink = 0\\n print(xk)\\n while rosen(xk_next) > rosen(xk) + c1 * alpha * (pk.T @ rosen_der(xk)):\\n \\\"\\\"\\\" find a step size that will satisfy Armijo-Goldstein inequality. Modify alpha. \\\"\\\"\\\"\\n alpha = 0.1* alpha\\n xk_next = xk + alpha * pk\\n ink += 1\\n\\n inner_k.append(abs(int(ink)))\\n\\n xk_next = xk + alpha * pk\\n\\n sk = xk_next - xk\\n\\n yk = rosen_der(xk_next) - rosen_der(xk)\\n\\n rho = 1 / (yk.T @ sk)\\n\\n Hk = np.copy((I - rho * sk @ yk.T) @ Hk @ (I - rho * yk @ sk.T) + rho * sk @ sk.T)\\n\\n old_xk = np.copy(xk)\\n xk = np.copy(xk_next)\\n\\n alpha_vec.append(alpha)\\n f_vec.append(rosen(xk))\\n grad_vec.append(np.linalg.norm(rosen_der(xk)))\\n alpha = np.copy(alpha_original)\\n print(f_vec[-1])\\n\\n k += 1\\n\\n return xk, k, inner_k, alpha_vec, f_vec, grad_vec\",\n \"def build_graph(self, values, values_mask, keys_mask, keys, use_mask=True):\\n\\n with vs.variable_scope(\\\"CoAttn\\\"):\\n\\n print('value_vec_size is: ', self.value_vec_size)\\n print('num_values size is: ', values.shape[1])\\n print('num_keys size is: ', keys.shape[1])\\n print('value_vec_size is (key):', keys.shape[2])\\n # Declare variable \\n W = tf.get_variable(\\\"W\\\", shape = (self.value_vec_size, self.value_vec_size), \\\\\\n initializer = tf.contrib.layers.xavier_initializer())\\n b = tf.get_variable(\\\"b\\\", shape = (self.value_vec_size), initializer = tf.constant_initializer(0))\\n\\n # Compute projected question hidden states\\n\\n Q = tf.tanh(tf.tensordot(values, W, 1) + tf.reshape(b, [1, 1, self.value_vec_size])) # (batch_size, num_values, value_vec_size)\\n\\n\\n Q = concat_sentinel('question_sentinel', Q, self.value_vec_size) # (batch_size, num_values, value_vec_size)\\n # Q = tf.nn.dropout(Q, self.keep_prob)\\n print('Q shape is: ', Q.shape)\\n # sentinel = tf.get_variable(name='question_sentinel', shape=tf.shape(Q)[2], \\\\\\n # initializer=tf.contrib.layers.xavier_initializer(), dtype = tf.float32)\\n # sentinel = tf.tile(sentinel, [tf.shape(original_tensor)[0], 1, 1])\\n # concat_tensor = tf.concat([original_tensor, sentinel], 2)\\n\\n print('Q shape is: ', Q.shape)\\n D = keys # (batch_size, num_keys, value_vec_size)\\n D = concat_sentinel('document_sentinel', D, self.value_vec_size)\\n # D = tf.nn.dropout(D, self.keep_prob)\\n\\n # key = document, value = question here\\n ### End your code here to implement 'Sentinel Vector'\\n # Compute affinity matrix L\\n L = tf.matmul(D, tf.transpose(Q, perm=[0, 2, 1])) # shape (batch_size, num_keys, num_values)\\n\\n # Compute Context-to-Question (C2Q) Attention, we obtain C2Q attention outputs\\n if use_mask:\\n print('tf.shape(values)[0] is: ', tf.shape(values)[0])\\n print('tf.ones([tf.shape(values)[0], 1] is ', tf.ones([tf.shape(values)[0], 1], dtype=tf.int32))\\n values_mask = tf.expand_dims(tf.concat([values_mask, tf.ones([tf.shape(values)[0], 1], dtype=tf.int32)], axis=1), 1)\\n print \\\"value_mask shape:\\\", values_mask.shape\\n print \\\"L shape:\\\", L.shape\\n _, A_D = masked_softmax(L, mask=values_mask, dim=2) #(batch_size, num_keys, num_values)\\n else:\\n A_D = tf.nn.softmax(L, dim=-1)\\n\\n C2Q_Attn = tf.matmul(A_D, Q) # (batch_size, num_keys, value_vec_size)\\n print('C2Q_Attn shapeis ', C2Q_Attn.shape)\\n\\n # Compute Question-to-Context (Q2C) Attention, we obtain Q2C attention outputs\\n if use_mask:\\n keys_mask = tf.expand_dims(tf.concat([keys_mask, tf.ones([tf.shape(keys)[0], 1], dtype=tf.int32)], axis=1), 1)\\n print \\\"key_mask shape:\\\", keys_mask.shape\\n print \\\"L shape:\\\", L.shape\\n _, A_Q = masked_softmax(tf.transpose(L, perm=[0, 2, 1]), mask=keys_mask, dim=-1) # (batch_size, num_values, num_keys)\\n else:\\n A_Q = tf.nn.softmax(tf.transpose(L, perm=[0, 2, 1]), dim=2)\\n\\n Q2C_Attn = tf.matmul(A_Q, D) # (batch_size, num_values, key_vec_size)\\n print('Q2C_Attn shapeis ', Q2C_Attn.shape)\\n\\n # Compute second-level attention outputs S\\n S = tf.matmul(A_D, Q2C_Attn) # (batch_size, num_keys, value_vec_size)\\n print('S size is: ', S.shape)\\n\\n # Concatenate C2Q_Attn and S:\\n C_D = tf.concat([D, C2Q_Attn, S], 2) # (batch_size, num_keys, 3 * value_vec_size)\\n # C_D = tf.nn.dropout(C_D, self.keep_prob)\\n print('co_context size is: ', C_D.shape)\\n\\n # co_input = tf.concat([tf.transpose(D, perm = [0, 2, 1]), C_D], 1)\\n # print('co_input size is: ', co_input.shape)\\n size = int(self.value_vec_size)\\n \\n if self.device == 'gpu':\\n bidirection_rnn = tf.contrib.cudnn_rnn.CudnnLSTM(1, size, 3*size, dropout=0.2, direction=cudnn_rnn_ops.CUDNN_RNN_BIDIRECTION, dtype=tf.float32)\\n C_D = tf.transpose(C_D, perm=[1, 0, 2])\\n print 'C_D shape', C_D.shape\\n input_h = tf.zeros([2, tf.shape(values)[0], size])\\n input_c = tf.zeros([2, tf.shape(values)[0], size])\\n params = tf.get_variable(\\\"RNN\\\", shape=(estimate_cudnn_parameter_size(3*self.value_vec_size, size, 2)),\\n initializer=tf.contrib.layers.xavier_initializer(), dtype=tf.float32)\\n \\n U, _, _ = bidirection_rnn(C_D, input_h, input_c, params)\\n#\\n print 'U shape:', U.shape\\n U = tf.transpose(U, perm=[1, 0, 2])\\n\\n else:\\n (u_fw_out, u_bw_out), _ = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), cell_bw=DropoutWrapper(rnn_cell.BasicLSTMCell(size),input_keep_prob=self.keep_prob), \\n inputs=C_D, dtype = tf.float32)\\n U = tf.concat([u_fw_out, u_bw_out], 2)\\n\\n U = tf.nn.dropout(U[:,:-1, :], self.keep_prob)\\n # U = tf.nn.dropout(U, self.keep_prob)\\n print('U shape is: ', U.shape)\\n \\n return U,A_D,A_Q\",\n \"def learn_MAP(self,knowledge,k=10):\\n \\n gradients = {}\\n for i in range(k):\\n\\n #create TILDE(R) tree object\\n tree_i = TILDE(typ=\\\"regression\\\",score=\\\"WV\\\",max_depth=self.max_depth)\\n\\n #subsample negatives if too many for each tree\\n sampled_neg = deepcopy(self.neg)\\n if len(self.neg) > 2*len(self.pos):\\n sampled_neg = sample(self.neg,2*len(self.pos))\\n\\n #compute gradients as I-P\\n for ex in self.examples:\\n parameter = knowledge.calculate_parameter(self.data,\\n ex,\\n self.examples[ex])\\n p = sigmoid(self.examples[ex])\\n if ex in self.pos:\\n gradients[ex] = 1-p - parameter\\n elif ex in sampled_neg:\\n gradients[ex] = 0-p - parameter\\n\\n #fit tree on gradients\\n tree_i.learn(self.data,self.bk,self.target,examples=gradients)\\n \\n #recompute example values as previous example value + tree_i value\\n for ex in self.examples:\\n tree_i_value = tree_i.infer(self.data,ex)\\n self.examples[ex] += tree_i_value\\n\\n #add tree to boosted_trees\\n self.boosted_trees.append(tree_i)\",\n \"def F(N,k=0) :\\n accum = 0.0\\n for i in xrange(1,N+1-k) :\\n accum += (1.0+F(N-1,k+i-1))/N\\n return accum\",\n \"def train(self, data, labels, validationData, validationLabels):\\n \\n # -- calls the classify method to evaluate performance \\n # -- OUR CODE HERE\\n \\n legalLabels = labels\\n self.legalLabels = legalLabels\\n trainingData = validationData\\n trainingLabels = validationLabels\\n \\n kCorrect = util.Counter()\\n self.conditionalProb = []\\n \\n \\n self.prior = util.Counter()\\n for label in labels:\\n self.prior[label] += 1.0\\n self.prior.normalize()\\n #for label in self.prior:\\n # self.prior[label]/=len(trainingLabels)\\n \\n \\\"\\\"\\\"\\n print \\\"legal labels are \\\", len(legalLabels)\\n print \\\"kgrid is \\\", kgrid\\n print \\\"the legal labels are.... \\\", legalLabels\\n \\\"\\\"\\\"\\n \\n import time\\n \\n condprobForK = {}\\n \\n # -- iterate through each k in kgrid... should we be doing this?\\n # -- won't this affect the cond prob tables? :(\\n k = 0.5\\n #print \\\"working on k = \\\",k,\\\" in kgrid\\\"\\n \\n # -- reset the conditonal prob table\\n # -- each time we go through a different k...\\n self.conditionalProb = {}\\n \\n # -- go through each label and initialize the Counter for that label (the cond prob table)\\n for label in legalLabels:\\n self.conditionalProb[label] = util.Counter()\\n \\n # -- go through each piece of training data and train the tables on it \\n for dataNum in range(len(trainingData)):\\n \\n # -- identify which label we're using... not sure if this is correct\\n label = trainingLabels[dataNum] # 0 or like 9 or 2\\n \\n # -- iterate through each pixel and update the conditional prob counter for that label\\n for pixel in trainingData[dataNum]:\\n \\n if pixel is \\\"moreThanOneConnBlackRegions\\\":\\n #print \\\"Number is :: \\\", label, \\\" and has \\\", trainingData[dataNum][pixel]\\n assert 1 is 1\\n \\n on_off = trainingData[dataNum][pixel] * 1.0\\n self.conditionalProb[label][pixel] += on_off * 1.0\\n \\n # -- now we go through and add k to each of the conditional probabilities\\n # -- note that we do so for each label and every single pixel\\n for label in legalLabels:\\n for pixel in self.conditionalProb[label]: \\n # -- add the k value \\n self.conditionalProb[label][pixel] += k * 1.0\\n assert self.conditionalProb[label][pixel] >= k # -- sanity check that it should be at least k\\n self.conditionalProb[label][pixel] /= (self.prior[label] * len(trainingLabels) + k*2)\\n \\n \\n \\n # -- END OUR CODE\",\n \"def _k(self, T):\\n RT = Rgas * T\\n return (self.parameters.A1 / np.exp(self.parameters.E1 / RT),\\n self.parameters.A2 / np.exp(self.parameters.E2 / RT))\",\n \"def f(X_,K_):\\r\\n return max(exp(X_)-K_,0)\",\n \"def dealer_probs():\\n # Pdf of any current hand (value, hard) and final value; p(v_f | v_c) where v_f = final value, v_c = current value\\n probabilities = {}\\n\\n # End nodes: (value, True) for value >= 17 and (value, False) for value > 17\\n # Dependencies (in order of increasing requirements):\\n # Hard values, value >= 11, possiblity of bust, no possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value\\n # Soft values, 17 >= value >= 11 (value, False) depends on (value', False) for 17 >= value' > value, (value', True) for 17 > value' > 11\\n # Hard values, 11 > value >= 2 , no possibility of bust, possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value and (value', False) for 17 >= value' > 13\\n\\n\\n # End nodes\\n for value in xrange(17, 22):\\n probabilities[(value, True)] = {value: 1.0}\\n if value == 17: continue # on soft 17, dealer will still hit\\n probabilities[(value, False)] = {value: 1.0}\\n\\n # Hard values, 17 > value >= 11, possibility of bust, no possibility of going soft with an ace\\n for value in xrange(16, 10, -1):\\n probabilities[(value, True)] = {}\\n current_prob = probabilities[(value, True)]\\n for next_card in xrange(1, min(10, 21-value)+1):\\n next_prob = probabilities[(value + next_card, True)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n # Soft values, 17 >= value >= 11\\n for value in xrange(17, 10, -1):\\n probabilities[(value, False)] = {}\\n current_prob = probabilities[(value, False)]\\n for next_card in xrange(1, 11):\\n next_value = value + next_card\\n hard = False\\n if next_value > 21:\\n next_value -= 10\\n hard = True\\n next_prob = probabilities[(next_value, hard)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n # Hard values, 11 > value >= 2, no possibility of bust, possibility of going soft with an ace\\n for value in xrange(10, 1, -1):\\n probabilities[(value, True)] = {}\\n current_prob = probabilities[(value, True)]\\n for next_card in xrange(2, 12):\\n next_value = value + next_card\\n hard = (next_card != 11)\\n next_prob = probabilities[(next_value, hard)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n return probabilities\",\n \"def value_iteration(P, nS, nA, gamma=0.9, tol=1e-3):\\n\\n\\tvalue_function = np.zeros(nS)\\n\\tpolicy = np.zeros(nS, dtype=int)\\n\\tmax_num_iterations = 2000\\n\\n\\t############################\\n\\t# YOUR IMPLEMENTATION HERE #\\n\\n\\tfor i in range(max_num_iterations):\\n\\t\\tprevious_value_function = np.copy(value_function)\\n\\t\\tfor s in range(nS):\\t# for each state\\n\\t\\t\\tq_values = np.zeros(nA)\\n\\t\\t\\tfor action in range(nA):\\t# for each action\\n\\t\\t\\t\\tq_value = 0\\n\\t\\t\\t\\tfor transition in P[s][action]:\\t# for every possible transition\\n\\t\\t\\t\\t\\tprobability = transition[0]\\n\\t\\t\\t\\t\\treward = transition[2]\\n\\t\\t\\t\\t\\tnext_state = transition[1]\\n\\t\\t\\t\\t\\tvalue_next_state = previous_value_function[next_state]\\n\\n\\t\\t\\t\\t\\t# print(\\\"probability: \\\" + str(probability) + \\\"reward: \\\" + str(reward) + \\\"value next state: \\\" + str(value_next_state))\\n\\n\\t\\t\\t\\t\\tq_value += probability * (reward + gamma * value_next_state)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tq_values[action] = q_value\\n\\n\\t\\t\\tvalue_function[s] = np.amax(q_values)\\t# the value is the max of these q values\\n\\t\\t\\t# extract policy\\n\\t\\t\\tpolicy[s] = np.argmax(q_values)\\n\\n\\t\\t# find the maximum difference between the previous value function and the current value function\\n\\t\\tdifArray = np.subtract(value_function, previous_value_function)\\n\\t\\tfor x in range(nS):\\n\\t\\t\\tdifArray[x] = abs(difArray[x])\\n\\t\\tmaxDif = np.amax(difArray)\\n\\n\\t\\tif (maxDif < tol):\\n\\t\\t\\tprint(\\\"optimal policy found at iteration \\\" + str(i + 1))\\n\\t\\t\\tbreak\\n\\n\\t############################\\n\\treturn value_function, policy\",\n \"def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 4th order calculation\\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\\n \\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n\\n # Calculate truncation error between 5th and 4th order\\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\\n \\n # Compare eps to emin and emax and update h accordingly\\n if np.max(eps) < emin:\\n if h*2.0 < hmax:\\n h *= 2.0\\n new_v = new_v5\\n new_r = new_r5 \\n \\n if np.max(eps) > emax:\\n if h/2.0 > hmin:\\n h /= 2.0\\n print h\\n # Error too large, call rk_adaptive again with smaller h\\n if recur < recurmax:\\n recur += 1\\n rk_adaptive(accel,m,r,h,v,recur)\\n new_v = new_v5\\n new_r = new_r5\\n \\n else:\\n new_v = new_v5\\n new_r = new_r5\\n \\n return new_v, new_r, h\",\n \"def generate_pn2kc_weights(nb_pn, nb_kc, min_pn=10, max_pn=20, aff_pn2kc=None, nb_trials=100000, baseline=25000,\\r\\n rnd=np.random.RandomState(2018), dtype=np.float32):\\r\\n\\r\\n dispersion = np.zeros(nb_trials)\\r\\n best_pn2kc = None\\r\\n\\r\\n for trial in range(nb_trials):\\r\\n pn2kc = np.zeros((nb_pn, nb_kc), dtype=dtype)\\r\\n\\r\\n if aff_pn2kc is None or aff_pn2kc <= 0:\\r\\n vaff_pn2kc = rnd.randint(min_pn, max_pn + 1, size=nb_pn)\\r\\n else:\\r\\n vaff_pn2kc = np.ones(nb_pn) * aff_pn2kc\\r\\n\\r\\n # go through every kenyon cell and select a nb_pn PNs to make them afferent\\r\\n for i in range(nb_pn):\\r\\n pn_selector = rnd.permutation(nb_kc)\\r\\n pn2kc[i, pn_selector[:vaff_pn2kc[i]]] = 1\\r\\n\\r\\n # This selections mechanism can be used to restrict the distribution of random connections\\r\\n # compute the sum of the elements in each row giving the number of KCs each PN projects to.\\r\\n pn2kc_sum = pn2kc.sum(axis=0)\\r\\n dispersion[trial] = pn2kc_sum.max() - pn2kc_sum.min()\\r\\n # pn_mean = pn2kc_sum.mean()\\r\\n\\r\\n # Check if the number of projections per PN is balanced (min max less than baseline)\\r\\n # if the dispersion is below the baseline accept the sample\\r\\n if dispersion[trial] <= baseline: return pn2kc\\r\\n\\r\\n # cache the pn2kc with the least dispersion\\r\\n if best_pn2kc is None or dispersion[trial] < dispersion[:trial].min():\\r\\n best_pn2kc = pn2kc\\r\\n\\r\\n # if non of the samples have dispersion lower than the baseline,\\r\\n # return the less dispersed one\\r\\n return best_pn2kc\",\n \"def _goalFunction(D, G, U, K, n, m):\\n J = 0\\n for k in range(K):\\n for i in range(n):\\n u = U[i][k] ** m\\n d = _extendedDissimilarity(D, G[k], i)\\n J += u * d\\n return J\",\n \"def rk5(accel,m,r,h,v):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n \\n return new_v5, new_r5\",\n \"def n_choose_k(N,K):\\n return factorial(N) // (factorial(N - K) * factorial(K))\",\n \"def Q_credit_checkers(s_grid, s_n, g_n, a_m, s_m, s_others, t_obs, v_obs,\\n f1=4, k1=[3,5], f2=6, k2=[3,3],\\n n_h1_1=128, n_h1_2=32, n_h2=32, stage=2, bias=True):\\n conv = convnet_1(s_grid, f1=f1, k1=k1, s1=[1,1], scope='conv')\\n conv_o = convnet_1(t_obs, f1=f2, k1=k2, s1=[1,1], scope='conv_o')\\n concated = tf.concat( [conv, s_n, g_n, a_m, conv_o, v_obs], axis=1 )\\n branch1 = tf.layers.dense(inputs=concated, units=n_h1_1, activation=tf.nn.relu, use_bias=bias, name='Q_branch1')\\n W_branch1_h2 = get_variable(\\\"W_branch1_h2\\\", [n_h1_1, n_h2])\\n\\n list_mult = []\\n list_mult.append( tf.matmul(branch1, W_branch1_h2) )\\n\\n if stage > 1:\\n with tf.variable_scope(\\\"stage-2\\\"):\\n concated2 = tf.concat( [s_m, s_others], axis=1 )\\n others = tf.layers.dense(inputs=concated2, units=n_h1_2, activation=tf.nn.relu, use_bias=bias, name='Q_branch2')\\n W_branch2_h2 = get_variable('W_branch2_h2', [n_h1_2, n_h2])\\n list_mult.append(tf.matmul(others, W_branch2_h2))\\n\\n h2 = tf.nn.relu(tf.add_n(list_mult, name='Q_h2'))\\n out = tf.layers.dense(inputs=h2, units=1, activation=None, use_bias=bias, name='Q_out')\\n \\n return out\",\n \"def n_choose_kv(newK):\\n values = np.zeros((1,newK+1))\\n ks = np.arange(newK+1)\\n \\n for i in range(newK+1):\\n values[i] = scipy.misc.comb(newK, ks[i])\\n\\n return values\",\n \"def binary_dec(A,n_iter = 1000):\\n\\n\\t### Initialization ###\\n\\n\\tp, q = np.shape(A)\\n\\t### B : to be changed\\n\\tB = np.eye(p)\\n \\t###\\n\\tC = bin_random_mat(p,q)\\n\\tlist_dist = []\\n\\tB_argmin = B\\n\\tC_argmin = C\\n\\n\\n\\n\\n\\t## temperature ##\\n\\tT_n = np.log(np.arange(2,n_iter+2,1))\\n\\t#T_n = np.arange(2,n_iter+2,1)\\n\\tfor i in range(n_iter):\\n\\t## update ##\\n\\t\\tC_0 = np.matrix(C)\\n\\t\\tlist_dist =np.append( list_dist, V_potential(np.dot(B,C_0),A) )\\n\\t\\tif V_potential(np.dot(B_argmin,C_argmin),A) == 0:\\n\\t\\t\\tbreak\\n\\t########## transition #############\\n\\t# Here we take 2 steps independent(for B and for C respectively)\\n\\t# We could also use metropolis hasting kernel.\\n\\n\\t\\tC_iter = np.matrix(Metropolis_transition_C(C))\\n\\t\\n\\n\\t\\tB_iter = B[np.random.permutation(np.arange(p))]\\n\\t\\t\\n\\t\\tif np.random.uniform(0,1,1) < \\\\\\n\\t\\t\\t\\tnp.exp(-1./T_n[i]*( V_potential(np.dot(B_iter,C_iter), A)\\\\\\n\\t\\t\\t\\t - V_potential(np.dot(B,C_0),A) ) ):\\n\\t\\t\\tC = C_iter\\n\\t\\t\\tB = B_iter\\n\\t######### end of transition ##############\\n\\n\\t\\t\\tif V_potential(np.dot(B,C),A) < np.min(list_dist):\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tB_argmin = B\\n\\t\\t\\t\\tC_argmin = np.matrix(C)\\n\\t\\t\\t# print i+1\\n\\t\\t\\t# print V_potential(np.dot(B_argmin,C_argmin),A)\\n\\t\\t\\t# print C_argmin\\n\\t\\t\\t# print '\\\\n'\\n\\n\\treturn list_dist,B_argmin, C_argmin\",\n \"def combinations(n, k):\\r\\n return exp(gammaln(n + 1) - gammaln(k + 1) - gammaln(n - k + 1))\",\n \"def solveForModeB1(X, M, n, maxInner, epsilon, tol,sita,Y1, lambta2):\\n # Pi(n) = [A(N) kr A(N-1) kr ... A(n+1) kr A(n-1) kr .. A(1)]^T\\n Pi = tensorTools.calculatePi(X, M, n)\\n #print 'Pi size', Pi.shape\\n #print 'pi='+str(Pi)\\n #print(M.U[n])\\n for iter in range(maxInner):\\n # Phi = (X(n) elem-div (B Pi)) Pi^T\\n #print X.vals.shape,X.shape\\n #print X.vals.flatten().shape\\n Phi = tensorTools.calculatePhi(X, M.U[n], Pi, n, epsilon=epsilon)\\n #print('phi'+str(Phi))\\n #print(Phi)\\n # check for convergence that min(B(n), E - Phi(n)) = 0 [or close]\\n kktModeViolation = np.max(np.abs(np.minimum(M.U[n], 1-Phi).flatten()))\\n if (kktModeViolation < tol):\\n break\\n\\n B=M.U[n]\\n #print B.shape\\n colNorm = np.apply_along_axis(np.linalg.norm, 0, B, 1)\\n zeroNorm = np.where(colNorm == 0)[0]\\n colNorm[zeroNorm] = 1\\n B = B / colNorm[np.newaxis, :]\\n tm=np.hstack((np.ones((B.shape[0],1)),B))\\n Y1=Y1.reshape((Y1.shape[0],1))\\n\\n derive=-1.0*lambta2/B.shape[0]*np.dot((Y1-np.dot(tm,sita)),sita.T)\\n #print derive.shape\\n #print np.multiply(M.U[n],derive[:,1:]).shape\\n #print np.multiply(M.U[n],Phi).shape\\n M.U[n] = np.array(np.multiply(M.U[n],Phi))-np.array((np.multiply(M.U[n],derive[:,1:])))\\n\\n #print 'after'\\n #print M.U[n][0]\\n #print(\\\" Mode={0}, Inner Iter={1}, KKT violation={2}\\\".format(n, iter, kktModeViolation))\\n return M, Phi, iter, kktModeViolation\",\n \"def method_2d(knots,y_n,num):\\n cv_iter = 10 # number of iteration for cross-validation \\n GSV = np.zeros((cv_iter,cv_iter))\\n# tr = np.zeros((cv_iter,cv_iter))\\n# fun =np.zeros((cv_iter,cv_iter))\\n lam_x = np.linspace(0,0.2,cv_iter)\\n lam_y = np.linspace(0,0.2,cv_iter)\\n num_knots = len(knots)\\n linear_knots = knots[1:num_knots-1]\\n num_knots = num_knots-4\\n znam = np.zeros((num_knots))\\n basis = np.zeros((num,num_knots))\\n basis_1 = np.zeros((num,num_knots))\\n basis_deriative = np.zeros((num,num_knots))\\n basis_deriative_1 = np.zeros((num,num_knots))\\n S = np.zeros((num_knots,num_knots,num))\\n vs = BsplineVectorSpace(2, knots)\\n vs_1 = BsplineVectorSpace(1, linear_knots)\\n I_i = np.eye(num_knots)\\n for i in xrange(0,num_knots):\\n basis[:,i] = vs.basis_der(i,0)(np.linspace(0,1,num))\\n basis_deriative[:,i] = vs.basis_der(i,1)(np.linspace(0,1,num))/num\\n basis_1[:,i] = vs_1.basis_der(i,0)(np.linspace(0,1,num))\\n basis_deriative_1[:,i] = vs_1.basis_der(i,1)(np.linspace(0,1,num))/num\\n B = abs(basis_deriative-basis_1)\\n S = np.zeros((num_knots,num_knots,num))\\n k = np.zeros((num_knots,num_knots,num))\\n for i in xrange(num_knots):\\n for j in xrange(num_knots):\\n S[i,j,:] = B[:,i]*B[:,j]\\n k[i,j,:] =basis_deriative_1[:,i] * basis_deriative_1[:,j]\\n S_int = np.zeros((num_knots,num_knots))\\n k_int = np.zeros((num_knots,num_knots))\\n for i in xrange(num_knots):\\n for j in xrange(num_knots):\\n S_int[i,j] = integrate.trapz(S[i,j,:])\\n k_int[i,j] = integrate.trapz(k[i,j,:])\\n basis_product = np.kron(basis,basis)\\n S_x = np.kron(S_int,I_i)\\n S_y = np.kron(I_i,S_int)\\n K_x = np.kron(k_int,I_i)\\n K_y = np.kron(I_i,k_int)\\n for i in xrange(cv_iter):\\n for j in xrange(cv_iter):\\n influence_matrix = np.dot(np.dot(basis_product,(np.linalg.inv(np.dot(np.transpose(\\n basis_product),basis_product)+lam_x[i]*S_x+lam_y[j]*S_y+lam_x[i]* K_x+lam_y[j]*K_y))),np.transpose(basis_product))\\n for k in xrange(num_knots):\\n znam[k] =(1-influence_matrix[k,k])**2\\n tr = np.sum(znam)\\n fun = np.sum((y_n-np.dot(influence_matrix,y_n))**2)\\n GSV[i,j] =fun/(num*tr)\\n print i,j\\n a,b = np.unravel_index(GSV.argmin(), GSV.shape)\\n# a = np.argmin(np.argmin(GSV,axis = 0))\\n# b = np.argmin(np.argmin(GSV,axis = 1))\\n lamb_x = lam_x[a]\\n lamb_y = lam_y[b]\\n print lamb_x,lamb_y\\n model_fit = np.dot(np.dot(np.dot(basis_product,(np.linalg.inv(np.dot(np.transpose(\\n basis_product),basis_product)+lamb_x*S_x+lamb_y*S_y+lamb_x* K_x+lamb_y*K_y))),np.transpose(basis_product)),y_n)\\n return model_fit,GSV\",\n \"def trainAndTune(self, trainingData, trainingLabels, validationData, validationLabels, kgrid):\\n\\n\\tself.conditional_prob_table = util.Counter()\\n\\tself.prior_distribution_prob_table = util.Counter()\\n\\tself.conditional_prob = {}\\n\\tself.prior_distribution_prob = {}\\n\\titeration = 0 # use to symbolize which k value we are for storage in dict, since k is a float\\n\\t\\n\\t#iterate through all k values to obtain best probabilities prior/cond\\n\\tfor k in kgrid:\\n\\t\\tprint \\\"K value: \\\", k, \\\" Iteration: \\\", iteration\\n\\t\\t# helper function to calculate prior dist prob and conditional prob\\n\\t\\tself.trainAndTuneHelper(trainingData, trainingLabels, k) \\n\\t\\t# Set weights in tables before next iteration, save all data to choose highest probabilities at the end\\n\\t\\tself.conditional_prob_table[iteration] = self.conditional_prob \\n\\t\\tself.prior_distribution_prob_table[iteration] = self.prior_distribution_prob\\n\\t\\titeration += 1 #represents k value since k is a float \\n\\t\\t\\n\\t# Assign highest conditional probability and prior distribution probability, pull from dictionaries\\n\\tself.conditional_prob = self.conditional_prob_table[max(self.conditional_prob_table, key=self.conditional_prob_table.get)]\\n\\tself.prior_distribution_prob = self.prior_distribution_prob_table[max(self.prior_distribution_prob_table, key=self.prior_distribution_prob_table.get)]\",\n \"def brute_force_inference(self):\\n\\n counter = 0\\n for k, v in self.vs.items():\\n if not v.observed:\\n counter += 1\\n\\n Z = 0.0\\n for config_lst in it.product([0, 1], repeat=counter * self.N):\\n config = np.asarray(config_lst)\\n\\n # set values\\n counter = 0\\n for k, v in self.vs.items():\\n if not v.observed:\\n val = config[counter*self.N:(counter+1)*self.N]\\n v.b = val\\n counter += 1\\n \\n # get scores\\n config_score = 1.0\\n for k, f in self.fs.items():\\n vecs = [e.v.b for e in f.edges]\\n score = exp(dot(dot(vecs[0], f.tp.F), vecs[1]))\\n config_score *= score\\n\\n Z += config_score\\n print \\\"Z\\\", Z\",\n \"def __init__(self, k):\\n self.k = k\\n self.N = 2**self.k\",\n \"def _step(self) -> Dict[str, tf.Tensor]:\\n\\n # Pull out the data needed for updates/priorities.\\n inputs = next(self._iterator)\\n\\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\\n keys, probs = inputs.info[:2]\\n\\n with tf.GradientTape() as tape:\\n # Evaluate our networks.\\n # `qv` means quantile values\\n # Shape: [B, A, num_quantiles]\\n qv_tm1 = self._network(o_tm1)\\n qv_t = self._target_network(o_t) # [B, A, num_quantiles]\\n q_t_selector = tf.reduce_mean(\\n self._network(o_t) if self._double_dqn else self._target_network(o_t),\\n axis=-1)\\n\\n # Shape: [B]\\n a_t = tf.argmax(q_t_selector, axis=1, output_type=tf.int32)\\n\\n # The rewards and discounts have to have the same type as network values.\\n r_t = tf.clip_by_value(tf.cast(r_t, qv_tm1.dtype), -1., 1.)\\n d_t = tf.cast(d_t, qv_tm1.dtype) * tf.cast(self._discount, qv_tm1.dtype)\\n\\n # Calculate actions value distribution\\n qv_a_tm1 = slice_with_actions(qv_tm1, a_tm1) # [B, num_quantiles]\\n\\n # Scale and shift time-t distribution atoms by discount and reward.\\n qv_a_t = slice_with_actions(qv_t, a_t) # [B, num_quantiles]\\n # Shape: [B, num_quantiles]\\n target = tf.stop_gradient(r_t[:, None] + d_t[:, None] * qv_a_t)\\n\\n # Calculate quantile huber loss\\n # Shape: [B, num_quantiles, num_quantiles]\\n bellman_errors = target[:, None, :] - qv_a_tm1[:, :, None]\\n tau = tf.linspace(0.0, 1.0, self._num_quantiles + 1)\\n tau_hat = ((tau[1:] + tau[:-1]) / 2.0)[None, :, None]\\n\\n # Compute the loss.\\n # Shape: [B, num_quantiles, num_quantiles]\\n # huber_loss_case_one = tf.cast(tf.abs(bellman_errors) <= self._kappa,\\n # tf.float32) * 0.5 * bellman_errors ** 2\\n # huber_loss_case_two = tf.cast(tf.abs(bellman_errors) > self._kappa,\\n # tf.float32) * self._kappa * (\\n # tf.abs(bellman_errors) - 0.5 * self._kappa)\\n # huber_loss = huber_loss_case_one + huber_loss_case_two\\n huber_loss = losses.huber(bellman_errors, self._kappa)\\n\\n # Shape: [B, num_quantiles, num_quantiles]\\n quantile_huber_loss = (tf.abs(tau_hat - tf.stop_gradient(\\n tf.cast(bellman_errors < 0, tf.float32))) * huber_loss) / self._kappa\\n\\n # Shape: [B]\\n loss = tf.reduce_mean(tf.reduce_sum(quantile_huber_loss, axis=2), axis=1)\\n td_errors = tf.identity(loss)\\n\\n # Get the importance weights.\\n importance_weights = 1. / probs # [B]\\n importance_weights **= self._importance_sampling_exponent\\n importance_weights /= tf.reduce_max(importance_weights)\\n\\n # Reweight.\\n loss *= tf.cast(importance_weights, loss.dtype) # [B]\\n loss = tf.reduce_mean(loss, axis=[0]) # []\\n\\n # Do a step of SGD.\\n gradients = tape.gradient(loss, self._network.trainable_variables)\\n self._optimizer.apply(\\n gradients, self._network.trainable_variables)\\n\\n # Update the priorities in the replay buffer.\\n if self._replay_client:\\n priorities = tf.cast(tf.sqrt(td_errors + 1e-10), tf.float64)\\n self._replay_client.update_priorities(\\n table=adders.DEFAULT_PRIORITY_TABLE, keys=keys, priorities=priorities)\\n\\n # Periodically update the target network.\\n if tf.math.mod(self._num_steps, self._target_update_period) == 0:\\n trfl.update_target_variables(\\n target_variables=self._target_network.variables,\\n source_variables=self._network.variables)\\n self._num_steps.assign_add(1)\\n\\n # Report loss & statistics for logging.\\n fetches = {\\n 'loss': loss,\\n }\\n\\n return fetches\",\n \"def birank(W, u0=None, v0=None,\\n alpha=0.85, beta=0.85, max_iter=200, tol=1.0e-4, verbose=False):\\n # default initial vectors: 1/|U|, 1/|V|\\n if u0 is None:\\n u0=np.repeat(1 / W.shape[0], W.shape[0])\\n if v0 is None:\\n v0=np.repeat(1 / W.shape[1], W.shape[1])\\n\\n\\n W = W.astype('float', copy=False)\\n WT = W.T\\n\\n Ku = np.array(W.sum(axis=1)).flatten()\\n Kv = np.array(W.sum(axis=0)).flatten()\\n # avoid divided by zero issue\\n Ku[np.where(Ku==0)] += 1\\n Kv[np.where(Kv==0)] += 1\\n\\n Ku_ = spa.diags(1/Ku)\\n Kv_ = spa.diags(1/Kv)\\n\\n Ku_bi = spa.diags(1/np.sqrt(Ku))\\n Kv_bi = spa.diags(1/np.sqrt(Kv))\\n Sv = Kv_bi.dot(WT).dot(Ku_bi)\\n Su = Sv.T\\n\\n\\n u_last = u0.copy()\\n v_last = v0.copy()\\n\\n for i in range(max_iter):\\n u = alpha * (Su.dot(v_last)) + (1-alpha) * u0\\n v = beta * (Sv.dot(u_last)) + (1-beta) * v0\\n\\n err_u = np.absolute(u - u_last).sum()\\n err_v = np.absolute(v - v_last).sum()\\n \\n if verbose:\\n print(\\n \\\"Iteration : {}; top error: {}; bottom error: {}\\\".format(\\n i, err_u, err_v\\n )\\n )\\n if err_v < tol and err_u < tol:\\n break\\n u_last = u\\n v_last = v\\n\\n return u, v\",\n \"def get_cost_updates(self, lr=0.1, k=1):\\n\\n # compute positive phase\\n pre_sigmoid_ph, ph_mean, ph_sample = self.sample_h_given_v(self.input)\\n\\n # decide how to initialize persistent chain:\\n # for CD, we use the newly generate hidden sample\\n chain_start = ph_sample\\n\\n # perform actual negative phase\\n # in order to implement CD-k/PCD-k we need to scan over the\\n # function that implements one gibbs step k times.\\n # Read Theano tutorial on scan for more information :\\n # http://deeplearning.net/software/theano/library/scan.html\\n # the scan will return the entire Gibbs chain\\n\\n # noinspection PyCallingNonCallable, PyUnusedLocal\\n (\\n [\\n pre_sigmoid_nvs,\\n nv_means,\\n nv_samples,\\n pre_sigmoid_nhs,\\n nh_means,\\n nh_samples\\n ],\\n updates\\n ) = theano.scan(\\n self.gibbs_hvh,\\n # the None are place holders, saying that\\n # chain_start is the initial state corresponding to the\\n # 6th output\\n outputs_info=[None, None, None, None, None, chain_start],\\n n_steps=k\\n )\\n # determine gradients on RBM parameters\\n # note that we only need the sample at the end of the chain\\n chain_end = nv_samples[-1]\\n\\n cost = \\\\\\n T.mean(self.free_energy(self.input)) - \\\\\\n T.mean(self.free_energy(chain_end))\\n\\n regularization = \\\\\\n (self.lmbda / 2.) * \\\\\\n (T.mean(T.sum(T.sqr(self.hidden_layer.W), axis=1)))\\n\\n cost += regularization\\n\\n learning_rate = T.cast(0.01, dtype=DTYPES.FLOATX)\\n\\n # noinspection PyUnusedLocal\\n def regulared(pidx, param):\\n # We must not compute the gradient through the gibbs sampling\\n grad = T.grad(cost, param, consider_constant=[chain_end])\\n current_cost = learning_rate * grad\\n updates[param] = param - current_cost\\n\\n def momentumed(pidx, param):\\n if len(self.Ms) < pidx + 1:\\n # initialize momentum for this element to zeros\\n self.Ms.append(theano.shared(\\n param.get_value() * 0.,\\n broadcastable=param.broadcastable\\n ))\\n # self.Ms.append(theano.shared(0.))\\n\\n M_update = self.Ms[pidx]\\n\\n momentum = T.cast(self.momentum, dtype=DTYPES.FLOATX)\\n mom = momentum * M_update\\n\\n grad = T.grad(\\n cost,\\n param,\\n consider_constant=[chain_end]\\n )\\n\\n v_prime = mom - learning_rate * grad\\n w_prime = param + v_prime\\n updates[M_update] = v_prime\\n updates[param] = w_prime\\n\\n # noinspection PyUnusedLocal\\n def rmsproped(pidx, param):\\n # NOTE : matrix of learning rates\\n if len(self.MSs) < pidx + 1:\\n self.MSs.append(theano.shared(\\n (param.get_value() * 0.) + 1,\\n broadcastable=param.broadcastable\\n ))\\n\\n # # NOTE: single scalar\\n # if len(self.MSs) < pidx + 1:\\n # self.MSs.append(theano.shared(1.))\\n\\n MS_update = self.MSs[pidx]\\n\\n grad = T.grad(cost, param, consider_constant=[chain_end])\\n\\n decay = T.cast(.9, dtype=DTYPES.FLOATX)\\n one_minus_decay = T.cast(.1, dtype=DTYPES.FLOATX)\\n\\n # NOTE: matrix of learning weights\\n current_rmsprop = \\\\\\n (decay * MS_update) + \\\\\\n (one_minus_decay * T.sqrt(T.sum(T.sqr(grad))))\\n\\n # # NOTE: single scalar\\n # current_rmsprop = \\\\\\n # (decay * MS_update) + \\\\\\n # (one_minus_decay * T.mean(T.sqr(grad)))\\n\\n updates[MS_update] = current_rmsprop\\n\\n learning_rate = .1 / current_rmsprop\\n # learning_rate = T.sqrt(\\n # T.cast(current_rmsprop, dtype=DTYPES.FLOATX)\\n # )\\n # if True:\\n # learning_rate = theano.printing.Print('lr')(learning_rate)\\n\\n updates[param] = param - (learning_rate * grad)\\n # updates[param] = param - (grad / learning_rate)\\n\\n # constructs the update dictionary\\n for pidx, param in enumerate(self.params):\\n # regulared(pidx, param)\\n momentumed(pidx, param)\\n # rmsproped(pidx, param)\\n\\n # reconstruction cross-entropy is a better proxy for CD\\n monitoring_cost = self.get_reconstruction_cost(\\n pre_sigmoid_nvs[-1]\\n )\\n\\n self.monitoring_cost = monitoring_cost\\n self.updates = updates\\n self.learning_rate = lr\",\n \"def rk8(accel,m,r,h,v): \\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\\n\\n\\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \\n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \\n \\n return new_v8,new_r8\",\n \"def weiner_tf(H, K):\\r\\n\\r\\n W = (1 / H) * ((np.conjugate(H) * H) / ((np.conjugate(H) * H) + K))\\r\\n return W\",\n \"def weighted_current(h,nk=400,fun=None):\\n if fun is None:\\n delta = 0.01\\n def fun(e): return (-np.tanh(e/delta) + 1.0)/2.0\\n jgs = np.zeros(h.intra.shape[0]) # current array\\n hkgen = h.get_hk_gen() # generator\\n fj = current_operator(h) # current operator\\n ks = np.linspace(0.0,1.0,nk,endpoint=False) # k-points\\n for k in ks: # loop\\n hk = hkgen(k) # Hamiltonian\\n (es,ws) = lg.eigh(hk) # diagonalize\\n ws = ws.transpose() # transpose\\n jk = fj(k) # get the generator\\n for (e,w) in zip(es,ws): # loop\\n weight = fun(e) # weight\\n print(weight)\\n d = np.conjugate(w)*ket_Aw(jk,w) # current density\\n jgs += d.real*weight # add contribution\\n# jgs += (np.abs(w)**2*weight).real # add contribution\\n jgs /= nk # normalize\\n print(\\\"Total current\\\",np.sum(jgs))\\n np.savetxt(\\\"CURRENT1D.OUT\\\",np.matrix([range(len(jgs)),jgs]).T)\",\n \"def B(self, s, t, n):\\n\\n if n == 0:\\n return 1\\n elif min(len(s), len(t)) < n:\\n return 0\\n if (s[:-1], t, n) in self.B_st.keys():\\n B1 = self.B_st[(s[:-1], t, n)]\\n else:\\n B1 = self.B(s[:-1], t, n)\\n #self.B_st[(s[:-1], t, n)] = B1\\n if (s, t[:-1], n) in self.B_st.keys():\\n B2 = self.B_st[(s, t[:-1], n)]\\n else:\\n B2 = self.B(s, t[:-1], n)\\n #self.B_st[(s, t[:-1], n)] = B2 \\n \\n if (s[:-1], t[:-1], n) in self.B_st.keys():\\n B3 = self.B_st[(s[:-1], t[:-1], n)]\\n else:\\n B3 = self.B(s[:-1], t[:-1], n)\\n #self.B_st[(s[:-1], t[:-1], n)] = B3\\n result = self.decay_param * (B1 + B2 - self.decay_param * B3)\\n if s[-1] == t[-1]:\\n if (s[:-1], t[:-1], n-1) in self.B_st.keys():\\n B4 = self.B_st[(s[:-1], t[:-1], n-1)]\\n else:\\n B4 = self.B(s[:-1], t[:-1], n-1)\\n #self.B_st[(s[:-1], t[:-1], n-1)] = B4\\n result += (self.decay_param ** 2) * B4\\n return result\",\n \"def assertB(n, k):\\n assert 0 <= k <= n\\n return (factorial(n)//factorial(k))//factorial(n-k)\",\n \"def compute_gp_parameters(K, K_star2, K_star, true_values, sigma_n=0.5):\\r\\n n = K.shape[0]\\r\\n d = 1 # Dimension\\r\\n f_bar_star = np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n ** 2) * np.eye(n)), true_values.reshape([n, d]))) #Prediction Function\\r\\n\\r\\n cov_f_star = K_star2 - np.dot(K_star, np.dot(np.linalg.inv(K + (sigma_n ** 2) * np.eye(n)), K_star.T)) # Covariance Function\\r\\n\\r\\n return (f_bar_star, cov_f_star)\",\n \"def wabbits(n, k):\\n a, b = 1, 1\\n for i in range(3, n+1):\\n a, b = b, a*k + b\\n return b\",\n \"def experiment(improved):\\n\\n N_list = [5 ,10 ,20]\\n K_list = [3 , 7 ,9]\\n P_list = [0.3 , 0.4 , 0.5 ,0.6 ,0.7]\\n\\n data = pandas.read_csv('train.csv')\\n\\n avg_list = []\\n for i in range(0,len(N_list) * len(K_list) * len(P_list)):\\n avg_list.append([0 , None])\\n\\n kf = KFold(n_splits=5, shuffle=True, random_state=209418441)\\n rotation_index = 1\\n for train_index, test_index in kf.split(data):\\n\\n train = data.iloc[train_index]\\n test = data.iloc[test_index]\\n index = 0\\n for n in N_list:\\n for k in K_list:\\n for p in P_list:\\n\\n #print('testing for N= ',n,', K = ',k, 'P = ',p)\\n KNN = forest.KNN_forest(N=n, K=k, P=p, data = train , improved=improved)\\n success_rate = utls.tests.succ_rate_test.test(test,KNN.Classify)\\n avg_list[index][0] += success_rate\\n avg_list[index][1] = (n,k,p)\\n #print(' rate is: ',avg_list[index][0]/rotation_index)\\n index += 1\\n rotation_index +=1\\n\\n\\n\\n best_option = max(avg_list,key= lambda x:x[0])\\n #print(' ****** DONE ******')\\n #print('best n,k,p are : ' , best_option[1] , ' with success rate: ' , best_option[0])\\n\\n return best_option[1]\",\n \"def build(self):\\n # weights to apply to training samples, updated on each\\n # iteration of the boosting algo, normalised to 1\\n sigWeights = np.ones(self.nSig, dtype=float)\\n bkgWeights = np.ones(self.nBkg, dtype=float)\\n reweight = 1.0/(np.sum(sigWeights)+np.sum(bkgWeights))\\n sigWeights *= reweight\\n bkgWeights *= reweight \\n\\n # Weight of each tree, strong classifers have higher weight\\n self.treeWeights = np.zeros(self.ntrees, dtype=float)\\n\\n for i in xrange(self.ntrees):\\n\\n # build new tree\\n newTree = Tree()\\n newTree.load(self.sigData,self.bkgData,weights=(sigWeights,bkgWeights))\\n newTree.build()\\n self.dTrees.append(newTree) \\n\\n # evaluate trees\\n # keep track of each event\\n err = 0.0\\n sigWrong = np.zeros(self.nSig)\\n bkgWrong = np.zeros(self.nBkg)\\n\\n for j in range(self.nSig):\\n if newTree.classify(np.array((self.sigData[j,])))<0:\\n sigWrong[i]=1\\n err+=sigWeights[j]\\n\\n for j in range(self.nBkg):\\n if newTree.classify(np.array((self.bkgData[j,])))>0:\\n bkgWrong[i]=1\\n err+=bkgWeights[j]\\n\\n alpha = self.beta*math.log((1.0-err)/err)\\n print err,alpha\\n corFactor = math.exp(-alpha)\\n wrongFactor = math.exp(alpha)\\n\\n if (err<1e-20 or err >= 0.5):\\n print \\\"SOEMTHING WRONG!!\\\"\\n\\n self.treeWeights[i] = alpha\\n\\n # reweight training samples\\n for j in range(self.nSig):\\n if sigWrong[j]:\\n sigWeights[j]*=wrongFactor\\n else :\\n sigWeights[j]*=corFactor\\n\\n for j in range(self.nBkg):\\n if bkgWrong[j]:\\n bkgWeights[j]*=wrongFactor\\n else :\\n bkgWeights[j]*=corFactor\\n\\n # normalise weights\\n reweight = 1.0/(np.sum(sigWeights)+np.sum(bkgWeights))\\n sigWeights *= reweight\\n bkgWeights *= reweight\",\n \"def policy_evaluation(P, nS, nA, policy, gamma=0.9, tol=1e-8):\\n value_function = np.zeros(nS)\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n def next_state_reward(P,state,action,gamma,value_function):\\n sum_reward=0\\n for p,nextS,r,boolean_v in P[state][action]:\\n sum_reward+=p*( r + gamma* value_function[nextS])\\n #print(sum_reward) \\n return sum_reward\\n\\n while True:\\n delta=0;\\n for state in range(nS):\\n new_value=0;\\n for action in range(nA):\\n sum_reward=next_state_reward(P,state,action,gamma,value_function)\\n new_value+=policy[state][action]*sum_reward\\n delta= max(delta, abs(new_value-value_function[state]))\\n value_function[state] = new_value\\n #print(value_function)\\n if(delta < tol):\\n break\\n\\n ############################\\n return value_function\",\n \"def dpsearch(points,k):\\n\\t#M = k\\n\\tpoints = np.sort(points,axis=0)\\n\\tL = len(points)\\n\\tM = k\\n\\tT = list(np.zeros(M+1,dtype='int'))\\n\\tT[0] = 0\\t#first threshold is by default always set to index 0 in trellis graph.\\n\\tT[M] = L \\t#last threshold is by default always set to last number in input points.\\n\\ttrellis_value = np.full((M+1,L+1),np.inf)\\n\\ttrellis_backpointer = np.full((M+1,L+1),np.inf)\\n\\n\\t# Stage 1: m=1\\t\\n\\tfor l in range(1,L-M+2):\\n\\t\\ttrellis_value[1][l] = ((l-0)/float(L))*np.var(points[0:l])\\n\\t\\ttrellis_backpointer[1][l] = 0\\n\\n\\t\\n\\tif(M>2):\\n\\t\\t# Stage 2: m=2 to m=M-1\\n\\t\\tfor m in range(2,M):\\n\\t\\t\\tfor l in range(m,L-M+m+1):\\n\\t\\t\\t\\t#finding optimal path\\n\\t\\t\\t\\tJ_min = np.inf\\n\\t\\t\\t\\tJ_temp = np.inf\\n\\t\\t\\t\\tfor i in range(m-1,l):\\n\\t\\t\\t\\t\\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\\n\\t\\t\\t\\t\\tif J_temp < J_min:\\n\\t\\t\\t\\t\\t\\tJ_min = J_temp\\n\\t\\t\\t\\t\\t\\tptr = i\\n\\t\\t\\t\\t\\n\\t\\t\\t\\ttrellis_value[m][l],trellis_backpointer[m][l] = J_min,ptr\\n\\t\\t\\t\\t\\n\\n\\t# Stage 3: m=M\\n\\tm = M\\n\\tl = L\\n\\t#finding optimal path\\n\\tJ_min = np.inf\\n\\tJ_temp = np.inf\\n\\tfor i in range(m-1,l):\\n\\t\\tJ_temp = trellis_value[m-1][i] + ((l-i)/float(L))*np.var(points[i:l])\\n\\t\\tif J_temp < J_min:\\n\\t\\t\\tJ_min = J_temp\\n\\t\\t\\tptr = i\\n\\n\\t\\n\\ttrellis_value[M][L] = J_min\\n\\ttrellis_backpointer[M][L] = ptr\\n\\t\\n\\t\\n\\t# Backtracking\\n\\tl = L\\n\\tm = M\\n\\twhile m>=2:\\n\\t\\tT[m-1] = int(trellis_backpointer[m][l])\\n\\t\\tl = int(trellis_backpointer[m][l])\\n\\t\\tm = m - 1\\n\\n\\t#Assign cluster labels\\n\\tlabels = np.full(len(points),0)\\n\\tj = T[0]\\n\\tcounter = 0\\n\\tfor i in range(1,k+1):\\n\\t\\tlabels[j:T[i]] = counter\\n\\t\\tj = T[i]\\n\\t\\tcounter += 1\\n\\n\\n\\treturn labels,T\",\n \"def bisection(self,\\n low_bound: float,\\n up_bound: float,\\n epsilon: float,\\n n: int,\\n Rmn: dict,\\n ytm: dict) -> float:\\n for i in range(100):\\n y = (low_bound + up_bound) / 2\\n if abs(Bootstrapping.f(self,y, n, Rmn, ytm)) < epsilon:\\n ym = ytm[list(ytm.keys())[-1]]\\n m = list(ytm.keys())[-1]\\n for j in range(list(ytm.keys())[-1] + 1, n + 1):\\n ytm[j] = ym + (y - ym) * (j - m) / (n - m)\\n return ytm\\n else:\\n if Bootstrapping.f(self,y, n, Rmn, ytm) * Bootstrapping.f(self,up_bound, n, Rmn, ytm) < 0:\\n low_bound = y\\n elif Bootstrapping.f(self,y, n, Rmn, ytm) * Bootstrapping.f(self,low_bound, n, Rmn, ytm) < 0:\\n up_bound = y\",\n \"def VFI(method) :\\n iteration=0 # Iteration Counter\\n converged = 0 # Convergence Flag|\\n \\n#----- Initial Settings \\n v_update = zeros(n_grid)\\n v_func = empty(n_grid)\\n k_next_vec = empty(n_grid)\\n run_time = empty(2)\\n \\n def obj(k_next) :\\n \\\"\\\"\\\"\\n This function is used in value function iteration.\\n It represents the objective function to be maximized for one node (state) of current capitals.\\n Resulting value is maximized one corresponding to next period's capital as a maximizer. \\n Next period's value is computed by interpolation.\\n \\n Input : k_next (next period's capital)\\n \\n Output : value_vec (maximized value resulting from choosing optimal capital in the next period)\\n \\\"\\\"\\\" \\n \\n if method==1 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\\n elif method==2 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\\n elif method==3 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\\n \\n return value_vec\\n\\n#----- Value function iteration\\n start = time.time() # start time\\n while converged==0 :\\n index = 0\\n for k_current in k_grid :\\n k_next = fminbound(obj,k_grid[0],k_grid[-1])\\n v_func[index] = (-1) * obj(k_next)\\n k_next_vec[index] = k_next\\n index = index + 1\\n dist = abs(max(v_func - v_update))\\n if dist<tol :\\n converged = 1\\n v_k, g_k = v_func, k_next_vec\\n v_update = v_func\\n print \\\"Iteration : \\\",iteration,\\\"\\\",\\\"Distance : \\\",dist # convergence process\\n iteration = iteration + 1\\n v_func = empty(n_grid) \\n k_next_vec = empty(n_grid)\\n \\n end = time.time() # end time\\n run_time[0],run_time[1] = runtime_cal(start,end) # total running time\\n \\n return v_k, g_k, run_time, iteration\",\n \"def FigA7(case):\\n \\n #set the parameter, arrays\\n \\n n_array=np.array([1,2,3])\\n\\n #set the result arrays\\n if case==0:\\n class_number=5\\n elif case==1:\\n class_number=6\\n fate=np.zeros([class_number])#number of evolutionary fate\\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\\n \\n time=np.linspace(0,100000, 1000000)\\n loop=10**6\\n \\\"\\\"\\\"\\n 0 Co and/or Ch cannot survive in mono-culture\\n 1 Co cannot invade\\n 2 Only equilibrium of exclusion is stable\\n 3 Only equilibrium of coexistence is stable\\n 4 Two equilibria are UNstable\\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\\n \\\"\\\"\\\"\\n for tri in range(np.size(n_array)):\\n counter=0\\n n=n_array[tri]\\n print(str(\\\"Hill coefficient is %d\\\" %(n)))\\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\\n if case==0 or case==1:\\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\\n else:\\n print(\\\"Error in case\\\")\\n return 1\\n \\n for i in range(loop):\\n if(i+1)%10000==0:\\n print(i+1)\\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\\n #check whether r is positive or not\\n if case==0:\\n r1=rmax*(1-cr-cd)#rCO\\n r2=rmax#sCH\\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\\n elif case==1:\\n r1=rmax*(1-cd)#sCo\\n r2=rmax*(1-cr)#rCh\\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\\n stab_e=0#initialize the falgs of stability\\n stab_c=0\\n if W0Co<0 or W0Ch<0:\\n fate[0]+=1\\n res=0\\n else:\\n #succeed in mono-culture \\n init=np.array([T0,10**(-6)])\\n if case==0: \\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\\n x2s=solCh[-1,1]\\n else:\\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\\n x2s=solCh[-1,1]\\n \\n #Evolutionary dynamics \\n if case==0:\\n K=Kr\\n else:\\n K=Ks\\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\\n #Co cannot invade\\n fate[1]+=1\\n res=1\\n else:\\n #Co can invade\\n #calculate Tdagger Td and check whether coexist or exclude\\n if case==0:\\n #rCo vs sCh\\n #in this case, at most one equilbrium is stable\\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\\n Td=tau**(1/n)\\n if Td<Ts:\\n #Co exclude Ch\\n fate[2]+=1\\n res=2\\n else:\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #unstable coexistence nor exclusion\\n fate[4]+=1\\n res=4\\n print(Td, x1d, x2d)\\n else:\\n #sCo vs rCh\\n # in this case two equilibria can be stable at the same time\\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\\n if tau_m>Ts**n or tau_p<Ts**n:\\n # cexclusion is stable\\n stab_e=1\\n # stability in coexistence \\n if tau_p<0:\\n stab_c=0\\n else:\\n Td=tau_p**(1/n)\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n stab_c=1\\n #classify\\n if stab_e==1 and stab_c==1:\\n # two stable equilbria\\n fate[5]+=1\\n res=5\\n elif stab_e==1 and stab_c==0:\\n #only stable cexclusion\\n fate[2]+=1\\n res=2\\n elif stab_e==0 and stab_c==1:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #both unstable\\n fate[4]+=1\\n res=4\\n \\n #save the results\\n if counter==0:\\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n #save the result with parameter values\\n \\n else:\\n #add array of results\\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n result=np.concatenate((result, R), axis=0)\\n counter+=1\\n \\n #save csv file and graph\\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \\n print(fate)\\n fate_matrix[tri,:]=fate \\n if case==0: \\n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\\n else:\\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\\n Plot(case)\",\n \"def find_new_kbl(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n z_u_r = self.grid_dict['z_u_r']\\n\\n #---> j loop\\n for j in range(Ly):\\n self.kbl[j] = N #initialize search at top\\n\\n # in fortran k=N-1,1,-1\\n for k in range(N-1,0,-1):\\n #INDEX MAP\\n k_w = k\\n k_r = k-1\\n \\n for j in range(Ly):\\n if z_u_w[j,k_w] > z_u_w[j,N] - self.hbls[j]:\\n self.kbl[j] = k_w\",\n \"def iteration(self):\\n T = self.generate_T()\\n R = self.reproduce(T)\\n self.P = self.choose_mi_best(R)\\n #print(self.P)\",\n \"def fn(n, k):\\n if k == 0: return 1 \\n if n <= 0 or k < 0: return 0 \\n return fn(n-1, k) + fn(n, k-1) - fn(n-1, k-n)\",\n \"def verhulst(nb_init, t0, tf, eps, methode, gamma, K) :\\n f=lambda y,t : gamma*y*(1-y/K)\\n Y=meth_epsilon(nb_init, t0, tf, eps, f, methode)\\n return Y\",\n \"def king2(r, n0, rc0, b0, n1, rc1, b1):\\n return n0 * (1. + (r/rc0)**2)**b0 + n1 * (1. + (r/rc1)**2)**b1\",\n \"def fn(n, k):\\n if n <= k: return 0 # one mailbox for each house\\n if k == 1: return mdist[0][n-1]\\n ans = inf \\n for nn in range(k-1, n): \\n ans = min(ans, fn(nn, k-1) + mdist[nn][n-1])\\n return ans\",\n \"def decision_heatmaps(obs):\\n global model\\n assert obs > 4 and obs < 1788, \\\"Chosen observation is outside the range of the demonstration episode.\\\"\\n saved_observations = np.load('saved_observations.npy')\\n state = saved_observations[obs-3:obs+1]\\n state_batch = np.expand_dims(state, axis=0)\\n q_vals = model.compute_q_values(state)\\n print(q_vals)\\n decision = np.argmax(q_vals)\\n print(decision)\\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\\n decision_node = model.model.output[:, decision]\\n last_conv_layer = model.model.layers[3]\\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\\n pooled_grads = K.mean(grads, axis=(0,2,3))\\n frame = Image.fromarray(state[-1])\\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\\n for i in range(64):\\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\\n\\n heatmap = np.mean(conv_layer_output_value, axis=0)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (84, 84))\\n heatmap = np.uint8(255 * heatmap)\\n superimposed_img = heatmap * .3 + np.array(frame) * .35\\n\\n plt.xlabel(decision_encodings[decision])\\n plt.imshow(superimposed_img, cmap='gray')\\n plt.show()\",\n \"def grid_search(self):\\n\\t\\tchoice_apply_BN = [False] if self.debug else [False] # True, False\\n\\t\\tchoice_apply_RD = [False] if self.debug else [False] # True, False\\n\\n\\t\\tchoice_layers = [3] if self.debug else [3] # 1, 2, 3, 4\\n\\t\\tchoice_hd_hn_af = ['S'] if self.debug else ['R'] # 'R6' | 'RK' | 'S' activation function w.r.t. head hidden layers\\n\\t\\tchoice_tl_af = ['S'] if self.debug else ['R'] # activation function for the last layer, sigmoid is suggested due to zero-prediction\\n\\t\\tchoice_hd_hn_tl_af = None\\n\\n\\t\\tchoice_apply_tl_af = [True] # True, False\\n\\n\\t\\tif choice_hd_hn_tl_af is not None:\\n\\t\\t\\tfor BN, RD, num_layers, af, apply_tl_af in product(choice_apply_BN, choice_apply_RD, choice_layers,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t choice_hd_hn_tl_af, choice_apply_tl_af):\\n\\t\\t\\t\\tffnns_para_dict = dict(FBN=False, BN=BN, RD=RD, num_layers=num_layers, HD_AF=af, HN_AF=af, TL_AF=af,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t apply_tl_af=apply_tl_af)\\n\\t\\t\\t\\tsf_para_dict = dict()\\n\\t\\t\\t\\tsf_para_dict['id'] = 'ffnns'\\n\\t\\t\\t\\tsf_para_dict['ffnns'] = ffnns_para_dict\\n\\n\\t\\t\\t\\tself.sf_para_dict = sf_para_dict\\n\\t\\t\\t\\tyield sf_para_dict\\n\\t\\telse:\\n\\t\\t\\tfor BN, RD, num_layers, hd_hn_af, tl_af, apply_tl_af in product(choice_apply_BN, choice_apply_RD,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tchoice_layers, choice_hd_hn_af,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tchoice_tl_af, choice_apply_tl_af):\\n\\t\\t\\t\\tffnns_para_dict = dict(FBN=False, BN=BN, RD=RD, num_layers=num_layers, HD_AF=hd_hn_af, HN_AF=hd_hn_af,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t TL_AF=tl_af, apply_tl_af=apply_tl_af)\\n\\t\\t\\t\\tsf_para_dict = dict()\\n\\t\\t\\t\\tsf_para_dict['id'] = 'ffnns'\\n\\t\\t\\t\\tsf_para_dict['ffnns'] = ffnns_para_dict\\n\\n\\t\\t\\t\\tself.sf_para_dict = sf_para_dict\\n\\t\\t\\t\\tyield sf_para_dict\",\n \"def fn(n, k):\\n if n == k: return 1\\n if k == 0: return 0\\n return ((n-1)*fn(n-1, k) + fn(n-1, k-1)) % 1_000_000_007\",\n \"def prediction_aggregation(self, xt_s,mu_s,var_s, method='PoE', weighting='uniform', power=26):\\n\\n nt = xt_s.shape[0]\\n mu = np.zeros([nt, self.C],dtype='float64')\\n var = np.zeros([nt, self.C],dtype='float64')\\n\\n prior_var = self.experts[0].kernel(xt_s[0], xt_s[0])\\n\\n \\n #Process each latent gp individually \\n for j in range(self.C):\\n \\n mu_s_c = mu_s[:, :, j]\\n var_s_c = var_s[:, :, j]\\n \\n weight_matrix = compute_weights(mu_s_c, var_s_c, power, weighting, prior_var)\\n \\n prec_s= 1/var_s_c\\n\\n if method == 'PoE':\\n \\n prec = tf.reduce_sum(prec_s, axis=0)\\n \\n\\n if method == 'gPoE':\\n \\n weight_matrix = normalize_weights(weight_matrix)\\n\\n prec = tf.reduce_sum(weight_matrix * prec_s , axis=0)\\n \\n\\n if method == 'BCM':\\n \\n prec = tf.reduce_sum(prec_s, axis=0) + (1 - self.M) / prior_var \\n\\n if method == 'rBCM':\\n \\n \\n prec = tf.reduce_sum(weight_matrix * prec_s, axis=0) \\\\\\n + (1 - tf.reduce_sum(weight_matrix, axis=0)) / prior_var\\n \\n \\n \\n if method != 'bar':\\n \\n var[:, j] = 1 / prec\\n\\n mu[:, j] = var[:, j] * tf.reduce_sum(weight_matrix * prec_s * mu_s_c, axis=0)\\n \\n else:\\n \\n weight_matrix = normalize_weights(weight_matrix)\\n\\n mu[:, j] = tf.reduce_sum(weight_matrix * mu_s_c, axis=0)\\n var[:, j] = tf.reduce_sum(weight_matrix * var_s_c, axis=0)\\n \\n \\n return self.lik_aggregation(mu, var)\",\n \"def ACM_Kruskal(G):\\n pass\",\n \"def rk_step(fun, t, y, f, h, A, B, C, K):\\n \\n K[0] = f\\n for s, (a, c) in enumerate(zip(A[1:], C[1:]), start=1):\\n dy = np.dot(K[:s].T, a[:s]) * h\\n K[s] = fun(t + c * h, y + dy)\\n\\n y_new = y + h * np.dot(K[:-1].T, B)\\n f_new = fun(t + h, y_new)\\n\\n K[-1] = f_new\\n\\n return y_new, f_new\",\n \"def _KF_gain(self, state_pred, covar_pred, sigma_points_pred, weights_c,\\n z_pred, z_points_pred, R):\\n diff_z = z_points_pred - z_pred[:, None, :]\\n diff_z = tf.cast(diff_z, tf.float64)\\n diff_z = tf.reshape(diff_z, [-1, self.dim_z])\\n diff_z = self.context.correct_observation_diff(diff_z)\\n diff_z = tf.reshape(diff_z,\\n [self.batch_size, self.num_sigma, self.dim_z])\\n diff_square = tf.matmul(diff_z[:, :, :, None], diff_z[:, :, None, :])\\n S = tf.multiply(diff_square, tf.cast(weights_c[:, :, :, None],\\n tf.float64))\\n S = tf.cast(tf.reduce_sum(S, axis=1), tf.float32) + R\\n S = self._make_valid(S)\\n\\n diff_state = sigma_points_pred - state_pred[:, None, :]\\n diff_state = tf.reshape(diff_state, [-1, self.dim_x])\\n diff_state = self.context.correct_state(diff_state)\\n diff_state = tf.reshape(diff_state,\\n [self.batch_size, self.num_sigma, self.dim_x])\\n z_state = tf.matmul(tf.cast(diff_state[:, :, :, None], tf.float64),\\n diff_z[:, :, None, :])\\n z_state_covar = \\\\\\n tf.reduce_sum(tf.multiply(z_state,\\n tf.cast(weights_c[:, :, :, None],\\n tf.float64)), axis=1)\\n z_state_covar = tf.cast(z_state_covar, tf.float32)\\n\\n K = tf.matmul(z_state_covar, tf.linalg.inv(S))\\n return K\",\n \"def past_weight_grad_calculator2(xs, es, kp_x, kd_x, kp_e, kd_e, shapes):\\n kp_x, kd_x, kp_e, kd_e = [as_floatx(k) for k in (kp_x, kd_x, kp_e, kd_e)]\\n n_samples, n_in, n_out = shapes\\n rx = kd_x/(kp_x+kd_x)\\n re = kd_e/(kp_e+kd_e)\\n\\n xr = create_shared_variable(np.zeros((n_samples, n_in)))\\n er = create_shared_variable(np.zeros((n_samples, n_out)))\\n\\n\\n\\n\\n # xr_new = xr*rx + xs/(kp_x+kd_x)\\n # er_new = er*re + es/(kp_e+kd_e)\\n\\n arr = rx*re/(1-rx*re)\\n\\n xr_new = xr*arr + xs/(kp_x+kd_x)\\n er_new = er*arr + es/(kp_e+kd_e)\\n\\n xsum = create_shared_variable(np.zeros((n_samples, n_in)))\\n esum = create_shared_variable(np.zeros((n_samples, n_out)))\\n\\n xsum_new = xsum+xr_new\\n esum_new = esum+er_new\\n\\n x_nospikes = tt.eq(xs, 0)\\n e_nospikes = tt.eq(es, 0)\\n\\n dw = xs.T.dot(esum_new) + xsum_new.T.dot(es)\\n\\n add_update(xr, xr_new)\\n add_update(er, er_new)\\n add_update(xsum, xsum_new*x_nospikes)\\n add_update(esum, esum_new*e_nospikes)\\n\\n return xs.T.dot(er) + xr.T.dot(es)\\n # return xr.T.dot(er)\\n # return dw\",\n \"def generateKNNobj():\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n #tdata=b[:,8:28].copy()\\n # indx with only M22 without zero order\\n m22idx = np.concatenate((np.arange(29,48),np.arange(49,68)))\\n tdata=b[:,m22idx].copy()\\n #tdata=b[:,9:28].copy() # remove the zero order zernike, i.e. remove the mean of the M20\\n #-standardize the data. use this information in future validation data too.\\n tmean = tdata.mean(axis=0)\\n tstd = tdata.std(axis=0)\\n tdata = (tdata - tmean)/tstd\\n ttpara=b[:,0:5].copy()\\n tpara = b[:,0:5].copy()\\n tpara[:,3] = ttpara[:,3]*np.cos(np.deg2rad(ttpara[:,4]))\\n tpara[:,4] = ttpara[:,3]*np.sin(np.deg2rad(ttpara[:,4]))\\n knn = nb.KNeighborsRegressor(algorithm='ball_tree',n_neighbors=15)\\n knn.fit(tdata,tpara)\\n p.dump(knn,open('finerGridKnnObj_M22_remMean.cp','w'),2)\\n p.dump([tmean,tstd],open('finerGridStdConst_M22_remMean.cp','w'),2)\\n #np.savetxt('finerGridStdConst.txt',np.array([tmean,tstd]),fmt='%f10.5',delimiter = ',')\\n return 'It is done !'\",\n \"def OutOfSampleExtension(self, P, k = 3):\\n \\n n_obs = P.shape[0]\\n knn = []\\n for obs in range(n_obs):\\n x_obs = P[obs]\\n # get nearest neighbors\\n dist = pairwise_distances(np.vstack([self.X, x_obs]))\\n knn_aux = np.argsort(dist[self.n:,:], axis = 1)[:, 1 : k + 1]\\n knn.append(knn_aux[0]) \\n knn = np.array(knn)\\n # compute weights\\n \\n W = [] # Initialize nxn weight matrix\\n for i in range(n_obs):\\n x_i = P[i]\\n G = [] # Local covariance matrix\\n for j in range(k):\\n x_j = self.X[knn[i][j]]\\n G_aux = []\\n for k_2 in range(k):\\n x_k = self.X[knn[i][k_2]]\\n gjk = np.dot((x_i - x_j), (x_i - x_k))\\n G_aux.append(gjk)\\n G.append(G_aux)\\n G = np.array(G)\\n G = G + self.reg*np.eye(*G.shape) # Regularization for G\\n w = np.linalg.solve(G, np.ones((k))) # Calculate weights for x_i\\n w = w / w.sum() # Normalize weights; sum(w)=1\\n \\n if self.verbose and i % 3 == 0:\\n print('[INFO] Weights calculated for {} observations'.format(i + 1))\\n \\n W.append(w)\\n \\n W = np.array(W)\\n y = []\\n for i in range(n_obs):\\n y_aux = W[i] @ self.Y[knn[i]]\\n y.append(y_aux)\\n y = np.array(y)\\n return y\",\n \"def initial_estimator(f, x, step,k):\\n\\n fx = f(x)\\n\\n if decide(fx > 0):\\n sign1 = 1\\n else:\\n sign1 = -1\\n k_step = k\\n h = fx / derivative(f, x)\\n\\n for k1 in range(1, 50000):\\n step = step + 1\\n x_new = x - k_step * h\\n k_step = k_step * 2 # make the k double in each iteration\\n fx_new = f(x_new)\\n if decide(fx_new > 0):\\n sign2 = 1\\n else:\\n sign2 = -1\\n\\n if not (sign1 == sign2):\\n return x_new, step\\n\\n print(\\\"limit need to Increase\\\")\",\n \"def test_tpr_fwer_alex(self, syn_genomic_data, syn_labels, syn_labels_0based, syn_labels_cat, syn_fm, syn_idx, rep, syn_true_pvalues):\\n\\n window_length = 35\\n best_params_montaez['n_snps'] = n_total_snps\\n\\n def combi_compute_pvalues(d, x, fm, l,filter_window_size,pf,ps,k):\\n\\n idx, pvalues, raw_weights = combi_method(d, x,fm, l,filter_window_size,pf,ps,k)\\n pvalues_filled = np.ones(n_total_snps)\\n pvalues_filled[idx] = pvalues\\n raw_weights = postprocess_weights_without_avg(raw_weights, p_svm)\\n\\t\\t\\t\\n # Map the raw weights to look like p-values between 0 and 1 (reverse order)\\t\\t\\n # Figure out how 'wide' range is\\n leftSpan = np.max(raw_weights) - np.min(raw_weights)\\n\\n # Convert the left range into a 0-1 range (float)\\n valueScaled = (raw_weights - np.min(raw_weights)) / leftSpan\\n\\n # Reverse order\\n raw_weights = 1 - valueScaled\\t\\n\\t\\t\\t\\n del d, l\\n return pvalues_filled, raw_weights\\n\\n def challenger_compute_pvalues(d, x, l_0b, l, idx):\\n is_only_zeros = False\\n with tensorflow.Session().as_default():\\n\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(l_0b[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n model.fit(x=x[idx.train], y=l_0b[idx.train], validation_data=(x[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'],class_weight=d_class_weights, callbacks=[ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),])\\n\\n model = iutils.keras.graph.model_wo_softmax(model)\\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\\n weights = analyzer.analyze(x).sum(0)\\n\\n if np.max(abs(weights)) < 0.005:\\n fig, axes = plt.subplots(1)\\n is_only_zeros = True\\n axes.plot(np.absolute(weights).sum(axis=1))\\n fig.savefig(os.path.join(IMG_DIR, 'test.png'))\\n\\n top_indices_sorted, _ = postprocess_weights(weights, top_k, window_length, p_svm, p_pnorm_filter)\\n rawlrp_scores_now = postprocess_weights_without_avg(weights,p_svm)\\n\\t\\t\\t\\t\\n # Map the raw weights to look like p-values between 0 and 1 (reverse order)\\t\\t\\n # Figure out how 'wide' range is\\n leftSpan = np.max(rawlrp_scores_now) - np.min(rawlrp_scores_now)\\n\\n # Convert the left range into a 0-1 range (float)\\n valueScaled = (rawlrp_scores_now - np.min(rawlrp_scores_now)) / leftSpan\\n\\n # Reverse order\\n rawlrp_scores_now = 1 - valueScaled\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\n pvalues = chi_square(d[:, top_indices_sorted], l)\\n pvalues_filled = np.ones(n_total_snps)\\n pvalues_filled[top_indices_sorted] = pvalues\\n del d, x, l\\n\\n return pvalues_filled, is_only_zeros, rawlrp_scores_now\\n\\n fm_2d = syn_fm(\\\"2d\\\")\\n fm_3d = syn_fm(\\\"3d\\\")\\n\\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\\n\\n bla = Parallel(n_jobs=-1, require='sharedmem')(delayed(combi_compute_pvalues)(clf, syn_genomic_data[str(i)][:], fm_2d[str(i)][:], syn_labels[str(i)], 35, 2, 2, 30) for i in tqdm(range(rep)))\\n raw_svmweights_per_run_combi = np.array(list(np.array(bla)[:, 1]))\\n pvalues_per_run_combi = np.array(list(np.array(bla)[:, 0]))\\n\\n pvalues_per_run_rpvt = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(chi_square)(syn_genomic_data[str(i)][:], syn_labels[str(i)]) for i in tqdm(range(rep))))\\n\\n # len(thresholds) * len(window_sizes) * 10020\\n abl = Parallel(n_jobs=-1, require='sharedmem')(delayed(challenger_compute_pvalues)(syn_genomic_data[str(i)][:], fm_3d[str(i)][:], syn_labels_cat[str(i)], syn_labels[str(i)], syn_idx[str(i)]) for i in tqdm(range(rep)))\\n\\n # Collect results\\n pvalues_per_run_dense = np.array(list(np.array(abl)[:, 0]))\\n rawlrp_scores_per_run_dense = np.array(list(np.array(abl)[:, 2]))\\n \\n # INNvestigate bugfix\\n zeros_index = np.array(list(np.array(abl)[:, 1])) \\n pvalues_per_run_combi = pvalues_per_run_combi[np.logical_not(zeros_index)]\\n raw_svmweights_per_run_combi = raw_svmweights_per_run_combi[np.logical_not(zeros_index)]\\n pvalues_per_run_dense = pvalues_per_run_dense[np.logical_not(zeros_index)]\\n rawlrp_scores_per_run_dense = rawlrp_scores_per_run_dense[np.logical_not(zeros_index)]\\n pvalues_per_run_rpvt = pvalues_per_run_rpvt[np.logical_not(zeros_index)]\\n true_pvalues = syn_true_pvalues[np.logical_not(zeros_index)]\\n\\n # COMBI\\n res_combi = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_combi, true_pvalues, threshold) for threshold in tqdm(thresholds)))\\n tpr_combi, _, fwer_combi, precision_combi = res_combi.T\\n\\n # SVM weights\\n res_rawsvm = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(raw_svmweights_per_run_combi, true_pvalues, threshold) for threshold in tqdm(thresholds)))\\n tpr_rawsvm, _, fwer_rawsvm, precision_rawsvm = res_rawsvm.T\\n\\n # RPVT\\n res_rpvt = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_rpvt, true_pvalues, threshold) for threshold in tqdm(thresholds)))\\n\\t\\t\\n tpr_rpvt, _, fwer_rpvt, precision_rpvt = res_rpvt.T\\n\\n # Plot\\n fig, axes = plt.subplots(1,2)\\n\\n fig.set_size_inches(15, 9)\\n ax1, ax2 = axes\\n\\n ax1.set_ylim(0, 0.7)\\n ax1.set_xlim(0, 0.3)\\n ax1.set_ylabel('True positive rate', fontsize=14)\\n ax1.set_xlabel('Family-wise error rate', fontsize=14)\\n ax2.set_ylabel('Precision', fontsize=14)\\n ax2.set_xlabel('True positive rate', fontsize=14)\\n\\n # CURVES must stop somewhere\\n tpr_rpvt_new = tpr_rpvt[tpr_rpvt < 1]\\n fwer_rpvt = fwer_rpvt[tpr_rpvt < 1]\\n precision_rpvt = precision_rpvt[tpr_rpvt < 1]\\n tpr_rpvt = tpr_rpvt_new\\n\\n tpr_combi_new = tpr_combi[tpr_combi < 1]\\n fwer_combi = fwer_combi[tpr_combi < 1]\\n precision_combi = precision_combi[tpr_combi < 1]\\t\\n tpr_combi = tpr_combi_new\\n\\n tpr_rawsvm_new = tpr_rawsvm[tpr_rawsvm < 1]\\n fwer_rawsvm = fwer_rawsvm[tpr_rawsvm < 1]\\n precision_rawsvm = precision_rawsvm[tpr_rawsvm < 1]\\n tpr_rawsvm = tpr_rawsvm_new\\n\\t\\t\\n # RPVT\\n ax1.plot(fwer_rpvt, tpr_rpvt, label='RPVT', color='lightsteelblue', linewidth=2)\\n ax2.plot(tpr_rpvt, precision_rpvt, color='lightsteelblue', label='RPVT', linewidth=2)\\n\\n # COMBI \\n ax1.plot(fwer_combi, tpr_combi, color='darkblue', label='COMBI', linewidth=2)\\n ax2.plot(tpr_combi, precision_combi, color='darkblue', label='COMBI', linewidth=2)\\n \\n # raw SVM weights\\n ax1.plot(fwer_rawsvm, tpr_rawsvm, linestyle='--', color='darkblue', label='SVM weights', linewidth=2)\\n ax2.plot(tpr_rawsvm, precision_rawsvm, linestyle='--', color='darkblue', label='SVM weights', linewidth=2)\\n\\n # DeepCOMBI + LRP scores\\n res_dense = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(pvalues_per_run_dense, true_pvalues, threshold) for threshold in tqdm(thresholds)))\\n res_rawlrp_dense = np.array(Parallel(n_jobs=-1, require='sharedmem')(delayed(compute_metrics)(rawlrp_scores_per_run_dense, true_pvalues, threshold) for threshold in tqdm(thresholds)))\\n\\n tpr_dense, _, fwer_dense, precision_dense = res_dense.T\\n tpr_rawlrp_dense, _, fwer_rawlrp_dense, precision_rawlrp_dense = res_rawlrp_dense.T\\n\\n assert fwer_combi.max() <= 1 and fwer_combi.min() >= 0\\n tpr_dense_new = tpr_dense[tpr_dense < 1]\\n fwer_dense = fwer_dense[tpr_dense < 1]\\n precision_dense = precision_dense[tpr_dense < 1]\\n tpr_dense = tpr_dense_new\\n\\n tpr_rawlrp_dense_new = tpr_rawlrp_dense[tpr_rawlrp_dense < 1]\\n fwer_rawlrp_dense = fwer_rawlrp_dense[tpr_rawlrp_dense < 1]\\n precision_rawlrp_dense = precision_rawlrp_dense[tpr_rawlrp_dense < 1]\\n tpr_rawlrp_dense = tpr_rawlrp_dense_new\\n\\n # DeepCOMBI\\n ax1.plot(fwer_dense, tpr_dense, color='fuchsia', label='DeepCOMBI', linewidth=3)\\n ax2.plot(tpr_dense, precision_dense, color='fuchsia', label='DeepCOMBI', linewidth=3)\\n\\n # LRP scores\\n ax1.plot(fwer_rawlrp_dense, tpr_rawlrp_dense, color='fuchsia', linestyle='--', label='LRP scores', linewidth=2)\\n ax2.plot(tpr_rawlrp_dense, precision_rawlrp_dense, color='fuchsia', linestyle='--', label='LRP scores', linewidth=2)\\n\\n ax1.legend(fontsize=14,loc= 'lower right')\\n ax2.legend(fontsize=14, loc= 'lower right')\\n fig.savefig(os.path.join(IMG_DIR, 'tpr_fwer_montaez_final1000_NAR.png'), bbox_inches='tight', dpi=300)\\n print(np.sum(zeros_index))\\n pdb.set_trace()\\n\\n # CURVES must stop somewhere\\n #combi_fp = combi_fp[combi_fp < 80]\\n #combi_tp = combi_tp[:len(combi_fp)]\\n #deepcombi_fp = deepcombi_fp[deepcombi_fp < 80]\\n #deepcombi_tp = deepcombi_tp[:len(deepcombi_fp)]\",\n \"def eg_sk():\\n\\n rxs = []\\n a = []\\n b = []\\n c = []\\n d = []\\n e = []\\n f = []\\n g = []\\n h = []\\n i = []\\n j = []\\n\\n for _ in range(1000):\\n a.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n b.append(utils.gaussian(10.1, 1))\\n\\n for _ in range(1000):\\n c.append(utils.gaussian(20, 1))\\n\\n for _ in range(1000):\\n d.append(utils.gaussian(30, 1))\\n\\n for _ in range(1000):\\n e.append(utils.gaussian(30.1, 1))\\n\\n for _ in range(1000):\\n f.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n g.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n h.append(utils.gaussian(40, 1))\\n\\n for _ in range(1000):\\n i.append(utils.gaussian(40, 3))\\n\\n for _ in range(1000):\\n j.append(utils.gaussian(10, 1))\\n\\n for k, v in enumerate([a, b, c, d, e, f, g, h, i, j]):\\n rxs.append(creation.RX(v, \\\"rx{}\\\".format(k)))\\n\\n for rx in stats.tiles(stats.scottKnot(rxs)):\\n print(\\\"\\\", rx[\\\"rank\\\"], rx[\\\"name\\\"], rx[\\\"show\\\"], sep=\\\"\\\\t\\\")\",\n \"def falling(n, k):\\n total, i = 1, 0\\n if k==0: \\n \\treturn 1\\n else: \\n \\twhile i < k: \\n \\t\\ttotal = total * n \\n \\t\\tn = n-1\\n \\t\\ti = i+1\\n \\treturn total\",\n \"def main(N,N_p,T,lb,ub,prob,N_vars,F_min,F_const,P_c_min,P_c_max):\\n\\n lb,ub,f,fu,D,U,P = initDE(N_p,lb,ub,prob)\\n if N_p < 4:\\n raise Exception(\\\"Sorry, there must be atleast a population of 4. Reccomended 20\\\")\\n for t in np.arange(T):\\n for i in np.arange(N_p):\\n V = mutation(i,N_p,t,T,P,N_vars,F_min,F_const)\\n\\n U=crossover(f,P_c_min,P_c_max,i,D,V,P,U)\\n\\n for j in np.arange(N_p): \\n N,f,P = boundgreed(N,j,U,P,f,fu,ub,lb,prob)\\n\\t\\n\\t\\t#if N == 500:\\n\\t\\t\\t#break\\n best_of_f= min(f)\\n globopt = P[f.argmin()]\\n return N,best_of_f, globopt[:N_vars]\",\n \"def valueIteration(P,R,gamma,theta,initial_v,max_iter=1e8):\\n print('Running value iteration ...')\\n\\n def one_step_lookahead(s, V):\\n \\\"\\\"\\\"\\n :param state: current state\\n :param v: current value estimator\\n :return: A, list of optimal action values under current value estimator\\n \\\"\\\"\\\"\\n num_a = num_actions\\n num_S = num_states\\n\\n A = np.zeros(num_a)\\n\\n for a in range(num_a):\\n for s_prime in range(num_S):\\n A[a] += P[s, a, s_prime] * (R[s, a, s_prime] + gamma * V[s_prime])\\n return A\\n \\n # initialization\\n v = initial_v \\n num_states, num_actions = P.shape[:2]\\n k = 0 \\n best_actions = [0] * num_states\\n delta = 1000\\n\\n while delta > theta and k <= max_iter:\\n delta = 0\\n k += 1\\n for s in range(num_states):\\n action_values = one_step_lookahead(s, v)\\n best_action_value = np.max(action_values)\\n delta = max(delta, np.abs(best_action_value - v[s]))\\n v[s] = best_action_value\\n print(delta)\\n\\n for s in range(num_states):\\n A = one_step_lookahead(s, v)\\n best_actions[s] = np.argmax(A)\\n\\n\\n print('number of iterations:', k)\\n return best_actions, v\",\n \"def determine_offer_tuple_NN(nn, ti, ca, eps, eps_ran, revenues, A, arrival_probabilities, preference_weights, no_purchase_preference):\\n\\n\\n # opportunity costs\\n opp_costs = 1.0*np.zeros_like(revenues)\\n for pro in products:\\n if functools.reduce(operator.or_, ca - A[:, pro] < 0):\\n # set opp costs to infty if not enough capacity for product\\n opp_costs[pro] = np.inf\\n else:\\n # calculate opportunity costs via Bellman: V(t+1, c) - V(t+1, c-A[i])\\n t_df = pd.DataFrame([np.zeros(T + 1)] * 1)\\n t_df.columns = [\\\"t\\\" + str(i) for i in t_df.columns]\\n t_df.iloc[0, ti+1] = 1\\n\\n cs_unsold = {}\\n for h in resources:\\n c_df = pd.DataFrame([np.zeros(T +1)] * 1)\\n c_df.columns = [\\\"c-h\\\" + str(h) + \\\"-t\\\" + str(i) for i in c_df.columns]\\n c_df.iloc[0, ti+1] = ca[h]\\n cs_unsold[h] = c_df\\n\\n cs_sold = {}\\n for h in resources:\\n c_df = pd.DataFrame([np.zeros(T + 1)] * 1)\\n c_df.columns = [\\\"c-h\\\" + str(h) + \\\"-t\\\" + str(i) for i in c_df.columns]\\n c_df.iloc[0, ti + 1] = ca[h] - A[h, pro]\\n cs_sold[h] = c_df\\n\\n X_unsold = pd.concat([t_df, *[cs_unsold[h] for h in resources]], axis=1)\\n X_sold = pd.concat([t_df, *[cs_sold[h] for h in resources]], axis=1)\\n\\n opp_costs[pro] = nn.predict(X_unsold) - nn.predict(X_sold)\\n\\n # epsilon greedy strategy - offer no products\\n if eps_ran < eps / 2:\\n return tuple(np.zeros_like(revenues))\\n\\n # epsilon greedy strategy - offer all products\\n if eps_ran < eps:\\n offer_tuple = np.ones_like(revenues)\\n offer_tuple[opp_costs == np.inf] = 0 # one resource not available => don't offer product\\n return tuple(offer_tuple)\\n\\n # setup\\n offer_tuple = np.zeros_like(revenues)\\n\\n # line 1\\n s_prime = revenues - opp_costs > 0\\n if all(np.invert(s_prime)):\\n return tuple(offer_tuple)\\n\\n # line 2-3\\n # offer_sets_to_test has in each row an offer set, we want to test\\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\\n offer_sets_to_test += offer_tuple\\n offer_sets_to_test = (offer_sets_to_test > 0)\\n\\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\\n arrival_probabilities, preference_weights, no_purchase_preference)\\n\\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1\\n s_prime = s_prime & offer_tuple == 0\\n v_s = np.amax(value_marginal)\\n\\n # line 4\\n while True:\\n # 4a\\n # offer_sets_to_test has in each row an offer set, we want to test\\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\\n offer_sets_to_test += offer_tuple\\n offer_sets_to_test = (offer_sets_to_test > 0)\\n\\n # 4b\\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\\n arrival_probabilities, preference_weights, no_purchase_preference)\\n\\n if np.amax(value_marginal) >= v_s:\\n v_s = np.amax(value_marginal)\\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1 # to get 1 for product offered\\n s_prime = (s_prime - offer_tuple) == 1 # only those products remain, that are neither in the offer_tuple\\n if all(offer_tuple == 1):\\n break\\n else:\\n break\\n return tuple(offer_tuple)\",\n \"def _update_samples_weight(self):\\n m, n = 0, self.u.shape[0]\\n T = self.u.shape[1]\\n N = n + T\\n d_0 = matrix(self.d_0.reshape(n, 1))\\n\\n # Linear Inequallity Constraints, Gx <= h\\n G = matrix(-1 * np.eye(N))\\n h = matrix(np.zeros(shape=(N, 1)))\\n\\n # Linear Equality Constraints, Ax = b\\n A = matrix(np.concatenate((np.ones(shape=(T, 1)), np.zeros(shape=(n, 1))), axis=0).T)\\n b = matrix(1.0)\\n\\n def F(x=None, z=None):\\n if x is None: return 0, matrix(0.5, (N, 1))\\n w = x[:T, :]\\n phi = x[T:, :]\\n reg_inv = 1 / self.reg\\n\\n weighted_u = np.dot(self.u, w) # n x 1\\n scores = -1 * reg_inv * (weighted_u + phi) # n x 1\\n\\n # Numeric correction\\n scores -= max(scores)\\n\\n # Auxilliaries\\n weighted_scores_exp = np.multiply(d_0, np.exp(scores))\\n sum_weighted_scores_exp = np.sum(weighted_scores_exp)\\n sum_weighted_scores_exp_square = sum_weighted_scores_exp ** 2\\n squared_weighted_scores_exp = np.square(weighted_scores_exp)\\n weighted_scores_exp_mults = np.dot(weighted_scores_exp, weighted_scores_exp.T)\\n uw_mult = np.multiply(self.u, weighted_scores_exp)\\n uw_mult_sum = np.sum(np.multiply(self.u, weighted_scores_exp), axis=0)\\n\\n f = self.reg * np.log(sum_weighted_scores_exp) + self.kappa * np.sum(phi) # f(x)\\n\\n dfdw = -1 * uw_mult_sum.T / sum_weighted_scores_exp\\n dfdphi = (-1 * weighted_scores_exp / sum_weighted_scores_exp) + self.kappa\\n Df = np.concatenate((dfdw, dfdphi), axis=0) # Gradient\\n\\n mf = matrix(f)\\n mDf = matrix(Df.T)\\n if z is None:\\n return mf, mDf\\n # Assumes d_0 is uniform\\n H = np.zeros(shape=(N, N)) # Hessian\\n dfdwiwi = np.zeros(shape=(T, 1))\\n dfdphiiphij = -1 * reg_inv * (np.tril(weighted_scores_exp_mults)) / sum_weighted_scores_exp_square\\n dfdphiiphii = reg_inv * (np.multiply(weighted_scores_exp,\\n sum_weighted_scores_exp - weighted_scores_exp) / sum_weighted_scores_exp_square)\\n # dfdwiwj, dfwiphij are zeros\\n dfdphiiwj = reg_inv * ((\\n uw_mult * sum_weighted_scores_exp - weighted_scores_exp * uw_mult_sum) / sum_weighted_scores_exp_square)\\n\\n H[T:, T:] = dfdphiiphij\\n H[T:, :T] = dfdphiiwj\\n H_diagonal = np.concatenate((dfdwiwi, dfdphiiphii), axis=0)\\n np.fill_diagonal(H, H_diagonal)\\n\\n mH = matrix(z[0] * H)\\n return mf, mDf, mH\\n\\n prev_w = self.w\\n prev_slacks = self.slacks\\n try:\\n wphi = solvers.cp(F, G=G, h=h, A=A, b=b)['x']\\n self.w = wphi[:T, :]\\n self.slacks = wphi[T:, :]\\n except Exception as e: # Catch rank errors and continue to next iteration\\n self.slacks = prev_slacks\\n self.w = prev_w\\n try:\\n self.w = np.concatenate((self.w, [[1 / (len(self.w) + 1)]]), axis=0)\\n except:\\n self.w = np.concatenate((self.w, [1 / (len(self.w) + 1)]), axis=0)\\n self.w /= np.sum(self.w)\\n\\n scores = ((-1 / self.reg) * np.squeeze(np.asarray(np.dot(self.u, self.w) + self.slacks))) + np.log(\\n self.d_0) # Update according to Equation (6)\\n return self.softmax(scores)\",\n \"def beam_search(X, u, w, b, relLabels):\\n\\n candidate_paths = [[] for _ in range(10)] # contains the candidate label sets\\n candidate_vals =[[] for _ in range(10)] # contains the label values (-1/1) for each candidate set\\n candidate_scores = [0. for _ in range(10)]\\n min_score = -1000\\n\\n iter = 0\\n start = 0\\n while True:\\n # print(\\\"Iter: \\\", iter)\\n intermediate_paths = {}\\n # intermediate_paths_val = []\\n interim_scores = []\\n hash_table = {}\\n\\n cnt_paths = 0\\n for cp in range(5):\\n labels_curr = candidate_paths[cp]\\n labels_val_curr = candidate_vals[cp]\\n scores_curr = candidate_scores[cp]\\n Y = -np.ones((10, 1))\\n for lv in range(len(labels_val_curr)):\\n Y[labels_curr[lv]] = labels_val_curr[lv]\\n\\n for l in range(10):\\n candidate_interim = labels_curr[:]\\n candidate_vals_interim = labels_val_curr[:]\\n # if l in labels_curr:\\n # continue\\n\\n temp_relLabels = []\\n for lc in range(len(labels_curr)):\\n temp_relLabels.extend(relLabels[labels_curr[lc]])\\n\\n # temp_relLabels = np.array(list(set(temp_relLabels)))\\n temp_relLabels = np.array(list(set(relLabels[l]).intersection(set(labels_curr))))\\n model_pos = returnModelVal(X, Y, 1.0, u[l], u[l], b[l][0], np.array(temp_relLabels))\\n candidate_interim.append(l)\\n\\n if model_pos < 0:\\n # print('hello')\\n candidate_vals_interim.append(-1)\\n interim_scores.append(-model_pos)\\n else:\\n candidate_vals_interim.append(1)\\n interim_scores.append(model_pos)\\n\\n hash_table[cnt_paths] = candidate_interim\\n intermediate_paths[cnt_paths] = candidate_vals_interim\\n cnt_paths += 1\\n # For the first iteration, just iterate once - all labels in one iteration\\n if start == 0:\\n start = 1\\n break\\n\\n temp_paths = intermediate_paths\\n interim_zip = zip(intermediate_paths, interim_scores)\\n sorted_scores = sorted(interim_zip, key=lambda x: x[1], reverse=True)[:5]\\n intermediate_paths, scores = zip(*sorted_scores)\\n\\n temp_cand = []\\n temp_val = []\\n for i in range(len(intermediate_paths)):\\n temp_cand.append(hash_table[intermediate_paths[i]])\\n temp_val.append(temp_paths[intermediate_paths[i]])\\n # candidate_scores[i] += scores[i]\\n\\n candidate_paths = temp_cand\\n candidate_vals = temp_val\\n print(candidate_paths)\\n print(candidate_vals)\\n # print(scores)\\n # candidate_scores = scores\\n\\n # Exit condition from loop\\n # if max(interim_scores) < min_score:\\n # break\\n #\\n # min_score = min(interim_scores)\\n\\n iter += 1\\n if iter > 5:\\n break\\n\\n candidate_dict = {}\\n for i in range(5):\\n for c in range(len(candidate_paths[i])):\\n if candidate_paths[i][c] not in candidate_dict:\\n candidate_dict[candidate_paths[i][c]] = candidate_vals[i][c]\\n elif candidate_dict[candidate_paths[i][c]] != 2:\\n if candidate_dict[candidate_paths[i][c]] != candidate_vals[i][c]:\\n candidate_dict[candidate_paths[i][c]] = 2.\\n\\n print(candidate_dict)\\n exit()\\n return candidate_dict\",\n \"def get_wm_ws_Gx_bot(self):\\n # BASICALLY SETS self.Gm1_bot, self.dGm1_dS_bot, self.Gt1_bot, self.dGt1_dS_bot \\n z_u_r = self.grid_dict['z_u_r']\\n z_u_w = self.grid_dict['z_u_w']\\n [Ly,N] = self.b.shape\\n #---> j-loop\\n for j in range(Ly): \\n self.kbl[j] = N # initialize search\\n #-> end j-loop\\n\\n #--> k-loop\\n for k in range(N-1,0,-1):\\n k_w = k\\n k_r = k-1\\n # --> j loop \\n for j in range(Ly):\\n if z_u_r[j,k_r] - z_u_w[j,0] > self.hbbl[j]:\\n self.kbl[j] = k_w\\n\\n #--> end k\\n # --> end j\\n\\n\\n '''\\n Compute nondimenisonal shape function coefficeints Gx() by\\n matching values and vertical derivatives of interior mixing\\n coefficients at hbbl (sigma=1)\\n '''\\n\\n self.Gm1_bot = np.zeros([Ly])\\n self.dGm1_dS_bot = np.zeros([Ly])\\n self.Gt1_bot = np.zeros([Ly])\\n self.dGt1_dS_bot = np.zeros([Ly]) \\n self.Av_bl_bot = np.zeros([Ly])\\n self.dAv_bl_bot = np.zeros([Ly]) \\n self.cff_up_bot = np.zeros([Ly])\\n self.cff_dn_bot = np.zeros([Ly])\\n\\n\\n\\n\\n\\n self.wm_bot = np.zeros([Ly])\\n self.ws_bot = np.zeros([Ly]) \\n\\n # CALCULATE ustar for the bottom based on bototm velocities\\n \\n \\n \\n # CALCULATE r_D\\n self.r_D = TTTW_func.get_r_D(self.u,self.v,self.Zob,self.grid_dict) \\n u = self.u\\n v_upts = TTTW_func.v2u(self.v)\\n \\n ubar = np.mean(u,axis=1)\\n vbar = np.mean(v_upts,axis=1)\\n\\n # --> j loop\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n if self.CD_SWITCH:\\n # DEPTH AVERAGED APPROACH\\n uref = u[j,0]\\n vref = v_upts[j,0]\\n ustar2 = self.C_D * (uref**2 + vref**2)\\n else:\\n ustar2 = self.r_D[j] * np.sqrt(u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n\\n self.wm_bot[j] = wm\\n self.ws_bot[j] = ws\\n \\n k_w = self.kbl[j] \\n z_bl = z_u_w[j,0] + self.hbbl[j]\\n\\n if z_bl < z_u_w[j,k_w-1]:\\n k_w = k_w-1\\n\\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * ( self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl_bot[j] = Av_bl\\n self.dAv_bl_bot[j] = dAv_bl\\n\\n\\n self.Gm1_bot[j] = Av_bl / (self.hbbl[j] * wm + self.eps)\\n self.dGm1_dS_bot[j] = np.min([0,-dAv_bl/(ws+self.eps)])\\n\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * ( self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1_bot[j] = At_bl / (self.hbbl[j] * ws + self.eps)\\n self.dGt1_dS_bot[j] = np.min([0,-dAt_bl/(ws+self.eps)])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6306666","0.6230689","0.60974103","0.60286343","0.6020426","0.5946944","0.5886355","0.5848057","0.5817468","0.5804055","0.57914394","0.5780807","0.5776807","0.5772554","0.57718253","0.5769636","0.5736517","0.57279","0.572249","0.57167286","0.5711532","0.5710818","0.56858236","0.5684907","0.5681367","0.56792843","0.56785923","0.56751806","0.56713843","0.5671282","0.56708044","0.5667581","0.56599456","0.5650766","0.5645501","0.56412214","0.5639554","0.5620629","0.56192034","0.5615366","0.5600064","0.5596593","0.55921775","0.55893016","0.55834585","0.55824745","0.5581326","0.55750275","0.55686337","0.55600727","0.55570555","0.55481917","0.55437154","0.55352503","0.55319047","0.55289257","0.55247265","0.5522719","0.5520444","0.55126613","0.55109537","0.55107486","0.5503505","0.54964346","0.549479","0.5493652","0.5492367","0.54916996","0.5490832","0.5487287","0.5484966","0.54828995","0.5482414","0.54784906","0.54738015","0.54734874","0.5469724","0.54635745","0.5463395","0.5462466","0.5459867","0.54579145","0.5449223","0.5447237","0.5446383","0.54443556","0.54337966","0.54333586","0.5426214","0.54191875","0.54155076","0.541479","0.541143","0.54051226","0.5403734","0.5393767","0.53917146","0.53916734","0.5391547","0.53882325"],"string":"[\n \"0.6306666\",\n \"0.6230689\",\n \"0.60974103\",\n \"0.60286343\",\n \"0.6020426\",\n \"0.5946944\",\n \"0.5886355\",\n \"0.5848057\",\n \"0.5817468\",\n \"0.5804055\",\n \"0.57914394\",\n \"0.5780807\",\n \"0.5776807\",\n \"0.5772554\",\n \"0.57718253\",\n \"0.5769636\",\n \"0.5736517\",\n \"0.57279\",\n \"0.572249\",\n \"0.57167286\",\n \"0.5711532\",\n \"0.5710818\",\n \"0.56858236\",\n \"0.5684907\",\n \"0.5681367\",\n \"0.56792843\",\n \"0.56785923\",\n \"0.56751806\",\n \"0.56713843\",\n \"0.5671282\",\n \"0.56708044\",\n \"0.5667581\",\n \"0.56599456\",\n \"0.5650766\",\n \"0.5645501\",\n \"0.56412214\",\n \"0.5639554\",\n \"0.5620629\",\n \"0.56192034\",\n \"0.5615366\",\n \"0.5600064\",\n \"0.5596593\",\n \"0.55921775\",\n \"0.55893016\",\n \"0.55834585\",\n \"0.55824745\",\n \"0.5581326\",\n \"0.55750275\",\n \"0.55686337\",\n \"0.55600727\",\n \"0.55570555\",\n \"0.55481917\",\n \"0.55437154\",\n \"0.55352503\",\n \"0.55319047\",\n \"0.55289257\",\n \"0.55247265\",\n \"0.5522719\",\n \"0.5520444\",\n \"0.55126613\",\n \"0.55109537\",\n \"0.55107486\",\n \"0.5503505\",\n \"0.54964346\",\n \"0.549479\",\n \"0.5493652\",\n \"0.5492367\",\n \"0.54916996\",\n \"0.5490832\",\n \"0.5487287\",\n \"0.5484966\",\n \"0.54828995\",\n \"0.5482414\",\n \"0.54784906\",\n \"0.54738015\",\n \"0.54734874\",\n \"0.5469724\",\n \"0.54635745\",\n \"0.5463395\",\n \"0.5462466\",\n \"0.5459867\",\n \"0.54579145\",\n \"0.5449223\",\n \"0.5447237\",\n \"0.5446383\",\n \"0.54443556\",\n \"0.54337966\",\n \"0.54333586\",\n \"0.5426214\",\n \"0.54191875\",\n \"0.54155076\",\n \"0.541479\",\n \"0.541143\",\n \"0.54051226\",\n \"0.5403734\",\n \"0.5393767\",\n \"0.53917146\",\n \"0.53916734\",\n \"0.5391547\",\n \"0.53882325\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5691289"},"document_rank":{"kind":"string","value":"22"}}},{"rowIdx":84675,"cells":{"query":{"kind":"string","value":"Find a bracket (a,b,c) such that policy function for next period asset level, a[x;asset[l],y] lies in the interval (a,b)"},"document":{"kind":"string","value":"def GetBracket(self, y, l, m, agrid):\n a, b, c = agrid[0], agrid[0]-agrid[1], agrid[0]-agrid[2]\n m0 = m\n v0 = self.neg\n while a > b or b > c:\n v1 = self.value(y, agrid[l], agrid[m])\n if v1 > v0:\n if m == 0:\n a, b = agrid[m], agrid[m]\n else:\n b, a = agrid[m], agrid[m-1]\n v0, m0 = v1, m\n else:\n c = agrid[m]\n if m == self.Na - 1:\n a, b, c = agrid[m-1], agrid[m], agrid[m]\n m = m + 1\n return m0, a, b, c"},"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 find_coeff(depth, period = 2*pi):\n\tfund_feq = 2 * pi / period\n\tAK = []\n\talphaK = []\n\n\tfor n in range(1, depth+1):\n\t\tdef a_function(x, i):\n\t\t\treturn input_function(x) * cos(i * fund_feq * x)\n\t\tdef b_function(x, i):\n\t\t\treturn input_function(x) * sin(i * fund_feq * x)\n\t\t(a, err) = quad(a_function, 0, period, n)\n\t\tan = 2 * a / period\n\t\t(b, err) = quad(b_function, 0, period, n)\n\t\tbn = 2 * b / period\n\t\tAk = math.sqrt(an**2 + bn**2)\n\t\tAK.append(Ak)\n\t\talphak = math.asin(an/Ak)\n\t\talphaK.append(alphak)\n\treturn (AK, alphaK)","def bracket(func, xa=0.0, xb=1.0, args=(), grow_limit=110.0, maxiter=1000):\n\t_gold = 1.618034\n\t_verysmall_num = 1e-21\n\tfa = apply(func, (xa,)+args)\n\tfb = apply(func, (xb,)+args)\n\tif (fa < fb):\t\t\t # Switch so fa > fb\n\t dum = xa; xa = xb; xb = dum\n\t dum = fa; fa = fb; fb = dum\n\txc = xb + _gold*(xb-xa)\n\tfc = apply(func, (xc,)+args)\n\tfuncalls = 3\n\titer = 0\n\twhile (fc < fb):\n\t tmp1 = (xb - xa)*(fb-fc)\n\t tmp2 = (xb - xc)*(fb-fa)\n\t val = tmp2-tmp1\n\t if abs(val) < _verysmall_num:\n\t\tdenom = 2.0*_verysmall_num\n\t else:\n\t\tdenom = 2.0*val\n\t w = xb - ((xb-xc)*tmp2-(xb-xa)*tmp1)/denom\n\t wlim = xb + grow_limit*(xc-xb)\n\t if iter > maxiter:\n\t\traise RuntimeError, \"Too many iterations.\"\n\t iter += 1\n\t if (w-xc)*(xb-w) > 0.0:\n\t\tfw = apply(func, (w,)+args)\n\t\tfuncalls += 1\n\t\tif (fw < fc):\n\t\t xa = xb; xb=w; fa=fb; fb=fw\n\t\t return xa, xb, xc, fa, fb, fc, funcalls\n\t\telif (fw > fb):\n\t\t xc = w; fc=fw\n\t\t return xa, xb, xc, fa, fb, fc, funcalls\n\t\tw = xc + _gold*(xc-xb)\n\t\tfw = apply(func, (w,)+args)\n\t\tfuncalls += 1\n\t elif (w-wlim)*(wlim-xc) >= 0.0:\n\t\tw = wlim\n\t\tfw = apply(func, (w,)+args)\n\t\tfuncalls += 1\n\t elif (w-wlim)*(xc-w) > 0.0:\n\t\tfw = apply(func, (w,)+args)\n\t\tfuncalls += 1\n\t\tif (fw < fc):\n\t\t xb=xc; xc=w; w=xc+_gold*(xc-xb)\n\t\t fb=fc; fc=fw; fw=apply(func, (w,)+args)\n\t\t funcalls += 1\n\t else:\n\t\tw = xc + _gold*(xc-xb)\n\t\tfw = apply(func, (w,)+args)\n\t\tfuncalls += 1\n\t xa=xb; xb=xc; xc=w\n\t fa=fb; fb=fc; fc=fw\n\treturn xa, xb, xc, fa, fb, fc, funcalls","def minimum_spanning_arborescence(sol):","def bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p):\r\n a0 = 0\r\n a1 = a\r\n Ja0 = J0\r\n ga0 = g0\r\n Jprime = g0.T@p\r\n i = 0\r\n Ja1, ga1 = f(x0+a1*p)\r\n while True:\r\n if (Ja1 > (J0 + mu1*a1*Jprime)) or (Ja1 > Ja0 and i > 1):\r\n Ja, ga, astar = pinpoint(f, J0, g0, x0, mu1, mu2, \\\r\n a0, Ja0, ga0, a1, Ja1, ga1, p)\r\n return Ja, ga, astar\r\n Jprimea1 = ga1.T@p\r\n if (np.abs(Jprimea1) <= np.abs(mu2*Jprime)):\r\n astar = a1\r\n return Ja1, ga1, astar\r\n elif (Jprimea1 >= 0):\r\n Ja, ga, astar = pinpoint(f, J0, g0, x0, mu1, mu2, \\\r\n a1, Ja1, ga1, a0, Ja0, ga0, p)\r\n return Ja, ga, astar\r\n else:\r\n a0 = a1\r\n Ja0 = Ja1\r\n a1 = 1.2*a1\r\n Ja1, ga1 = f(x0+a1*p)\r\n i += 1","def get_confidence_interval(self,a,b):\n\t\tk_vals,prob_vals = self.tuple_of_probabilities\n\t\tworking_indices = [i for i,v in enumerate(k_vals) if (v >= a and v<= b)]\n\t\tworking_prob_vals = [prob_vals[i] for i in working_indices]\n\t\treturn sum(working_prob_vals)","def evaluate(bounds , func):\n if len(bounds) != 2:\n raise ValueError(\"Bounds should contain 2 elements, found %d.\" % len(bounds))\n\n a = bounds[0]\n b = bounds[1]\n ya = func(a)\n yb = func((a+b)/2.)\n yc = func(b)\n I = (b-a) * (ya + 4. * yb + yc) / 6.\n return I","def search_interval_3d(function, point_a, point_b, step, tol, max_iterations,\n show_process = False):\n # The first interval is created with the values [0, step]\n t = step\n # We use a parametrization for the line based on the two points given.\n # It is possible to get any point in the line changing the parameters t.\n # For t=0 we get the point_b and for t=1 we get the point_a.\n last_val = function( line_param(point_a, point_b, 0) )\n current_val = function( line_param(point_a, point_b, t) )\n \n # While the signs of the function evaluated in the ends of the interval is\n # the same.\n iterations = 0\n while last_val*current_val > 0:\n if iterations > max_iterations:\n raise Exception('Maximum iterations reached. But no solution was found.')\n # Update the step\n last_val = current_val\n t += step\n # Calculate the new value\n current_val = function( line_param(point_a, point_b, t) )\n iterations += 1\n \n # These point represent the interval for which a change is the signs exist.\n # This means that there is a point in this interval for which the function\n # is zero. We use bisection in this interval to find that point.\n left_point = line_param(point_a, point_b, t - step)\n right_point = line_param(point_a, point_b, t)\n \n if show_process: \n print('number of iterations to find interval = {0}'.format(iterations))\n print('interval found : [{0} , {1} ])'.format(left_point, right_point))\n \n return left_point, right_point","def get_bounds(self, A: list, c: int) -> (int, int):\r\n\r\n # This implementation uses two binary search algorithms to find\r\n # the upper and lower bound.\r\n # First step is to isolate the upper_bound.\r\n\r\n L = 0\r\n R = len(A)\r\n while L < R:\r\n # Find the middle value\r\n m = math.floor((L + R) / 2)\r\n v = A[m]\r\n\r\n # Check if |A[i] - i| < c:\r\n if abs(v - m) > c:\r\n # This step is important, if we are on a negative number\r\n # We need to move right instead of left.\r\n if v < 0 or (v - m) < 0:\r\n L = m + 1\r\n else:\r\n # Else, we need to move towards the left.\r\n R = m\r\n else:\r\n # If it matches the condition, move the left up because we're\r\n # going towards the lowest number.\r\n L = m + 1\r\n upper_bound = R\r\n\r\n # Now that we have the upper bound, we only need to\r\n # Binary search for the lower bound between index 0 and upper_bound.\r\n L = 0\r\n R = upper_bound\r\n while L < R:\r\n # find the middle\r\n m = math.floor((L + R) / 2)\r\n if abs(A[m] - m) > c:\r\n # If it's greater, move the left up.\r\n L = m + 1\r\n else:\r\n # Else, move the right down.\r\n R = m\r\n\r\n # Finally we have the lower bound.\r\n lower_bound = L\r\n\r\n # Return the lower bound and the upper bound index\r\n # Note the -1 because the upper bound will give the\r\n # size of the array in worst case.\r\n return lower_bound, upper_bound - 1","def interval(a, b):\n aIndex, bIndex = None, None\n for i in range(len(table)):\n fs = table[i]\n if aIndex == None and fs >= a: aIndex = i\n if bIndex == None and fs > b: bIndex = i\n if bIndex == None: bIndex = len(table)\n return bIndex - aIndex","def solve_working(\n assets_this_period,\n assets_next_period,\n hc_this_period,\n hc_next_period,\n interest_rate,\n wage_rate,\n income_tax_rate,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n delta_hc,\n zeta,\n psi,\n n_gridpoints_capital,\n n_gridpoints_hc,\n efficiency,\n survival_rate,\n):\n # Initialize objects\n policy_labor_working_tmp = np.zeros(\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\n )\n\n # Implied hc effort\n hc_effort = get_hc_effort(\n hc_this_period=hc_this_period,\n hc_next_period=hc_next_period,\n zeta=zeta,\n psi=psi,\n delta_hc=delta_hc,\n )\n\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\n\n # Implied labor supply\n labor_input = 1 - hc_effort\n\n # Consumption\n consumption = get_consumption(\n assets_this_period=assets_this_period,\n assets_next_period=assets_next_period,\n pension_benefit=np.float64(0.0),\n labor_input=labor_input,\n interest_rate=interest_rate,\n wage_rate=wage_rate,\n income_tax_rate=income_tax_rate,\n productivity=hc_this_period,\n efficiency=efficiency,\n )\n\n # Flow utility\n flow_utility = util(\n consumption=consumption,\n labor_input=labor_input,\n hc_effort=hc_effort,\n gamma=gamma,\n sigma=sigma,\n )\n\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\n\n # Value function on the complete mesh (i.e. for all possible choices)\n value_full = flow_utility + beta * survival_rate * continuation_value\n\n # Derive optimal policies and store value function given optimal choices\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\n for assets_this_period_idx in range(n_gridpoints_capital):\n for hc_this_period_idx in range(n_gridpoints_hc):\n assets_next_period_idx = policy_capital_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n hc_next_period_idx = policy_hc_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n policy_labor_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ] = labor_input[\n assets_this_period_idx,\n assets_next_period_idx,\n hc_this_period_idx,\n hc_next_period_idx,\n ]\n\n return (\n policy_capital_working_tmp,\n policy_hc_working_tmp,\n policy_labor_working_tmp,\n value_working_tmp,\n )","def find_balance(stmt, start=0):\n open_list = ['(']\n close_list = [')']\n stack = []\n found = False\n for i, val in enumerate(stmt[start:]):\n if val in open_list:\n stack.append(val)\n found = True\n elif val in close_list:\n pos = close_list.index(val)\n if (stack and open_list[pos] == stack[len(stack) - 1]):\n stack.pop()\n else:\n raise Exception(\"Unbalanced parentheses found\")\n if found and not stack:\n return i + start + 1\n raise Exception(\"Unbalanced parentheses found\")","def beta_range_s_circular(s,sma):\n #sma**2. = s**2. + y**2.\n if s > sma: #failure mode/nonphysical\n s = sma\n y = np.sqrt(sma**2.-s**2.)\n beta_min = np.pi/2. - np.arctan2(y,s)\n beta_max = np.pi/2. + np.arctan2(y,s)\n return beta_min, beta_max","def overlap_ss(Ax, Ay, Az, Cx, Cy, Cz, alpha_bra, alpha_ket, c1, c2):\n A = np.array([Ax, Ay, Az])\n C = np.array([Cx, Cy, Cz])\n alpha_sum = alpha_bra + alpha_ket\n return c1 * c2 * (np.pi / alpha_sum)**(3/2) * np.exp((-alpha_bra * alpha_ket * np.dot(A-C, A-C)) / alpha_sum)","def testPolicy( \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n self, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n symbol=\"jpm\", \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sd=dt.datetime(2008, 1, 1), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ed=dt.datetime(2009, 12, 31), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sv=10000, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ): \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n dates = pd.date_range(sd,ed)\n df_prices = ind.get_price(symbol, dates)\n\n daily_rets = (df_prices / df_prices.shift(1)) - 1\n daily_rets = daily_rets[1:]\n\n\n sd_older = sd - dt.timedelta(days=365)\n dates_older = pd.date_range(sd_older,ed)\n df_prices_older = ind.get_price(symbol, dates_older)\n sd_key = df_prices.index[0]\n sd_index = df_prices_older.index.get_loc(sd_key)\n\n\n df_holdings = df_prices.copy()\n df_holdings['Holdings'] = np.nan\n del df_holdings[symbol]\n # print(df_holdings)\n\n cum_ret_prev = 0\n iters = 0\n\n\n num_bins = len(self.bins)\n\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\n _,_,ind5 = ind.get_MACD(df_prices_older)\n BB = ind1.iloc[sd_index:].values\n CCI = ind2.iloc[sd_index:].values\n SMA_Cross = ind3.iloc[sd_index:].values\n Momentum = ind4.iloc[sd_index:].values\n MACD = ind5.iloc[sd_index:].values\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\n state = x_0 + x_3*10 + x_4*100\n\n\n\n\n\n self.learner.rar = 0\n\n action = self.learner.querysetstate(state[0])\n\n daily_return = daily_rets.iloc[0][symbol]\n df_holdings.iloc[0]['Holdings'] = 0\n\n\n for day_idx in range(1,daily_rets.shape[0]):\n\n # implement action\n cur_price = df_prices.iloc[day_idx-1][symbol]\n next_price = df_prices.iloc[day_idx][symbol]\n action = self.learner.querysetstate(state[day_idx])\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\n\n\n df_holdings.iloc[-1]['Holdings'] = 0\n df_trades = df_holdings.diff()\n df_trades['Trades'] = df_trades['Holdings']\n del df_trades['Holdings']\n df_trades.iloc[0]['Trades'] = 0\n return df_trades","def find_s_in_range(a, b, prev_s, B, c):\n ri = ceil(2 * (b * prev_s - 2 * B), n)\n\n while True:\n si_lower = ceil(2 * B + ri * n, b)\n si_upper = ceil(3 * B + ri * n, a)\n\n for si in range(si_lower, si_upper):\n attempt = (c * pow(si, e, n)) % n\n attempt = rsa1.integer_to_bytes(attempt)\n\n if oracle(attempt):\n return si\n \n ri += 1","def boundary(gap, min_tags_in_window, average):\n\tassert min_tags_in_window >= 1;\n\ttemp = 0;\n\tfor i in range(0, min_tags_in_window): temp += poisson(i, average);\n\ttemp = pow(temp, gap+1); \n\treturn temp*temp; # start & end ","def set_sobol_g_func():\n a = np.zeros(21)\n x = np.zeros(21) \n\n # a[0:2] = 0\n # a[2:9] = [0.005, 0.020, 0.040, 0.060, 0.08, 0.090, 1]\n # a[9:16] = 2\n # a[16:24] = [2.10, 2.25, 2.75, 3, 3.10, 3.15, 3.25, 3.50]\n # a[24:30] = 9\n # a[30:44] = [8, 8.5, 9, 10, 10.5, 11, 12, 12.5, 13, 13.5, 14, 14.5, 15, 16]\n # a[44:] = [70, 75, 80, 85, 90, 99]\n\n a[0:2] = 0\n a[2:4] = [0.005, 0.090]\n a[4:7] = 2\n a[7:11] = [2.10, 2.75, 3, 3.15]\n a[11:15] = [8, 13, 13.5, 16]\n a[15:] = [70, 75, 80, 85, 90, 99]\n\n x_names = ['x' + str(i+1) for i in range(21)]\n len_params = len(x_names)\n x_bounds = np.zeros((21, 2))\n x_bounds[:, 0] = 0\n x_bounds[:, 1] = 1\n\n problem = {\n 'num_vars': len(x),\n 'names': x_names,\n 'bounds': x_bounds\n }\n return a, x, x_bounds, x_names, len_params, problem","def getx(v, lb, ub, i, B):\r\n x = lb + np.multiply((ub - lb), v)\r\n x[i] = B - (x.sum() - x[i])\r\n # Test if variable x[i] is within the bounds\r\n if x[i] <= ub[i] and x[i] >= lb[i]:\r\n return x\r\n else:\r\n return np.array([])","def _get_effect_interval(counts, effect, power_alpha=0.05, ci_alpha=None):\n\n if isinstance(effect, (int, float)):\n l_bar = effect\n ci = np.nan\n\n elif ci_alpha is None:\n ci = np.nanstd(effect)\n l_bar = np.nanmean(effect)\n else:\n ci = confidence_bound(effect, alpha=ci_alpha)\n l_bar = np.nanmean(effect)\n\n l_low = l_bar - ci\n l_hi = l_bar + ci\n\n power_bar = z_power(counts, l_bar, power_alpha)\n if not np.isnan(ci):\n power_low = z_power(counts, l_low, power_alpha)\n power_hi = z_power(counts, l_hi, power_alpha)\n else:\n power_low = np.nan * power_bar\n power_hi = np.nan * power_bar\n\n return power_bar, power_low, power_hi","def interq_range(sig):\n #ny.percentile(sig, 75) - ny.percentile(sig, 25)\n return np.percentile(sig, 75) - np.percentile(sig, 25)","def budget_problem3(balance, annualInterestRate):\r\n remaining = balance\r\n\r\n # creating the following bounds assists with bisection search\r\n lo = balance/12\r\n hi = ((balance * (annualInterestRate/12))**12)/12\r\n payment = (lo + hi)/2\r\n\r\n while remaining != 0:\r\n for month in range(12):\r\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\r\n if remaining > 0:\r\n lo = payment\r\n elif round(remaining,2) < -0.11:\r\n hi = payment\r\n else:\r\n break\r\n payment = (lo + hi)/2\r\n remaining = balance\r\n print 'Lowest Payment: ' + str(round(payment,2))\r\n return round(payment,2)","def bisecter(func, step=0.1):\n points = list(func.points(step))\n area = sum(map(lambda p: p[1], points))\n\n current = 0.\n for x, y in points:\n current += y\n if current >= area / 2:\n return x","def get_new_bracket(x1, x2, x3, x4):\n points = [x1, x2, x3]\n dist = float(inf)\n for point in points:\n if abs(x4 - point) < dist and f(point) * f(x4) < 0:\n valid_point = point\n dist = abs(x4 - point)\n return valid_point","def compute_interval_limits(bias, acceleration, n_boots, ci=95):\n from scipy.stats import norm\n from numpy import isnan, nan\n\n alpha = _compute_alpha_from_ci(ci)\n\n alpha_low = alpha / 2\n alpha_high = 1 - (alpha / 2)\n\n z_low = norm.ppf(alpha_low)\n z_high = norm.ppf(alpha_high)\n\n kws = {'bias': bias, 'acceleration': acceleration}\n low = _compute_quantile(z_low, **kws)\n high = _compute_quantile(z_high, **kws)\n\n if isnan(low) or isnan(high):\n return low, high\n\n else:\n low = int(norm.cdf(low) * n_boots)\n high = int(norm.cdf(high) * n_boots)\n return low, high","def compound(ir, period):\n\treturn ir.compound(period)","def _intersect_continuous(self, interval):\n first = self.intervals.bisect_left(interval)\n last = first\n while first > 0 and \\\n self.intervals[first - 1].upper >= interval.lower:\n first -= 1\n while last < len(self.intervals) and \\\n self.intervals[last].lower <= interval.upper:\n last += 1\n return first, last","def interval_prob(x1, x2, a, b):\n with mp.extradps(5):\n a, b = _validate_a_b(a, b)\n x1 = mp.mpf(x1)\n x2 = mp.mpf(x2)\n if x1 > x2:\n raise ValueError('x1 must not be greater than x2')\n return mp.betainc(a, b, x1, x2, regularized=True)","def bs(a, b):\n if b - a == 1:\n # Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)\n if a == 0:\n Pab = Qab = mpz(1)\n else:\n Pab = mpz((6*a-5)*(2*a-1)*(6*a-1))\n Qab = mpz(a*a*a*C3_OVER_24)\n Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)\n if a & 1:\n Tab = -Tab\n else:\n # Recursively compute P(a,b), Q(a,b) and T(a,b)\n # m is the midpoint of a and b\n m = (a + b) // 2\n # Recursively calculate P(a,m), Q(a,m) and T(a,m)\n Pam, Qam, Tam = bs(a, m)\n # Recursively calculate P(m,b), Q(m,b) and T(m,b)\n Pmb, Qmb, Tmb = bs(m, b)\n # Now combine\n Pab = Pam * Pmb\n Qab = Qam * Qmb\n Tab = Qmb * Tam + Pam * Tmb\n return Pab, Qab, Tab","def findInterval(intervals,interval):\n low,ind = algorithms.binsearch(intervals,interval.start-1,lambda a,b: cmp(a.start,b))\n return (low,ind)","def boundary_conditions(x, t, z=None, nbsym=2):\n indmax = argrelmax(x)[0]\n indmin = argrelmin(x)[0]\n lx = x.shape[0] - 1\n if indmin.shape[0] + indmax.shape[0] < 3:\n raise ValueError(\"Not enough extrema.\")\n\n if indmax[0] < indmin[0]:\n if x[0] > x[indmin[0]]:\n lmax = indmax[1:np.min([indmax.shape[0], nbsym + 1])][::-1]\n lmin = indmin[:np.min([indmin.shape[0], nbsym])][::-1]\n lsym = indmax[0]\n else:\n lmax = indmax[1:np.min([indmax.shape[0], nbsym])][::-1]\n lmin = indmin[:np.min([indmin.shape[0], nbsym - 1])][::-1]\n lmin = np.hstack((lmin, [1]))\n lsym = 1\n else:\n if x[0] < x[indmax[0]]:\n lmax = indmax[:np.min([indmax.shape[0], nbsym])][::-1]\n lmin = indmin[1:np.min([indmin.shape[0], nbsym + 1])][::-1]\n lsym = indmin[0]\n else:\n lmax = indmax[:np.min([indmin.shape[0], nbsym - 1])][::-1]\n lmax = np.hstack((lmax, [1]))\n lmin = indmin[:np.min([indmax.shape[0], nbsym])][::-1]\n lsym = 1\n\n if indmax[-1] < indmin[-1]:\n if x[-1] < x[indmax[-1]]:\n rmax = indmax[(max([indmax.shape[0] - nbsym + 1, 1]) - 1):][::-1]\n rmin = indmin[(max([indmin.shape[0] - nbsym, 1]) - 1):-1][::-1]\n rsym = indmin[-1]\n else:\n rmax = indmax[max(indmax.shape[0] - nbsym + 1, 0):indmax.shape[0]][::-1]\n rmax = np.hstack(([lx], rmax))\n rmin = indmin[max(indmin.shape[0] - nbsym, 0):][::-1]\n rsym = lx\n else:\n if x[-1] > x[indmin[-1]]:\n rmax = indmax[max(indmax.shape[0] - nbsym - 1, 0):-1][::-1]\n rmin = indmin[max(indmin.shape[0] - nbsym, 0):][::-1]\n rsym = indmax[-1]\n else:\n rmax = indmax[max(indmax.shape[0] - nbsym, 0):][::-1]\n rmin = indmin[max(indmin.shape[0] - nbsym + 1, 0):][::-1]\n rmin = np.hstack(([lx], rmin))\n rsym = lx\n\n tlmin = 2 * t[lsym] - t[lmin]\n tlmax = 2 * t[lsym] - t[lmax]\n trmin = 2 * t[rsym] - t[rmin]\n trmax = 2 * t[rsym] - t[rmax]\n\n # In case symmetrized parts do not extend enough\n if (tlmin[0] > t[0]) or (tlmax[0] > t[1]):\n if lsym == indmax[0]:\n lmax = indmax[:np.min((indmax.shape[0], nbsym))][::-1]\n else:\n lmin = indmin[:np.min((indmin.shape[0], nbsym))][::-1]\n if lsym == 1:\n raise Exception(\"Bug\")\n lsym = 1\n tlmin = 2 * t[lsym] - t[lmin]\n tlmax = 2 * t[lsym] - t[lmax]\n\n if (trmin[-1] < t[lx]) or (trmax[-1] < t[lx]):\n if rsym == indmax.shape[0]:\n rmax = indmax[np.max([indmax.shape[0] - nbsym + 1,\n 1]):indmax.shape[0]][::-1]\n else:\n rmin = indmin[np.max([indmax.shape[0] - nbsym + 1,\n 1]):indmin.shape[0]][::-1]\n\n if rsym == lx:\n raise Exception(\"bug\")\n rsym = lx\n trmin = 2 * t[rsym] - t[rmin]\n trmax = 2 * t[rsym] - t[rmax]\n\n if z is None:\n z = x\n zlmax = z[lmax]\n zlmin = z[lmin]\n zrmax = z[rmax]\n zrmin = z[rmin]\n\n tmin = map(np.array, [tlmin, t[indmin], trmin])\n tmax = map(np.array, [tlmax, t[indmax], trmax])\n zmin = map(np.array, [zlmin, z[indmin], zrmin])\n zmax = map(np.array, [zlmax, z[indmax], zrmax])\n\n tmin, tmax, zmin, zmax = map(np.hstack, [tmin, tmax, zmin, zmax])\n return tmin, tmax, zmin, zmax","def find_balanced_budget_tax(c):\n def steady_state_budget(t):\n e, u, w = compute_steady_state_quantities(c, t)\n return t - u * c\n\n tau = brentq(steady_state_budget, 0.0, 0.9 * c)\n return tau","def lagrange_coefficients_ASTME2022(interval=10, interval_type='inner'):\n\n global _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE\n if _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE is None:\n _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE = CaseInsensitiveMapping()\n\n name_lica = ', '.join((str(interval), interval_type))\n if name_lica in _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE:\n return _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE[name_lica]\n\n r_n = np.linspace(1 / interval, 1 - (1 / interval), interval - 1)\n d = 3\n if interval_type.lower() == 'inner':\n r_n += 1\n d = 4\n\n lica = _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE[name_lica] = (\n as_float_array([lagrange_coefficients(r, d) for r in r_n]))\n\n return lica","def equation_level_calculation(element_x, element_y):\n a = 4 * pow(element_x, 2) + pow(element_y, 2)\n b = 3 * pow(element_x, 2) + pow(element_y, 2)\n c = 3 * pow(element_x, 2) - pow(element_y, 2) if element_x > element_y else None\n return [a, b, c]","def bs(a, b):\n if b - a == 1:\n # Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)\n if a == 0:\n Pab = Qab = mpz(1)\n else:\n Pab = mpz((6*a-5)*(2*a-1)*(6*a-1))\n Qab = mpz(a*a*a*C3_OVER_24)\n Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)\n if a & 1:\n Tab = -Tab\n else:\n # Recursively compute P(a,b), Q(a,b) and T(a,b)\n # m is the midpoint of a and b\n m = (a + b) // 2\n # Recursively calculate P(a,m), Q(a,m) and T(a,m)\n Pam, Qam, Tam = bs(a, m)\n # Recursively calculate P(m,b), Q(m,b) and T(m,b)\n Pmb, Qmb, Tmb = bs(m, b)\n # Now combine\n Pab = Pam * Pmb\n Qab = Qam * Qmb\n Tab = Qmb * Tam + Pam * Tmb\n return Pab, Qab, Tab","def boundary_conditions(particle_outer_radius, boundary_temp):\n\n boundary_condition = [particle_outer_radius, boundary_temp]\n\n return boundary_condition","def find_single_fit_range(lorentz_params):\n f0 = lorentz_params[1]\n FWHM = lorentz_params[2]\n return (f0 - 4 * FWHM, f0 - 2 * FWHM, f0 + 2 * FWHM, f0 + 4 * FWHM)","def get_bounds():\n bounds = [\n (0.1, 0.5), # Omega_m\n (0.05, 0.15) # beta\n ]\n return np.array(bounds)","def get_continuum_in_range(w,s,low_low, low_high, high_low, high_high,\n pmin=12,pmax=88, only_correct_negative_values = False,\n fit_degree=2, plot = True, verbose = True, warnings=True) :\n s_low = s[np.where((w <= low_low))] \n s_high = s[np.where((w >= high_high))] \n \n w_fit = w[np.where((w > low_low) & (w < high_high))]\n w_fit_low = w[np.where((w > low_low) & (w < low_high))]\n w_fit_high = w[np.where((w > high_low) & (w < high_high))]\n\n y_fit = s[np.where((w > low_low) & (w < high_high))]\n y_fit_low = s[np.where((w > low_low) & (w < low_high))]\n y_fit_high = s[np.where((w > high_low) & (w < high_high))]\n\n # Remove outliers\n median_y_fit_low = np.nanmedian(y_fit_low)\n for i in range(len(y_fit_low)):\n if np.nanpercentile(y_fit_low,2) > y_fit_low[i] or y_fit_low[i] > np.nanpercentile(y_fit_low,98): y_fit_low[i] =median_y_fit_low\n\n median_y_fit_high = np.nanmedian(y_fit_high)\n for i in range(len(y_fit_high)):\n if np.nanpercentile(y_fit_high,2) > y_fit_high[i] or y_fit_high[i] > np.nanpercentile(y_fit_high,98): y_fit_high[i] =median_y_fit_high\n \n w_fit_cont = np.concatenate((w_fit_low,w_fit_high))\n y_fit_cont = np.concatenate((y_fit_low,y_fit_high))\n \n try:\n fit = np.polyfit(w_fit_cont,y_fit_cont, fit_degree)\n yfit = np.poly1d(fit)\n y_fitted = yfit(w_fit)\n \n y_fitted_low = yfit(w_fit_low)\n median_low = np.nanmedian(y_fit_low-y_fitted_low)\n rms=[]\n for i in range(len(y_fit_low)):\n rms.append(y_fit_low[i]-y_fitted_low[i]-median_low)\n \n # rms=y_fit-y_fitted\n lowlimit=np.nanpercentile(rms,pmin)\n highlimit=np.nanpercentile(rms,pmax)\n \n corrected_s_ =copy.deepcopy(y_fit)\n for i in range(len(w_fit)):\n if w_fit[i] >= low_high and w_fit[i] <= high_low: # ONLY CORRECT in [low_high,high_low] \n if only_correct_negative_values:\n if y_fit[i] <= 0 : \n corrected_s_[i] = y_fitted[i]\n else:\n if y_fit[i]-y_fitted[i] <= lowlimit or y_fit[i]-y_fitted[i] >= highlimit: corrected_s_[i] = y_fitted[i]\n \n \n corrected_s = np.concatenate((s_low,corrected_s_))\n corrected_s = np.concatenate((corrected_s,s_high))\n \n \n if plot:\n ptitle = \"CorrectionBase in range \"+np.str(np.round(low_low,2))+\" - [ \"+np.str(np.round(low_high,2))+\" - \"+np.str(np.round(high_low,2))+\" ] - \"+np.str(np.round(high_high,2))\n plot_plot(w_fit,[y_fit,y_fitted,y_fitted-highlimit,y_fitted-lowlimit,corrected_s_], color=[\"r\",\"b\", \"black\",\"black\",\"green\"], alpha=[0.3,0.7,0.2,0.2,0.5],xmin=low_low-40, xmax=high_high+40,vlines=[low_low,low_high,high_low,high_high],ptitle=ptitle, ylabel=\"Normalized flux\") \n #plot_plot(w,[s,corrected_s],xmin=low_low-40, xmax=high_high+40,vlines=[low_low,low_high,high_low,high_high])\n except Exception:\n if warnings: print(\" Fitting the continuum failed! Nothing done.\")\n corrected_s = s\n\n return corrected_s","def three_stable_points(rational_function, invariant_list):\n # define ground field and ambient function field\n if rational_function.parent().is_field():\n K = rational_function.parent()\n R = K.ring()\n else:\n R = rational_function.parent()\n K = R.fraction_field()\n\n z = R.gen(0)\n phi = K(rational_function)\n\n T = invariant_list\n\n automorphisms = []\n for t in permutations(range(len(T)),3):\n a = (T[0][0]*T[1][1]*T[2][1]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] -\n T[0][0]*T[1][1]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] +\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] +\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0])\n\n b = (T[0][0]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\n T[0][0]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] -\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][0] *T[t[2]][1] +\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] +\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] -\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0])\n\n c = (T[0][0]*T[1][1]*T[2][1]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\n T[0][0]*T[1][1]*T[2][1]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] -\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] +\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] +\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] -\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][1])\n\n d = (T[0][0]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] -\n T[0][0]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] +\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] +\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0])\n\n if a*d - b*c != 0:\n s = K(a*z + b) / K(c*z + d)\n if s(phi(z)) == phi(s(z)) and s not in automorphisms:\n automorphisms.append(s)\n return automorphisms","def linesearch(f, x0, J0, g0, a, amax, mu1, mu2, p):\r\n J, g, a = bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p)\r\n x = x0+a*p\r\n return x, J, g, a","def interval(self, alpha: float = 0.32, printlevel: int = 1) -> dict[str, float]:\n\n bands = {}\n poinull = self.poinull\n observed = self.calculator.bestfit.params[poinull.parameter][\"value\"]\n bands[\"observed\"] = observed\n\n if min(self.pvalues()) > alpha:\n msg = f\"The minimum of the scanned p-values is {min(self.pvalues())} which is larger than the\"\n msg += f\" confidence level alpha = {alpha}. Try to increase the range of POI values.\"\n raise POIRangeError(msg)\n\n tck = interpolate.splrep(poinull.values, self.pvalues() - alpha, s=0)\n roots = np.array(interpolate.sproot(tck))\n\n msg = f\" bound on the POI `{poinull.name}` cannot not be interpolated.\"\n\n if roots.size > 2:\n msg_warn = \"Multiple roots have been founds.\"\n if isinstance(self.calculator, FrequentistCalculator):\n msg_warn += \" Try to increase the number of toys, 'ntoysnull', to reduce fluctuations.\"\n warnings.warn(msg_warn)\n\n lower_roots = roots[roots < observed]\n upper_roots = roots[roots > observed]\n\n if upper_roots.size == 0:\n msg = \"Upper\" + msg + \" Try to increase the maximum POI value.\"\n raise POIRangeError(msg)\n else:\n bands[\"upper\"] = max(upper_roots)\n\n if lower_roots.size == 0:\n if self.qtilde:\n bands[\"lower\"] = 0.0\n else:\n msg = \"Low\" + msg + \" Try to decrease the minimum POI value.\"\n raise POIRangeError(msg)\n else:\n bands[\"lower\"] = min(lower_roots)\n\n if self.qtilde and bands[\"lower\"] < 0.0:\n bands[\"lower\"] = 0.0\n\n if printlevel > 0:\n msg = f\"\\nConfidence interval on {poinull.name}:\\n\"\n msg += f\"\\t{bands['lower']} < {poinull.name} < {bands['upper']} at {(1 - alpha) * 100:.1f}% C.L.\"\n print(msg)\n\n return bands","def I_bisection(self,a,b,tol,itr):\n \n ibs=[]\n iterations=0\n ibs_x=[]\n while iterations < itr:\n \n if (a+b)/2 > tol:\n a=a\n b=(a+b)/2\n ibs_x.append(b)\n #print(\"Upper Bound = \",b)\n \n \n elif (a+b)/2 < tol :\n a=(a+b)/2\n b=b\n #print(\"Lowe Bound =\",a)\n ibs_x.append(a)\n \n \n elif (a+b)/2 == tol:\n ibs_x.append((a+b)/2)\n #print(\" Sol =\" , (a+b)/2)\n iterations=iterations+1\n \n \n #print(\"IBS =\",self.Func((a+b)/2),\" iter=\",iterations) \n ibs.append(ibs_x)\n ibs.append((a+b)/2)\n ibs.append(iterations)\n \n return ibs","def computeBound(A, omega, Q, omega2, Q2, k):\n A = A.todense()\n M = Q2.T.dot(A).dot(Q2)\n R = A.dot(Q2) - Q2.dot(M)\n \n normR = numpy.linalg.norm(R) \n lmbda, U = numpy.linalg.eigh(M)\n L2 = omega[k:]\n\n delta = float(\"inf\")\n \n for i in lmbda: \n for j in L2: \n if abs(i-j) < delta: \n delta = abs(i-j) \n \n #print(lmbda, L2)\n print(\"normR=\" + str(normR), \"delta=\"+ str(delta), \"bound=\"+str(normR/delta))\n \n return normR/delta","def sf_bound(l0, l2, lmbdas, bidual, r, rank=False):\n\n xvals, bnd = [], []\n if l0 == \"constr\":\n offset = 2\n if rank == False:\n bnd_label = r\"$p^{\\ast \\ast}(k + r + 2)$\"\n else:\n bnd_label = r\"$p^{\\ast \\ast}(k + r + 2) - \\zeta_r$\"\n\n for l in lmbdas:\n # if l - r - offset > 0:\n # xvals.append(l)\n # bnd.append(bidual[l-r-offset])\n if l + r + offset < lmbdas[-1]:\n bnd.append(bidual[l + r + offset])\n else:\n bnd.append(bidual[-1])\n\n xvals = lmbdas\n\n elif l0 == \"pen\":\n offset = 1\n if rank == False:\n bnd_label = r\"$p^{\\ast \\ast}(\\lambda) + \\lambda(r + 1)$\"\n else:\n bnd_label = r\"$p^{\\ast \\ast}(\\lambda) + \\lambda(r + 1) + \\zeta$\"\n\n if rank == False:\n bnd = [bd + l * (r + offset) for bd, l in zip(bidual, lmbdas)]\n else:\n # this is very confusing, but the code is set up such that the 3rd\n # argument (lmbdas) is the one that varies, in this case we are\n # letting the rank vary from 1,m so we artifically let lmbdas\n # bet this and set r to be the value of l0 penalty\n\n bnd = [bd + r * (l + offset) for bd, l in zip(bidual, lmbdas)]\n\n xvals = lmbdas\n\n return xvals, bnd, bnd_label","def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\n ##\n if iszero ( C ) :\n return findroot ( fun , xmin , xmax , args = args )\n ##\n func = lambda x , *a : fun(x,*a)-C\n return findroot ( func , xmin , xmax , args = args )","def find_optimal_strategy(prices, max_position=3, cost_per_trade=0.02):\n buy_price = np.maximum(prices.bid_price, prices.ask_price).values\n sell_price = np.minimum(prices.bid_price, prices.ask_price).values\n\n account = np.full((prices.shape[0] + 1, 2 * max_position + 3), -np.inf)\n account[0, max_position + 1] = 0\n\n actions = np.empty((prices.shape[0], 2 * max_position + 3), dtype=int)\n\n for i in range(prices.shape[0]):\n for j in range(1, account.shape[1] - 1):\n buy = account[i, j - 1] - cost_per_trade - buy_price[i]\n sell = account[i, j + 1] - cost_per_trade + sell_price[i]\n hold = account[i, j]\n if buy > sell and buy > hold:\n account[i + 1, j] = buy\n actions[i, j] = 1\n elif sell > buy and sell > hold:\n account[i + 1, j] = sell\n actions[i, j] = -1\n else:\n account[i + 1, j] = hold\n actions[i, j] = 0\n\n pnl = account[-1, 1:-1] + (np.arange(-max_position, max_position + 1) *\n prices.market_price.iloc[-1])\n j = np.argmax(pnl) + 1\n optimal_sequence = []\n for i in reversed(range(actions.shape[0])):\n optimal_sequence.append(actions[i, j])\n j -= actions[i, j]\n optimal_sequence = np.array(list(reversed(optimal_sequence)))\n\n return optimal_sequence, np.max(pnl) / optimal_sequence.size","def test_curve_apply():\n c = Curve(data=data_num)\n c2 = c.apply(window_length=3)\n c3 = c.apply(window_length=3, func1d=np.min)\n\n assert c2.df.iloc[0][0] - 4.491228070175438 < 0.0001\n assert c3.df.iloc[0][0] - 1 < 0.0001","def the_function(interval):\n if math.ceil(interval.upper) % 2:\n return interval * type(interval).closed(\n fractions.Fraction(3, 2),\n fractions.Fraction(3, 2)\n )\n else:\n return interval * type(interval).closed(\n fractions.Fraction(1, 2),\n fractions.Fraction(1, 2)\n )","def overlap_coefficient(input_adj):\n adj = input_adj.copy()\n d = np.diagonal(adj)\n deg_dict = dict(zip(adj.columns, d))\n \n edges = get_upper_edges(adj, sorted=False)\n df = pd.DataFrame(edges, columns=['weight'])\n df['deg_A'] = df.index.map(lambda x: deg_dict[x[0]])\n df['deg_B'] = df.index.map(lambda x: deg_dict[x[1]])\n df['min_deg'] = df[['deg_A','deg_B']].min(axis=1)\n df['oc'] = df['weight']/df['min_deg']\n\n return df","def bracket(iterable, origin, interval_size, already_sorted=False, intervals_right_closed=False, coalesce=False):\r\n if not already_sorted:\r\n sorted_indices, iterable = zip(*sorted([(i, v) for i, v in enumerate(iterable)], key=operator.itemgetter(1)))\r\n \r\n brackets = []\r\n bracket_indices = []\r\n \r\n interval_offset = None\r\n interval_left = None\r\n interval_right = None\r\n \r\n for x in iterable:\r\n if interval_offset is None or x - interval_left >= interval_size:\r\n new_interval_offset = (x - origin) // interval_size\r\n new_interval_left = origin + new_interval_offset * interval_size\r\n \r\n if intervals_right_closed and x == new_interval_left:\r\n new_interval_offset -= 1\r\n new_interval_left -= interval_size\r\n \r\n if coalesce and (interval_offset is not None) and (new_interval_left <= brackets[-1].interval.right):\r\n interval_right = new_interval_left + interval_size\r\n brackets[-1].interval = brackets[-1].interval.replace_right(interval_right)\r\n elif interval_offset is None or new_interval_offset != interval_offset:\r\n interval_offset = new_interval_offset\r\n interval_left = new_interval_left\r\n interval_right = interval_left + interval_size\r\n brackets.append(\r\n Bracket(thalesians.tsa.intervals.Interval(interval_left,\r\n interval_right,\r\n not intervals_right_closed,\r\n intervals_right_closed),\r\n interval_offset))\r\n \r\n bracket_indices.append(len(brackets) - 1)\r\n \r\n if not already_sorted:\r\n new_bracket_indices = [None] * len(bracket_indices)\r\n for i in range(len(bracket_indices)):\r\n new_bracket_indices[sorted_indices[i]] = bracket_indices[i]\r\n bracket_indices = new_bracket_indices\r\n \r\n return brackets, bracket_indices","def bisect(\n f: Callable,\n a: Array,\n b: Array,\n args: Tuple = (),\n xtol: float = 1e-7,\n ftol: float = 1e-7,\n maxiter: int = 100,\n full_output: bool = False,\n range_check: bool = True,\n) -> Union[Array, dict]:\n\n fa = f(*((a,) + args))\n fb = f(*((b,) + args))\n if range_check and snp.any(snp.sign(fa) == snp.sign(fb)):\n raise ValueError(\"Initial bisection range does not bracket zero.\")\n\n for numiter in range(maxiter):\n c = (a + b) / 2.0\n fc = f(*((c,) + args))\n fcs = snp.sign(fc)\n a = snp.where(snp.logical_or(snp.sign(fa) * fcs == 1, fc == 0.0), c, a)\n b = snp.where(snp.logical_or(fcs * snp.sign(fb) == 1, fc == 0.0), c, b)\n fa = f(*((a,) + args))\n fb = f(*((b,) + args))\n xerr = snp.max(snp.abs(b - a))\n ferr = snp.max(snp.abs(fc))\n if xerr <= xtol and ferr <= ftol:\n break\n\n idx = snp.argmin(snp.stack((snp.abs(fa), snp.abs(fb))), axis=0)\n x = snp.choose(idx, (a, b))\n if full_output:\n r = x, {\"iter\": numiter, \"xerr\": xerr, \"ferr\": ferr, \"a\": a, \"b\": b}\n else:\n r = x\n return r","def selecting_a_representative_for_an_interval(begin, end, the_set):\n save_tuple = None\n the_min = float('inf')\n for t in the_set:\n if begin <= t[0] <= end:\n if t[1] < the_min:\n save_tuple = t\n the_min = t[1]\n\n return save_tuple","def eval_strategy_range(make_strategy, lower_bound, upper_bound):\r\n best_value, best_win_rate = 0, 0\r\n value = lower_bound\r\n while value <= upper_bound:\r\n strategy = make_strategy(value)\r\n win_rate = compare_strategies(strategy)\r\n print('Win rate against the baseline using', value, 'value:', win_rate)\r\n if win_rate > best_win_rate:\r\n best_win_rate, best_value = win_rate, value\r\n value += 1\r\n return best_value","def find_instruments_in_range(self, df, strategy_range, posi):\n sub = df[(df.strike >= min(strategy_range)) & (df.strike <= max(strategy_range))]#.head(self.allowed_position_size)\n if 'call' in posi:\n return sub[(sub.strike == min(sub.strike))]\n else:\n return sub[(sub.strike == max(sub.strike))]","def alice(\n partner1_salary_compound_rate: float,\n partner1_salary_plateau: float,\n partner2_salary_compound_rate: float,\n partner2_salary_plateau: float,\n base_spending: float,\n spending_luxury_compound_rate: float,\n rrsp_interest_rate: float,\n tfsa_interest_rate: float,\n):\n\n ruleset_func = ruleset.get_couple_ruleset(\n salary_rules.get_compound_plateau(\n partner1_salary_compound_rate, partner1_salary_plateau\n ),\n salary_rules.get_compound_plateau(\n partner2_salary_compound_rate, partner2_salary_plateau\n ),\n couple_spending_rules.get_luxury_over_basic(\n base_spending, spending_luxury_compound_rate\n ),\n couple_savings_rules.get_equalizing_rrsp_only_split(),\n rrsp_interest_rate,\n tfsa_interest_rate,\n )\n\n return ruleset_func","def _findBucket(self, node):\n for bucket in buckets:\n if bucket.inRange(node):\n return bucket\n #if bucket.low <= node and node <= bucket.high:\n # return bucket\n return None","def calcBRange(c,n=10):\n \n bMin = -abs(c)/2.0 \n bMax = abs(c)/2.0 \n return np.linspace(bMin,bMax,n)","def golden(func, args=(), brack=None, tol=1.e-4, full_output=0):\n\tif brack is None:\n\t\txa,xb,xc,fa,fb,fc,funcalls = bracket(func, args=args)\n\telif len(brack) == 2:\n\t\txa,xb,xc,fa,fb,fc,funcalls = bracket(func, xa=brack[0], xb=brack[1], args=args)\n\telif len(brack) == 3:\n\t\txa,xb,xc = brack\n\t\tif (xa > xc): # swap so xa < xc can be assumed\n\t\t\tdum = xa; xa=xc; xc=dum\n\t\tassert ((xa < xb) and (xb < xc)), \"Not a bracketing interval.\"\n\t\tfa = apply(func, (xa,)+args)\n\t\tfb = apply(func, (xb,)+args)\n\t\tfc = apply(func, (xc,)+args)\n\t\tassert ((fb<fa) and (fb < fc)), \"Not a bracketing interval.\"\n\t\tfuncalls = 3\n\telse:\n\t\traise ValueError, \"Bracketing interval must be length 2 or 3 sequence.\"\n\n\t_gR = 0.61803399\n\t_gC = 1.0-_gR\n\tx3 = xc\n\tx0 = xa\n\tif (abs(xc-xb) > abs(xb-xa)):\n\t\tx1 = xb\n\t\tx2 = xb + _gC*(xc-xb)\n\telse:\n\t\tx2 = xb\n\t\tx1 = xb - _gC*(xb-xa)\n\tf1 = apply(func, (x1,)+args)\n\tf2 = apply(func, (x2,)+args)\n\tfuncalls += 2\n\twhile (abs(x3-x0) > tol*(abs(x1)+abs(x2))):\n\t\tif (f2 < f1):\n\t\t\tx0 = x1; x1 = x2; x2 = _gR*x1 + _gC*x3\n\t\t\tf1 = f2; f2 = apply(func, (x2,)+args)\n\t\telse:\n\t\t\tx3 = x2; x2 = x1; x1 = _gR*x2 + _gC*x0\n\t\t\tf2 = f1; f1 = apply(func, (x1,)+args)\n\t\tfuncalls += 1\n\tif (f1 < f2):\n\t\txmin = x1\n\t\tfval = f1\n\telse:\n\t\txmin = x2\n\t\tfval = f2\n\tif full_output:\n\t\treturn xmin, fval, funcalls\n\telse:\n\t\treturn xmin","def find_combination(self, age, coef):\n\n # easy exit:\n if (age < self.models[0].glb[iage]): return None\n if (age > self.models[-1].glb[iage]): return None\n\n istart = 0\n istop = len(self.models)-1\n while (istop > istart+1):\n itemp = (istop+istart)//2\n if (age < self.models[itemp].glb[iage]):\n istop = itemp\n else:\n istart = itemp\n mu = (age - self.models[istart].glb[iage]) \\\n / (self.models[istop].glb[iage] - self.models[istart].glb[iage])\n return ((coef*(1.0-mu), self.models[istart].name), (coef*mu, self.models[istop].name))","def find_B(self):\n max_lb = 0\n for arc in self.arcs():\n lb = self.arc_info[arc[0]]['lower_bound']\n max_lb = max(max_lb, lb)\n n = len(self)\n m = len(list(self.edges()))\n return((m - n + 2)*max_lb)","def make_initial_conditions(system, displacement, low):\n C = sir.CurveSegment(system.sbar, system.imax, 0, system, 1)\n C.s = C.s + displacement\n s_inter, i_inter = C._curve_sol(low)\n C = sir.CurveSegment(system.sbar, system.imax, 0, system, s_inter)\n C.s = C.s + displacement\n s0 = np.linspace(C.s[-1], 1)\n i0 = np.array([i_inter]*len(s0))\n s0 = np.concatenate((C.s, s0))\n i0 = np.concatenate((C.i, i0))\n return s0, i0","def bucket_boundaries(self, bucket):\n\n if bucket < 0 or bucket >= self.total_buckets:\n raise IndexError('bucket %d out of range' % bucket)\n if bucket == self.total_buckets - 1:\n return (self._lower_bounds[bucket], float('Inf'))\n return (self._lower_bounds[bucket], self._lower_bounds[bucket + 1])","def find_ab_params(spread, min_dist):\n\n def curve(x, a, b):\n return 1.0 / (1.0 + a * x ** (2 * b))\n\n xv = np.linspace(0, spread * 3, 300)\n yv = np.zeros(xv.shape)\n yv[xv < min_dist] = 1.0\n yv[xv >= min_dist] = np.exp(\n -(xv[xv >= min_dist] - min_dist) / spread)\n params, covar = curve_fit(curve, xv, yv)\n return params[0], params[1]","def lp_acent(A,b,c,x_0):\n #Parameters\n b = b.flatten()\n c = c.flatten()\n ALPHA = 0.01\n BETA = 0.5\n EPSILON = 1e-6\n MAXITERS = 100\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\n print 'failed' \n return 0\n #m = len(b)\n #n = len(x_0)\n lambda_hist = []\n x = x_0\n for iter in range(MAXITERS):\n # H = np.diag(1/np.power(x,3))\n g = c-np.power(x,-1)\n #print g.shape\n #solving KKT system\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\n lambda_hist.append(lambdasqr/2)\n if lambdasqr/2 <= EPSILON:\n break\n # backtracking line search\n t = 1\n # brin the point inside the domain\n while np.min(x+t*dx)<=0:\n t =BETA*t\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\n t = BETA*t\n x = x+t*dx\n if iter == MAXITERS:\n print 'ERROR: MAXITERS reached'\n else:\n #plt.figure()\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\n return x,w,lambda_hist","def calcrange(a4lim,data):\r\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\r\n return a4range","def bisection(leaf, args):\n #retrieve the lower/upper bound of given Most Promising Region\n lb = leaf.lb\n ub = leaf.ub\n #find the dimension number of decision variabless\n dimX = len(lb)\n #determine the dimension that should be partitioned\n dimID = (leaf.level + 1) % dimX \n #determine the partition threshold\n thr = (lb[dimID]+ub[dimID])/2.0\n #create new lower/upper middle bound [lb,umb], [lmd,ub]\n lmb,umb = [np.array([]) for i in range(2)]\n for i in range(dimX):\n lmb = np.append(lmb,[lb[i],thr][i==dimID])\n umb = np.append(umb,[ub[i],thr][i==dimID])\n subRegions = [[lb,umb],[lmb,ub]]\n return {'parent':leaf,'thr':thr,'subRegions':subRegions}","def basis_function(t, i, knots):\n t_this = knots[i]\n t_next = knots[i+1]\n out = 1. if (t>=t_this and t<t_next) else 0.\n return out","def get_available_age_brackets_and_mapping():\n brackets_dic = {}\n dict_of_age_by_brackets = {}\n\n for num_agebrackets in [85, 18, 15, 12]:\n brackets = []\n if num_agebrackets == 85:\n for i in range(84):\n brackets.append([i])\n brackets.append(np.arange(84, 101))\n # # num_agebracket = 20 only works if you have an age distribution and\n # # matrices that go in more detail than age 84+, so if you wanted\n # # brackets of 85-89, 90-94, 95-100+, etc. it would be hard unless\n # # you have those matrices (which we don't because of the European\n # # matrices)\n\n # if num_agebrackets == 20:\n # for i in range(19):\n # brackets.append(np.arange(5 * i, 5 * (i + 1)))\n # brackets.append(np.arange(95, 101))\n if num_agebrackets == 18:\n for i in range(16):\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\n brackets.append(np.arange(80, 84))\n brackets.append(np.arange(84, 101))\n if num_agebrackets == 15:\n for i in range(14):\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\n brackets.append(np.arange(70, 101))\n if num_agebrackets == 12:\n for i in range(11):\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\n brackets.append(np.arange(55, 101))\n\n age_by_brackets_dic = dict.fromkeys(np.arange(101), 0)\n for n, b in enumerate(brackets):\n for a in b:\n age_by_brackets_dic[a] = n\n\n brackets_dic[num_agebrackets] = brackets\n dict_of_age_by_brackets[num_agebrackets] = age_by_brackets_dic\n\n return brackets_dic, dict_of_age_by_brackets","def _intersect(self, interval):\n first = self.intervals.bisect_left(interval)\n last = first\n while first > 0 and \\\n self.intervals[first - 1].upper > interval.lower:\n first -= 1\n while last < len(self.intervals) and \\\n self.intervals[last].lower < interval.upper:\n last += 1\n return first, last","def CI(x, alpha=0.05):\n x = np.asarray(x)\n xs = x.size\n s = np.argsort(x)\n c = int((alpha / 2) * xs)\n return Interval(x[s[c-1]], x[s[xs-c]])","def ofi(b, b_v, a, a_v):\n b_, b_v_, a_, a_v_ = b.shift(1), b_v.shift(1), a.shift(1), a_v.shift(1)\n ofi = i(b >= b_) * b_v - i(b <= b_) * b_v_ - i(a <= a_) * a_v + i(a >= a_) * a_v_\n return ofi.fillna(0)","def bucket_intervals(alpha, bucket_sizes, sigma):\n heads = array(\"l\", [0] * sigma)\n tails = array(\"l\", [0] * sigma)\n j = 0\n for i in range(len(alpha)):\n heads[alpha[i]] = j\n j += bucket_sizes[alpha[i]]\n tails[alpha[i]] = j - 1\n\n # print_buckets(heads)\n # print_buckets(tails)\n return heads, tails","def entry_condition(self, wage):\n \n #a. solve incumbant firm problem\n pol_k, pol_n, pi, W = self.incumbant_firm(wage) \n \n # b. enter/stay in the market policy function\n pol_enter=np.zeros((self.Ns,self.ntau)) #1 to enter/stay\n \n for i_s in range(self.Ns):\n for j_t in range(self.ntau):\n if W[i_s,j_t]>=0:\n pol_enter[i_s,j_t]=1\n \n # c. present discounted value of a potential entrant\n W_e = np.sum(np.sum( W * self.joint_pdf * pol_enter, axis=0) ) - self.ce\n \n return W_e, pol_k, pol_n, pi, W, pol_enter","def f3_ab_b(self,a,b,c):\n ans = (7.*(a*a - a*b*c) + (a*a/b)*(a*c - b))*self.g2(a,b,-c)/(a*a + b*b - 2.*a*b*c)\n #print 'b_b:',ans,\n return ans","def budget(df, df_hist, harmonize_year=\"2015\"):\n\n harmonize_year = int(harmonize_year)\n\n df = df.set_axis(df.columns.astype(int), axis=\"columns\")\n df_hist = df_hist.set_axis(df_hist.columns.astype(int), axis=\"columns\")\n\n data_years = df.columns\n hist_years = df_hist.columns\n\n years = data_years[data_years >= harmonize_year]\n\n if data_years[0] not in hist_years:\n hist_years = hist_years.insert(bisect(hist_years, data_years[0]), data_years[0])\n df_hist = df_hist.reindex(columns=hist_years).interpolate(\n method=\"slinear\", axis=1\n )\n\n def carbon_budget(years, emissions):\n # trapezoid rule\n dyears = np.diff(years)\n demissions = np.diff(emissions)\n\n budget = (dyears * (np.asarray(emissions)[:-1] + demissions / 2)).sum()\n return budget\n\n solver = pyo.SolverFactory(\"ipopt\")\n if solver.executable() is None:\n raise RuntimeError(\n \"No executable for the solver 'ipopt' found \"\n \"(necessary for the budget harmonization). \"\n \"Install from conda-forge or add to PATH.\"\n )\n\n harmonized = []\n\n for region in df.index:\n model = pyo.ConcreteModel()\n\n \"\"\"\n PARAMETERS\n \"\"\"\n data_vals = df.loc[region, years]\n hist_val = df_hist.loc[region, harmonize_year]\n\n budget_val = carbon_budget(data_years, df.loc[region, :])\n\n if data_years[0] < harmonize_year:\n hist_in_overlap = df_hist.loc[region, data_years[0] : harmonize_year]\n budget_val -= carbon_budget(hist_in_overlap.index, hist_in_overlap)\n\n \"\"\"\n VARIABLES\n \"\"\"\n model.x = pyo.Var(years, initialize=0, domain=pyo.Reals)\n x = np.array(\n [model.x[y] for y in years]\n ) # keeps pyomo VarData objects, ie. modelling vars not numbers\n\n \"\"\"\n OBJECTIVE FUNCTION\n \"\"\"\n delta_years = np.diff(years)\n delta_x = np.diff(x)\n delta_m = np.diff(data_vals)\n\n def l2_norm():\n return pyo.quicksum((delta_m / delta_years - delta_x / delta_years) ** 2)\n\n model.obj = pyo.Objective(expr=l2_norm(), sense=pyo.minimize)\n\n \"\"\"\n CONSTRAINTS\n \"\"\"\n model.hist_val = pyo.Constraint(expr=model.x[harmonize_year] == hist_val)\n\n model.budget = pyo.Constraint(expr=carbon_budget(years, x) == budget_val)\n\n \"\"\"\n RUN\n \"\"\"\n results = solver.solve(model)\n\n assert (results.solver.status == pyo.SolverStatus.ok) and (\n results.solver.termination_condition == pyo.TerminationCondition.optimal\n ), (\n f\"ipopt terminated budget optimization with status: \"\n f\"{results.solver.status}, {results.solver.termination_condition}\"\n )\n\n harmonized.append([pyo.value(model.x[y]) for y in years])\n\n df_harm = pd.DataFrame(\n harmonized,\n index=df.index,\n columns=years.astype(str),\n )\n\n return df_harm","def get_boundaries(outputs: list, inv_choices: str) -> list:\n process_output = []\n\n def process_partition(partition):\n boundaries = set()\n if '-' in partition:\n p = list(map(int, partition.split('-')))\n boundaries.update({p[0] - 1, p[0], p[0] + 1, p[1] - 1, p[1], p[1] + 1})\n\n sort_bounds = sorted(boundaries)\n inv_min_bound = [sort_bounds.pop(0), inv_choices]\n inv_max_bound = [sort_bounds.pop(), inv_choices]\n # Since it is sorted and starting from the lowest, only the lowest value need to be checked.\n if not any(inv_min_bound[0] in sublist for sublist in process_output):\n process_output.extend([inv_min_bound, inv_max_bound])\n # Check if overlapping and if it is, check the answer (last item) and replace it if had the invalid choice.\n for i in sort_bounds:\n if any(i in sublist for sublist in process_output):\n ind = get_index(process_output, i)\n ans = process_output[ind][-1]\n if ans == inv_choices:\n process_output.pop(ind)\n\n process_output.append([i, output_answer])\n\n for part in outputs:\n output_answer = part.pop()\n if len(part) == 1 and isinstance(part, list):\n\n part = ''.join([p for p in part if isinstance(p, str)])\n process_partition(part)\n else:\n logger.critical('LIMITATION: Not able to process more than 1 BVA variable per function!')\n break\n return process_output","def first_order_conditions(geom: geometry.Geometry,\n a: jnp.ndarray,\n b: jnp.ndarray,\n fg: jnp.ndarray):\n grad_a, grad_b = grad_of_marginal_fit(\n a, b, fg[:n], fg[n:], tau_a, tau_b, geom)\n return jnp.concatenate((\n jnp.where(a > 0,\n marginal_a(geom, fg[:n], fg[n:]) - grad_a,\n 0.0),\n jnp.where(b > 0,\n marginal_b(geom, fg[:n], fg[n:]) - grad_b,\n 0.0)\n ))","def B(n, k):\n assert 0 < k <= n\n global lookup\n for index_y in range(len(lookup), n + 1):\n lookup.append([1])\n min_value = min(index_y, k)\n for index_x in range(min_value):\n if index_x < len(lookup[index_y - 1]) - 1:\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\n else:\n lookup[index_y].append(lookup[index_y - 1][index_x])\n return lookup[n][k]","def uniform_search(fun, a, b, E, n=3, counter=0):\n if b - a < E:\n return (b + a) / 2, counter\n step = (b - a) / n\n xn = a + step\n min_x = a\n min_f = fun(a)\n while xn <= b:\n counter += 1\n f = fun(xn)\n if f < min_f:\n min_x = xn\n min_f = f\n xn += step\n counter += 2\n if fun(min_x - step) < fun(min_x + step):\n return uniform_search(fun, min_x - step, min_x, E, n, counter)\n return uniform_search(fun, min_x, min_x + step, E, n, counter)","def compute_bounds(self, x=None, aux=None, C=None, method='backward', IBP=False, forward=False, \n bound_lower=True, bound_upper=True, reuse_ibp=False,\n return_A=False, needed_A_list=None, final_node_name=None, average_A=False, new_interval=None,\n return_b=False, b_dict=None, reference_bounds=None, intermediate_constr=None, alpha_idx=None):\n\n # Several shortcuts.\n method = method.lower() if method is not None else method\n if method == 'ibp':\n # Pure IBP bounds.\n method = None\n IBP = True\n elif method == 'ibp+backward' or method == 'ibp+crown' or method == 'crown-ibp':\n method = 'backward'\n IBP = True\n elif method == 'crown':\n method = 'backward'\n elif method == 'forward':\n forward = True\n elif method == 'forward+backward':\n method = 'backward'\n forward = True\n elif method == \"crown-optimized\" or method == 'alpha-crown':\n if bound_lower:\n ret1 = self.get_optimized_bounds(x=x, IBP=False, C=C, method='backward', new_interval=new_interval, reference_bounds=reference_bounds,\n bound_lower=bound_lower, bound_upper=False, return_A=return_A)\n if bound_upper:\n ret2 = self.get_optimized_bounds(x=x, IBP=False, C=C, method='backward', new_interval=new_interval, reference_bounds=reference_bounds,\n bound_lower=False, bound_upper=bound_upper, return_A=return_A)\n if bound_upper and bound_upper:\n assert return_A is False\n return ret1[0], ret2[1]\n elif bound_lower:\n return ret1\n elif bound_upper:\n return ret2\n else:\n raise NotImplementedError\n\n # If y in self.backward_node_pairs[x], then node y is visited when \n # doing backward bound propagation starting from node x.\n self.backward_from = dict([(node, []) for node in self._modules])\n\n if not bound_lower and not bound_upper:\n raise ValueError('At least one of bound_lower and bound_upper in compute_bounds should be True')\n A_dict = {} if return_A else None\n\n if x is not None:\n self._set_input(*x, new_interval=new_interval)\n\n if IBP and method is None and reuse_ibp:\n # directly return the previously saved ibp bounds\n return self.ibp_lower, self.ibp_upper\n root = [self._modules[name] for name in self.root_name]\n batch_size = root[0].value.shape[0]\n dim_in = 0\n\n for i in range(len(root)):\n value = root[i].forward()\n if hasattr(root[i], 'perturbation') and root[i].perturbation is not None: \n root[i].linear, root[i].center, root[i].aux = \\\n root[i].perturbation.init(value, aux=aux, forward=forward)\n # This input/parameter has perturbation. Create an interval object.\n if self.ibp_relative:\n root[i].interval = Interval(\n None, None, \n root[i].linear.nominal, root[i].linear.lower_offset, root[i].linear.upper_offset)\n else:\n root[i].interval = \\\n Interval(root[i].linear.lower, root[i].linear.upper, ptb=root[i].perturbation)\n if forward:\n root[i].dim = root[i].linear.lw.shape[1]\n dim_in += root[i].dim\n else:\n if self.ibp_relative:\n root[i].interval = Interval(\n None, None, \n value, torch.zeros_like(value), torch.zeros_like(value)) \n else:\n # This inpute/parameter does not has perturbation. \n # Use plain tuple defaulting to Linf perturbation.\n root[i].interval = (value, value)\n root[i].forward_value = root[i].forward_value = root[i].value = root[i].lower = root[i].upper = value\n\n if self.ibp_relative:\n root[i].lower = root[i].interval.lower\n root[i].upper = root[i].interval.upper\n else:\n root[i].lower, root[i].upper = root[i].interval\n\n if forward:\n self._init_forward(root, dim_in)\n\n final = self._modules[self.final_name] if final_node_name is None else self._modules[final_node_name]\n logger.debug('Final node {}[{}]'.format(final, final.name))\n\n if IBP:\n res = self._IBP_general(node=final, C=C)\n if self.ibp_relative:\n self.ibp_lower, self.ibp_upper = res.lower, res.upper\n else:\n self.ibp_lower, self.ibp_upper = res\n\n if method is None:\n return self.ibp_lower, self.ibp_upper \n\n if C is None:\n # C is an identity matrix by default \n if final.output_shape is None:\n raise ValueError('C is not provided while node {} has no default shape'.format(final.shape))\n dim_output = int(np.prod(final.output_shape[1:]))\n C = torch.eye(dim_output, device=self.device).unsqueeze(0).repeat(batch_size, 1, 1) # TODO: use an eyeC object here.\n\n # check whether weights are perturbed and set nonlinear for the BoundMatMul operation\n for n in self._modules.values():\n if isinstance(n, (BoundLinear, BoundConv, BoundBatchNormalization)):\n n.nonlinear = False\n for l_name in n.input_name[1:]:\n node = self._modules[l_name]\n if hasattr(node, 'perturbation'):\n if node.perturbation is not None:\n n.nonlinear = True\n\n # BFS to find out whether each node is used given the current final node\n if final != self.last_final_node:\n self.last_final_node = final\n for i in self._modules.values():\n i.used = False\n final.used = True\n queue = deque([final])\n while len(queue) > 0:\n n = queue.popleft()\n for n_pre_name in n.input_name:\n n_pre = self._modules[n_pre_name]\n if not n_pre.used:\n n_pre.used = True\n queue.append(n_pre)\n\n for i in self._modules.values(): # for all nodes\n if not i.used:\n continue\n if hasattr(i, 'nonlinear') and i.nonlinear:\n for l_name in i.input_name:\n node = self._modules[l_name]\n # print('node', node, 'lower', hasattr(node, 'lower'), 'perturbed', node.perturbed, 'forward_value', hasattr(node, 'forward_value'), 'from_input', node.from_input)\n if not hasattr(node, 'lower'):\n assert not IBP, 'There should be no missing intermediate bounds when IBP is enabled'\n if not node.perturbed and hasattr(node, 'forward_value'):\n node.interval = node.lower, node.upper = \\\n node.forward_value, node.forward_value\n continue\n # FIXME check that weight perturbation is not affected\n # (from_input=True should be set for weights)\n if not node.from_input and hasattr(node, 'forward_value'):\n node.lower = node.upper = node.forward_value\n continue\n if forward:\n l, u = self._forward_general(\n node=node, root=root, dim_in=dim_in, concretize=True)\n else:\n # assign concretized bound for ReLU layer to save computational cost\n # FIXME: Put ReLU after reshape will cause problem!\n if (isinstance(node, BoundActivation) or isinstance(node, BoundTranspose)) and hasattr(\n self._modules[node.input_name[0]], 'lower'):\n node.lower = node.forward(self._modules[node.input_name[0]].lower)\n node.upper = node.forward(self._modules[node.input_name[0]].upper)\n elif isinstance(node, BoundReshape) and \\\n hasattr(self._modules[node.input_name[0]], 'lower') and \\\n hasattr(self._modules[node.input_name[1]], 'value'):\n # Node for input value.\n val_input = self._modules[node.input_name[0]]\n # Node for input parameter (e.g., shape, permute)\n arg_input = self._modules[node.input_name[1]]\n node.lower = node.forward(val_input.lower, arg_input.value)\n node.upper = node.forward(val_input.upper, arg_input.value)\n else:\n first_layer_flag = False\n # This is the list of all intermediate layers where we need to refine.\n if intermediate_constr is not None:\n intermediate_beta_enabled_layers = [k for v in intermediate_constr.values() for k in v]\n else:\n intermediate_beta_enabled_layers = []\n # Here we avoid creating a big C matrix in the first linear layer.\n # Disable this optimization when we have beta for intermediate layer bounds.\n if type(node) == BoundLinear or type(node) == BoundConv and node.name not in intermediate_beta_enabled_layers:\n for l_pre in node.input_name:\n if type(self._modules[l_pre]) == BoundInput:\n node.lower, node.upper = self._IBP_general(node)\n first_layer_flag = True\n break\n if not first_layer_flag:\n reduced_dim = False # Only partial neurons (unstable neurons) are bounded.\n unstable_idx = None\n dim = int(np.prod(node.output_shape[1:]))\n # FIXME: C matrix shape incorrect for BoundParams.\n if (isinstance(node, BoundLinear) or isinstance(node, BoundMatMul)) and int(\n os.environ.get('AUTOLIRPA_USE_FULL_C', 0)) == 0:\n if intermediate_constr is not None and node.name in reference_bounds:\n # If we are doing bound refinement and reference bounds are given, we only refine unstable neurons.\n # For each batch element, we find the unstable neurons.\n unstable_masks = torch.logical_and(reference_bounds[node.name][0] < 0, reference_bounds[node.name][1] > 0)\n # unstable_masks = torch.ones(dtype=torch.bool, size=(batch_size, dim), device=self.device)\n # For simplicity, merge unstable locations for all elements in this batch. TODO: use individual unstable mask.\n unstable_locs = unstable_masks.sum(dim=0).bool()\n # This is a 1-d indices, shared by all elements in this batch.\n unstable_idx = unstable_locs.nonzero().squeeze()\n # Number of unstable neurons after merging.\n max_non_zero = unstable_locs.sum()\n # Create an abstract C matrix, the unstable_idx are the non-zero elements in specifications for all batches.\n newC = OneHotC([batch_size, max_non_zero, *node.output_shape[1:]], self.device, unstable_idx, None)\n reduced_dim = True\n # print(f'layer {node.name} total {dim} unstable {max_non_zero} newC {newC.shape}')\n \"\"\"\n newC = torch.eye(dim, device=self.device) \\\n .unsqueeze(0).repeat(batch_size, 1, 1) \\\n .view(batch_size, dim, *node.output_shape[1:])\n print(f'creating new C {newC.size()}')\n if int(os.environ.get('USE_EYE_C', 0)) == 1:\n newC = eyeC([batch_size, dim, *node.output_shape[1:]], self.device)\n \"\"\"\n else:\n newC = eyeC([batch_size, dim, *node.output_shape[1:]], self.device)\n elif (isinstance(node, BoundConv) or isinstance(node,\n BoundBatchNormalization)) and node.mode == \"patches\":\n # import pdb; pdb.set_trace()\n # Here we create an Identity Patches object \n newC = Patches(None, 1, 0,\n [batch_size, node.output_shape[-2] * node.output_shape[-1],\n node.output_shape[-3], node.output_shape[-3], 1, 1], 1)\n elif isinstance(node, BoundAdd) and node.mode == \"patches\":\n num_channel = node.output_shape[-3]\n L = node.output_shape[-2] * node.output_shape[-1]\n patches = (torch.eye(num_channel, device=self.device)).unsqueeze(0).unsqueeze(\n 0).unsqueeze(4).unsqueeze(5).expand(batch_size, L, num_channel, num_channel, 1, 1) # now [1 * 1 * in_C * in_C * 1 * 1]\n newC = Patches(patches, 1, 0, [batch_size] + list(patches.shape[1:]))\n else:\n if intermediate_constr is not None and node.name in reference_bounds:\n # If we are doing bound refinement and reference bounds are given, we only refine unstable neurons.\n # For each batch element, we find the unstable neurons.\n unstable_masks = torch.logical_and(reference_bounds[node.name][0] < 0, reference_bounds[node.name][1] > 0)\n # Flatten the conv layer shape.\n unstable_masks = unstable_masks.view(unstable_masks.size(0), -1)\n # unstable_masks = torch.ones(dtype=torch.bool, size=(batch_size, dim), device=self.device)\n # For simplicity, merge unstable locations for all elements in this batch. TODO: use individual unstable mask.\n unstable_locs = unstable_masks.sum(dim=0).bool()\n # This is always a 1-d indices. For conv layers it's flattened.\n unstable_idx = unstable_locs.nonzero().squeeze()\n # Number of unstable neurons after merging.\n max_non_zero = unstable_locs.sum()\n # Create a C matrix.\n newC = torch.zeros([1, max_non_zero, dim], device=self.device)\n # Fill the corresponding elements to 1.0\n newC[0, torch.arange(max_non_zero), unstable_idx] = 1.0\n newC = newC.repeat(batch_size, 1, 1).view(batch_size, max_non_zero, *node.output_shape[1:])\n reduced_dim = True\n # print(f'layer {node.name} total {dim} unstable {max_non_zero} newC {newC.size()}')\n else:\n if dim > 1000:\n warnings.warn(f\"Creating an identity matrix with size {dim}x{dim} for node {node}. This may indicate poor performance for bound computation. If you see this message on a small network please submit a bug report.\", stacklevel=2)\n newC = torch.eye(dim, device=self.device) \\\n .unsqueeze(0).repeat(batch_size, 1, 1) \\\n .view(batch_size, dim, *node.output_shape[1:])\n # print('Creating new C', type(newC), 'for', node)\n if False: # TODO: only return A_dict of final layer\n _, _, A_dict = self._backward_general(C=newC, node=node, root=root,\n return_A=return_A, A_dict=A_dict, intermedaite_constr=intermediate_constr)\n else:\n self._backward_general(C=newC, node=node, root=root, return_A=False, intermediate_constr=intermediate_constr, unstable_idx=unstable_idx)\n\n if reduced_dim:\n # If we only calculated unstable neurons, we need to scatter the results back based on reference bounds.\n new_lower = reference_bounds[node.name][0].detach().clone().view(batch_size, -1)\n new_lower[:, unstable_idx] = node.lower.view(batch_size, -1)\n node.lower = new_lower.view(batch_size, *node.output_shape[1:])\n new_upper = reference_bounds[node.name][1].detach().clone().view(batch_size, -1)\n new_upper[:, unstable_idx] = node.upper.view(batch_size, -1)\n node.upper = new_upper.view(batch_size, *node.output_shape[1:])\n # node.lower and node.upper (intermediate bounds) are computed in the above function.\n # If we have bound references, we set them here to always obtain a better set of bounds.\n if reference_bounds is not None and node.name in reference_bounds:\n # Initially, the reference bound and the computed bound can be exactly the same when intermediate layer beta is 0. This will prevent gradients flow. So we need a small guard here.\n if Check_against_base_lp:\n if node.name == Check_against_base_lp_layer:\n pass\n # print(reference_bounds[node.name][0][1,0,0,3].item(), node.lower[1,0,0,3].item())\n # node.lower = torch.max(reference_bounds[node.name][0] - 1e-5, node.lower)\n # node.upper = torch.min(reference_bounds[node.name][1] + 1e-5, node.upper)\n else:\n # For LP checking, fix all other intermediate layer bounds.\n node.lower = reference_bounds[node.name][0]\n node.upper = reference_bounds[node.name][1]\n else:\n # Setting reference bounds are actually incorrect. Because the split constraints are computed using slightly\n # different alpha (not the optimal), they can be slightly worse than original at the beginning.\n # So we only update bounds to reference if they cross zero (split constraints).\n node.lower = torch.max(reference_bounds[node.name][0] - 1e-5,\n node.lower)\n node.upper = torch.min(reference_bounds[node.name][1] + 1e-5,\n node.upper)\n \"\"\"\n update_lower = reference_bounds[node.name][0] >= 0\n node.lower[update_lower] = reference_bounds[node.name][0][update_lower]\n update_upper = reference_bounds[node.name][0] <= 0\n node.upper[update_upper] = reference_bounds[node.name][1][update_upper]\n \"\"\"\n\n if method == 'backward':\n # This is for the final output bound. No need to pass in intermediate layer beta constraints.\n return self._backward_general(C=C, node=final, root=root, bound_lower=bound_lower, bound_upper=bound_upper,\n return_A=return_A, needed_A_list=needed_A_list, average_A=average_A, A_dict=A_dict,\n return_b=return_b, b_dict=b_dict, unstable_idx=alpha_idx)\n elif method == 'forward':\n return self._forward_general(C=C, node=final, root=root, dim_in=dim_in, concretize=True)\n else:\n raise NotImplementedError","def Es_case_B(z, x, gamma):\n \n if z == 0 and x == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n #alp = alpha(z, x, beta2)\n alp = alpha_exact_case_B_brentq(z, x, beta)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n\n kap = 2*(alp - z)/beta\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\n \n N1 = cos2a - (1+x)\n N2 = (1+x)*sin2a - beta*kap\n D = kap - beta*(1+x)*sin2a\n \n #print(N1, N2, D)\n \n # SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\n NSC = (sin2a - beta*kap *cos2a)/ (gamma**2-1) \n \n return (N1*N2)/D**3\n #return (N1*N2 + NSC)/D**3","def p_donate_ci(self, a=5, alpha =1, beta=1):\n ones = self.counts[1:]\n zeros = self.counts[0]\n dist = beta_dist(ones + alpha, zeros + beta, 10000)\n lower_bound = np.percentile(dist, a / 2.0)\n upper_bound = np.percentile(dist, 100 - a / 2.0)\n mean = np.mean(dist)\n return (lower_bound, self.p_donate, upper_bound)","def findsubintervals (t ,x):\n k, m = len(t), len(x)\n if k<2:\n return zeros(m,1)\n else:\n j = concatenate([t, x]).argsort()\n i = nonzero(j >= k)\n arr = arange(0,m)\n arr = i - arr - 1\n arr = arr[0]\n return arr","def findLinearFunction(data, x):\n aData = []\n bData = []\n prevDs = ()\n for ds in data:\n if prevDs:\n aData.append(findLinearA(prevDs[0], prevDs[1], ds[0], ds[1]))\n prevDs = ds\n if len(aData) > 1:\n a = average(aData)\n else:\n return None\n for ds in data:\n bData.append(findLinearB(a, ds[0], ds[1]))\n b = average(bData)\n return makeLinearFunction(x, a, b)","def find_span( knots, degree, x ):\n # Knot index at left/right boundary\n low = degree\n high = 0\n high = len(knots)-1-degree\n\n # Check if point is exactly on left/right boundary, or outside domain\n if x <= knots[low ]: returnVal = low\n elif x >= knots[high]: returnVal = high-1\n else:\n # Perform binary search\n span = (low+high)//2\n while x < knots[span] or x >= knots[span+1]:\n if x < knots[span]:\n high = span\n else:\n low = span\n span = (low+high)//2\n returnVal = span\n\n return returnVal","def acq_max(ac, gp, ymax, restarts, bounds):\n\n x_max = bounds[:, 0]\n ei_max = 0\n\n for i in range(restarts):\n #Sample some points at random.\n x_try = numpy.asarray([numpy.random.uniform(x[0], x[1], size=1) for x in bounds]).T\n\n #Find the minimum of minus the acquisition function\n res = minimize(lambda x: -ac(x.reshape(1, -1), gp=gp, ymax=ymax), x_try, bounds=bounds, method='L-BFGS-B')\n\n #Store it if better than previous minimum(maximum).\n if -res.fun >= ei_max:\n x_max = res.x\n ei_max = -res.fun\n\n return x_max","def ab_finder(Func, Ind):\n b = []\n for i in range(len(Func)):\n for j in range(i+1, len(Func)):\n b.append(np.log(Func[i]/Func[j])/np.log(Ind[j]/Ind[i]))\n print(b)\n plt.plot([i for i in range(len(b))], b)\n b = np.mean(b)\n a = np.mean([Func[i]*(Ind[i]**b) for i in range(len(Func))])\n return a, b","def upper_bound_of_coefficient(f):\n weight = 0\n for c in f.itercoefficients():\n weight += abs(c)**2\n weight = arith1.floorsqrt(weight) + 1\n degree = f.degree()\n lc = f[degree]\n m = (degree >> 1) + 1\n bound = 1\n for i in range(1, m):\n b = combinatorial.binomial(m - 1, i) * weight + \\\n combinatorial.binomial(m - 1, i - 1) * lc\n if bound < b:\n bound = b\n return bound","def find_approx(self, gamma):\n if self.jumps != []:\n # first we divide the jumps of the BSS into subarrays in each of which the subsequent jumps are closer to each other than \\gamma\n jump_seq_list = identify_jump_subseq(self.jumps, gamma)\n # jumps will store all jumps of the projection\n jumps = []\n # iteration over each separate subsequence\n for jump_seq in jump_seq_list:\n # if an array consists of only one jump there is nothing to project\n if len(jump_seq) > 1:\n # we initialize the DAG structure and find the shortest path in the graph which is equivalent to projecting in the given interval\n graph = DAG(jump_seq, gamma)\n shortestPathTuple = graph.shortestPath()\n # we skip first and last element of the second entry of the shortestPathTuple since those are only auxiliary values specific to the graphs (-np.inf and np.inf); second entry of the shortestPathTuple is the set of jumps of the projection in the given interval\n jumps.append(shortestPathTuple[1][1:-1])\n else:\n jumps.append(jump_seq)\n else:\n return BinaryStateSequence(first_value = self.first_value, jumps = [], time_horizon = self.time_horizon)\n\n return BinaryStateSequence(first_value = self.first_value, jumps = flatten_list(jumps), \n time_horizon = self.time_horizon)","def biseccion(func, a, b, tol=1e-4):\n p = (a + b) / 2 \n while np.fabs(func(p)) > tol:\n p = (a + b) / 2 \n if func(a) * func(p) < 0:\n b = p\n elif func(a) * func(p) > 0:\n a = p\n else:\n return p\n return p","def bicgstab_iso(A, x, b, MVop, VVop, max_itr=500, atol=1E-14, rtol=1E-14):\n r_prv = b - MVop(A, x)\n \n r0 = r_prv.copy()\n \n rho_prv = 1\n alpha = 1\n omega_prv = 1\n \n v_prv = sp.zeros_like(x)\n p_prv = sp.zeros_like(x)\n \n for i in xrange(max_itr):\n rho = sp.trace(sp.dot(r0, r_prv))\n \n beta = (rho / rho_prv) * (alpha / omega_prv)\n \n p = r_prv + beta * (p_prv - omega_prv * v_prv)\n \n v = MVop(A, p)\n \n alpha = rho / VVop(r0, v)\n \n s = r_prv - alpha * v\n \n t = MVop(A, s)\n \n omega = VVop(t, s) / VVop(t, t)\n \n x += alpha * p + omega * s\n \n #Test x\n if sp.allclose(MVop(A, x), b, atol=atol, rtol=rtol):\n break\n \n r_prv = s - omega * t\n \n rho_prv = rho\n omega_prv = omega\n \n v_prv[:] = v\n p_prv[:] = p\n \n convg = i < max_itr - 1\n \n return x, convg","def _balance_scipy(self, data):\n try:\n from scipy.optimize import linprog\n except ImportError:\n raise ImportError(\"SciPy is required to balance systems\")\n\n c = -1 * np.ones(data['A_ub'].shape[1])\n sol = linprog(c, **data)\n assert sol.success\n return sol.x","def basis_generic(n, *, p, bound=1):\r\n if n == 0:\r\n return ((0,),) # \r\n if n == 1:\r\n return ((1,),)\r\n result = []\r\n \r\n # append P^{last} beta^{epsilon}\r\n for epsilon in [0,1]:\r\n # Without this lower bound edge case we lose the element (0, 1, 1) in degree 5.\r\n # I don't have a good explanation for what it means yet.\r\n lower_bound = bound + epsilon if bound > 1 else 1\r\n for last in range(lower_bound, 1 + (n // (2*(p - 1)))):\r\n remaining_degree = n - 2*(p-1)*last - epsilon\r\n basis_in_remaining_degree = basis_generic(remaining_degree, p=p, bound=p * last)\r\n for vec in basis_in_remaining_degree:\r\n result.append(vec + (last, epsilon))\r\n return tuple(result)","def select_around_interval(string, beg, end, fst, snd):\n assert 0 <= beg <= end <= len(string)\n\n # These edge cases should not yield a result\n if beg == end == len(string) or beg == end == 0:\n return\n\n match = expand_to_valid_structure(string, beg, end, fst, snd)\n if match == None:\n return None\n nbeg, nend = match\n #match1 = find_matching_pair(string, beg, end, fst, snd)\n #match2 = find_matching_pair(string, max(0, end - 1), fst, snd)\n #if match1 == None or match2 == None:\n #return None\n #nbeg, nend = max([match1, match2], key=interval_length)\n\n # If interval remains the same try selecting one level higher\n if (beg, end) == (nbeg, nend):\n if beg > 0:\n return select_around_interval(string, beg - 1, end, fst, snd)\n elif end < len(string):\n return select_around_interval(string, beg, end + 1, fst, snd)\n\n # Decide whether to select exclusive or remain inclusive\n if beg > nbeg + 1 or end < nend - 1:\n # Select exclusive\n nbeg += 1\n nend -= 1\n return Interval(nbeg, nend)","def interval_intersect(b, a, d, c):\n return (d <= a) and (b <= c) # int2 lower <= int1 upper AND int1 lower <= int2 upper","def solve_eq(preswet,func):\n\n from numpy import sign,diff\n\n # Sorry to be annoying but I'm going to force you to use\n # a monotonically increasing variable\n #assert (sign(diff(preswet))==1).all(), \"Use a monotonically increasing abscissa\"\n\n # Identify changes in sign of function\n dsign=sign(func)\n isdiff=np.zeros(dsign.shape,dtype=bool)\n isdiff[1:]=abs(diff(dsign)).astype(bool)\n\n # shift to get the value on the other side\n # of the x-axis\n shift=np.zeros(dsign.shape,dtype=bool)\n shift[:-1]=isdiff[1:]; shift[-1]=isdiff[0]\n\n # solve by linear interpolation between \n # values points\n sols=np.zeros((isdiff.sum()))\n stab=np.zeros((isdiff.sum()))\n for ii in range(isdiff.sum()):\n f0=func[isdiff][ii]\n f1=func[shift][ii]\n p0=preswet[isdiff][ii]\n p1=preswet[shift][ii]\n slope=(f1-f0)/(p1-p0)\n sols[ii]=p0-f0/slope\n stab[ii]=sign(slope)\n\n ### Debug with plots\n #fig=plt.figure()\n #ax=fig.add_subplot(111)\n #ax.plot(preswet,func)\n #ax.plot(sols,zeros(sols.shape),ls='',marker='o')\n #ax.plot(preswet[isdiff],func[isdiff],ls='',marker='+',mew=2)\n #ax.plot(preswet[shift],func[shift],ls='',marker='x',mew=2)\n #ax.grid(True)\n #show()\n\n return sols,stab","def quanty_index(i,ang=2):\n norb = 2*ang + 1\n k = (i//(2*norb))*(2*norb)\n if (i-k) < norb:\n j = k + 2*(i-k)\n else:\n j = k + 2*((i-k)-norb) + 1\n return j","def get_boundary_position_of_index():\n function = LegacyFunctionSpecification() \n function.must_handle_array = True\n for x in ['i','j','k']:\n function.addParameter(x, dtype='i', direction=function.IN)\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN, default = 1)\n for x in ['x','y','z']:\n function.addParameter(x, dtype='d', direction=function.OUT)\n function.addParameter('number_of_points', 'i', function.LENGTH) \n function.result_type = 'i'\n return function","def alpha_exact_case_D(z, x, beta, lamb):\n #beta = np.sqrt(beta2)\n f = lambda a: a + 1/2 * (lamb - beta*sqrt(lamb**2 + x**2 + 4*(1+x)*sin(a)**2 + 2*lamb*sin(2*a))) - z\n \n res = scipy.optimize.root_scalar(f, bracket=(-1,1))\n \n return res.root","def get_adl(adl_score,cog):\n ranges = [(0),(1,2),(3,4),(5,6,7),(8,9),(10,11),(12,13),(14,15,16)]\n modifier = [-2,-1,0,1,2,3,4,5]\n #\n found = True\n while found:\n for i,r in enumerate(ranges):\n print(adl_score,range[i])\n if adl_score in ranges[i]:\n adl_score = adl_score+modifier[i]\n found = False\n break\n return adl_score"],"string":"[\n \"def find_coeff(depth, period = 2*pi):\\n\\tfund_feq = 2 * pi / period\\n\\tAK = []\\n\\talphaK = []\\n\\n\\tfor n in range(1, depth+1):\\n\\t\\tdef a_function(x, i):\\n\\t\\t\\treturn input_function(x) * cos(i * fund_feq * x)\\n\\t\\tdef b_function(x, i):\\n\\t\\t\\treturn input_function(x) * sin(i * fund_feq * x)\\n\\t\\t(a, err) = quad(a_function, 0, period, n)\\n\\t\\tan = 2 * a / period\\n\\t\\t(b, err) = quad(b_function, 0, period, n)\\n\\t\\tbn = 2 * b / period\\n\\t\\tAk = math.sqrt(an**2 + bn**2)\\n\\t\\tAK.append(Ak)\\n\\t\\talphak = math.asin(an/Ak)\\n\\t\\talphaK.append(alphak)\\n\\treturn (AK, alphaK)\",\n \"def bracket(func, xa=0.0, xb=1.0, args=(), grow_limit=110.0, maxiter=1000):\\n\\t_gold = 1.618034\\n\\t_verysmall_num = 1e-21\\n\\tfa = apply(func, (xa,)+args)\\n\\tfb = apply(func, (xb,)+args)\\n\\tif (fa < fb):\\t\\t\\t # Switch so fa > fb\\n\\t dum = xa; xa = xb; xb = dum\\n\\t dum = fa; fa = fb; fb = dum\\n\\txc = xb + _gold*(xb-xa)\\n\\tfc = apply(func, (xc,)+args)\\n\\tfuncalls = 3\\n\\titer = 0\\n\\twhile (fc < fb):\\n\\t tmp1 = (xb - xa)*(fb-fc)\\n\\t tmp2 = (xb - xc)*(fb-fa)\\n\\t val = tmp2-tmp1\\n\\t if abs(val) < _verysmall_num:\\n\\t\\tdenom = 2.0*_verysmall_num\\n\\t else:\\n\\t\\tdenom = 2.0*val\\n\\t w = xb - ((xb-xc)*tmp2-(xb-xa)*tmp1)/denom\\n\\t wlim = xb + grow_limit*(xc-xb)\\n\\t if iter > maxiter:\\n\\t\\traise RuntimeError, \\\"Too many iterations.\\\"\\n\\t iter += 1\\n\\t if (w-xc)*(xb-w) > 0.0:\\n\\t\\tfw = apply(func, (w,)+args)\\n\\t\\tfuncalls += 1\\n\\t\\tif (fw < fc):\\n\\t\\t xa = xb; xb=w; fa=fb; fb=fw\\n\\t\\t return xa, xb, xc, fa, fb, fc, funcalls\\n\\t\\telif (fw > fb):\\n\\t\\t xc = w; fc=fw\\n\\t\\t return xa, xb, xc, fa, fb, fc, funcalls\\n\\t\\tw = xc + _gold*(xc-xb)\\n\\t\\tfw = apply(func, (w,)+args)\\n\\t\\tfuncalls += 1\\n\\t elif (w-wlim)*(wlim-xc) >= 0.0:\\n\\t\\tw = wlim\\n\\t\\tfw = apply(func, (w,)+args)\\n\\t\\tfuncalls += 1\\n\\t elif (w-wlim)*(xc-w) > 0.0:\\n\\t\\tfw = apply(func, (w,)+args)\\n\\t\\tfuncalls += 1\\n\\t\\tif (fw < fc):\\n\\t\\t xb=xc; xc=w; w=xc+_gold*(xc-xb)\\n\\t\\t fb=fc; fc=fw; fw=apply(func, (w,)+args)\\n\\t\\t funcalls += 1\\n\\t else:\\n\\t\\tw = xc + _gold*(xc-xb)\\n\\t\\tfw = apply(func, (w,)+args)\\n\\t\\tfuncalls += 1\\n\\t xa=xb; xb=xc; xc=w\\n\\t fa=fb; fb=fc; fc=fw\\n\\treturn xa, xb, xc, fa, fb, fc, funcalls\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p):\\r\\n a0 = 0\\r\\n a1 = a\\r\\n Ja0 = J0\\r\\n ga0 = g0\\r\\n Jprime = g0.T@p\\r\\n i = 0\\r\\n Ja1, ga1 = f(x0+a1*p)\\r\\n while True:\\r\\n if (Ja1 > (J0 + mu1*a1*Jprime)) or (Ja1 > Ja0 and i > 1):\\r\\n Ja, ga, astar = pinpoint(f, J0, g0, x0, mu1, mu2, \\\\\\r\\n a0, Ja0, ga0, a1, Ja1, ga1, p)\\r\\n return Ja, ga, astar\\r\\n Jprimea1 = ga1.T@p\\r\\n if (np.abs(Jprimea1) <= np.abs(mu2*Jprime)):\\r\\n astar = a1\\r\\n return Ja1, ga1, astar\\r\\n elif (Jprimea1 >= 0):\\r\\n Ja, ga, astar = pinpoint(f, J0, g0, x0, mu1, mu2, \\\\\\r\\n a1, Ja1, ga1, a0, Ja0, ga0, p)\\r\\n return Ja, ga, astar\\r\\n else:\\r\\n a0 = a1\\r\\n Ja0 = Ja1\\r\\n a1 = 1.2*a1\\r\\n Ja1, ga1 = f(x0+a1*p)\\r\\n i += 1\",\n \"def get_confidence_interval(self,a,b):\\n\\t\\tk_vals,prob_vals = self.tuple_of_probabilities\\n\\t\\tworking_indices = [i for i,v in enumerate(k_vals) if (v >= a and v<= b)]\\n\\t\\tworking_prob_vals = [prob_vals[i] for i in working_indices]\\n\\t\\treturn sum(working_prob_vals)\",\n \"def evaluate(bounds , func):\\n if len(bounds) != 2:\\n raise ValueError(\\\"Bounds should contain 2 elements, found %d.\\\" % len(bounds))\\n\\n a = bounds[0]\\n b = bounds[1]\\n ya = func(a)\\n yb = func((a+b)/2.)\\n yc = func(b)\\n I = (b-a) * (ya + 4. * yb + yc) / 6.\\n return I\",\n \"def search_interval_3d(function, point_a, point_b, step, tol, max_iterations,\\n show_process = False):\\n # The first interval is created with the values [0, step]\\n t = step\\n # We use a parametrization for the line based on the two points given.\\n # It is possible to get any point in the line changing the parameters t.\\n # For t=0 we get the point_b and for t=1 we get the point_a.\\n last_val = function( line_param(point_a, point_b, 0) )\\n current_val = function( line_param(point_a, point_b, t) )\\n \\n # While the signs of the function evaluated in the ends of the interval is\\n # the same.\\n iterations = 0\\n while last_val*current_val > 0:\\n if iterations > max_iterations:\\n raise Exception('Maximum iterations reached. But no solution was found.')\\n # Update the step\\n last_val = current_val\\n t += step\\n # Calculate the new value\\n current_val = function( line_param(point_a, point_b, t) )\\n iterations += 1\\n \\n # These point represent the interval for which a change is the signs exist.\\n # This means that there is a point in this interval for which the function\\n # is zero. We use bisection in this interval to find that point.\\n left_point = line_param(point_a, point_b, t - step)\\n right_point = line_param(point_a, point_b, t)\\n \\n if show_process: \\n print('number of iterations to find interval = {0}'.format(iterations))\\n print('interval found : [{0} , {1} ])'.format(left_point, right_point))\\n \\n return left_point, right_point\",\n \"def get_bounds(self, A: list, c: int) -> (int, int):\\r\\n\\r\\n # This implementation uses two binary search algorithms to find\\r\\n # the upper and lower bound.\\r\\n # First step is to isolate the upper_bound.\\r\\n\\r\\n L = 0\\r\\n R = len(A)\\r\\n while L < R:\\r\\n # Find the middle value\\r\\n m = math.floor((L + R) / 2)\\r\\n v = A[m]\\r\\n\\r\\n # Check if |A[i] - i| < c:\\r\\n if abs(v - m) > c:\\r\\n # This step is important, if we are on a negative number\\r\\n # We need to move right instead of left.\\r\\n if v < 0 or (v - m) < 0:\\r\\n L = m + 1\\r\\n else:\\r\\n # Else, we need to move towards the left.\\r\\n R = m\\r\\n else:\\r\\n # If it matches the condition, move the left up because we're\\r\\n # going towards the lowest number.\\r\\n L = m + 1\\r\\n upper_bound = R\\r\\n\\r\\n # Now that we have the upper bound, we only need to\\r\\n # Binary search for the lower bound between index 0 and upper_bound.\\r\\n L = 0\\r\\n R = upper_bound\\r\\n while L < R:\\r\\n # find the middle\\r\\n m = math.floor((L + R) / 2)\\r\\n if abs(A[m] - m) > c:\\r\\n # If it's greater, move the left up.\\r\\n L = m + 1\\r\\n else:\\r\\n # Else, move the right down.\\r\\n R = m\\r\\n\\r\\n # Finally we have the lower bound.\\r\\n lower_bound = L\\r\\n\\r\\n # Return the lower bound and the upper bound index\\r\\n # Note the -1 because the upper bound will give the\\r\\n # size of the array in worst case.\\r\\n return lower_bound, upper_bound - 1\",\n \"def interval(a, b):\\n aIndex, bIndex = None, None\\n for i in range(len(table)):\\n fs = table[i]\\n if aIndex == None and fs >= a: aIndex = i\\n if bIndex == None and fs > b: bIndex = i\\n if bIndex == None: bIndex = len(table)\\n return bIndex - aIndex\",\n \"def solve_working(\\n assets_this_period,\\n assets_next_period,\\n hc_this_period,\\n hc_next_period,\\n interest_rate,\\n wage_rate,\\n income_tax_rate,\\n beta,\\n gamma,\\n sigma,\\n neg,\\n continuation_value,\\n delta_hc,\\n zeta,\\n psi,\\n n_gridpoints_capital,\\n n_gridpoints_hc,\\n efficiency,\\n survival_rate,\\n):\\n # Initialize objects\\n policy_labor_working_tmp = np.zeros(\\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\\n )\\n\\n # Implied hc effort\\n hc_effort = get_hc_effort(\\n hc_this_period=hc_this_period,\\n hc_next_period=hc_next_period,\\n zeta=zeta,\\n psi=psi,\\n delta_hc=delta_hc,\\n )\\n\\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\\n\\n # Implied labor supply\\n labor_input = 1 - hc_effort\\n\\n # Consumption\\n consumption = get_consumption(\\n assets_this_period=assets_this_period,\\n assets_next_period=assets_next_period,\\n pension_benefit=np.float64(0.0),\\n labor_input=labor_input,\\n interest_rate=interest_rate,\\n wage_rate=wage_rate,\\n income_tax_rate=income_tax_rate,\\n productivity=hc_this_period,\\n efficiency=efficiency,\\n )\\n\\n # Flow utility\\n flow_utility = util(\\n consumption=consumption,\\n labor_input=labor_input,\\n hc_effort=hc_effort,\\n gamma=gamma,\\n sigma=sigma,\\n )\\n\\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\\n\\n # Value function on the complete mesh (i.e. for all possible choices)\\n value_full = flow_utility + beta * survival_rate * continuation_value\\n\\n # Derive optimal policies and store value function given optimal choices\\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\\n for assets_this_period_idx in range(n_gridpoints_capital):\\n for hc_this_period_idx in range(n_gridpoints_hc):\\n assets_next_period_idx = policy_capital_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n hc_next_period_idx = policy_hc_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n policy_labor_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ] = labor_input[\\n assets_this_period_idx,\\n assets_next_period_idx,\\n hc_this_period_idx,\\n hc_next_period_idx,\\n ]\\n\\n return (\\n policy_capital_working_tmp,\\n policy_hc_working_tmp,\\n policy_labor_working_tmp,\\n value_working_tmp,\\n )\",\n \"def find_balance(stmt, start=0):\\n open_list = ['(']\\n close_list = [')']\\n stack = []\\n found = False\\n for i, val in enumerate(stmt[start:]):\\n if val in open_list:\\n stack.append(val)\\n found = True\\n elif val in close_list:\\n pos = close_list.index(val)\\n if (stack and open_list[pos] == stack[len(stack) - 1]):\\n stack.pop()\\n else:\\n raise Exception(\\\"Unbalanced parentheses found\\\")\\n if found and not stack:\\n return i + start + 1\\n raise Exception(\\\"Unbalanced parentheses found\\\")\",\n \"def beta_range_s_circular(s,sma):\\n #sma**2. = s**2. + y**2.\\n if s > sma: #failure mode/nonphysical\\n s = sma\\n y = np.sqrt(sma**2.-s**2.)\\n beta_min = np.pi/2. - np.arctan2(y,s)\\n beta_max = np.pi/2. + np.arctan2(y,s)\\n return beta_min, beta_max\",\n \"def overlap_ss(Ax, Ay, Az, Cx, Cy, Cz, alpha_bra, alpha_ket, c1, c2):\\n A = np.array([Ax, Ay, Az])\\n C = np.array([Cx, Cy, Cz])\\n alpha_sum = alpha_bra + alpha_ket\\n return c1 * c2 * (np.pi / alpha_sum)**(3/2) * np.exp((-alpha_bra * alpha_ket * np.dot(A-C, A-C)) / alpha_sum)\",\n \"def testPolicy( \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n self, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n symbol=\\\"jpm\\\", \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sd=dt.datetime(2008, 1, 1), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ed=dt.datetime(2009, 12, 31), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sv=10000, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ): \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n dates = pd.date_range(sd,ed)\\n df_prices = ind.get_price(symbol, dates)\\n\\n daily_rets = (df_prices / df_prices.shift(1)) - 1\\n daily_rets = daily_rets[1:]\\n\\n\\n sd_older = sd - dt.timedelta(days=365)\\n dates_older = pd.date_range(sd_older,ed)\\n df_prices_older = ind.get_price(symbol, dates_older)\\n sd_key = df_prices.index[0]\\n sd_index = df_prices_older.index.get_loc(sd_key)\\n\\n\\n df_holdings = df_prices.copy()\\n df_holdings['Holdings'] = np.nan\\n del df_holdings[symbol]\\n # print(df_holdings)\\n\\n cum_ret_prev = 0\\n iters = 0\\n\\n\\n num_bins = len(self.bins)\\n\\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\\n _,_,ind5 = ind.get_MACD(df_prices_older)\\n BB = ind1.iloc[sd_index:].values\\n CCI = ind2.iloc[sd_index:].values\\n SMA_Cross = ind3.iloc[sd_index:].values\\n Momentum = ind4.iloc[sd_index:].values\\n MACD = ind5.iloc[sd_index:].values\\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\\n state = x_0 + x_3*10 + x_4*100\\n\\n\\n\\n\\n\\n self.learner.rar = 0\\n\\n action = self.learner.querysetstate(state[0])\\n\\n daily_return = daily_rets.iloc[0][symbol]\\n df_holdings.iloc[0]['Holdings'] = 0\\n\\n\\n for day_idx in range(1,daily_rets.shape[0]):\\n\\n # implement action\\n cur_price = df_prices.iloc[day_idx-1][symbol]\\n next_price = df_prices.iloc[day_idx][symbol]\\n action = self.learner.querysetstate(state[day_idx])\\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\\n\\n\\n df_holdings.iloc[-1]['Holdings'] = 0\\n df_trades = df_holdings.diff()\\n df_trades['Trades'] = df_trades['Holdings']\\n del df_trades['Holdings']\\n df_trades.iloc[0]['Trades'] = 0\\n return df_trades\",\n \"def find_s_in_range(a, b, prev_s, B, c):\\n ri = ceil(2 * (b * prev_s - 2 * B), n)\\n\\n while True:\\n si_lower = ceil(2 * B + ri * n, b)\\n si_upper = ceil(3 * B + ri * n, a)\\n\\n for si in range(si_lower, si_upper):\\n attempt = (c * pow(si, e, n)) % n\\n attempt = rsa1.integer_to_bytes(attempt)\\n\\n if oracle(attempt):\\n return si\\n \\n ri += 1\",\n \"def boundary(gap, min_tags_in_window, average):\\n\\tassert min_tags_in_window >= 1;\\n\\ttemp = 0;\\n\\tfor i in range(0, min_tags_in_window): temp += poisson(i, average);\\n\\ttemp = pow(temp, gap+1); \\n\\treturn temp*temp; # start & end \",\n \"def set_sobol_g_func():\\n a = np.zeros(21)\\n x = np.zeros(21) \\n\\n # a[0:2] = 0\\n # a[2:9] = [0.005, 0.020, 0.040, 0.060, 0.08, 0.090, 1]\\n # a[9:16] = 2\\n # a[16:24] = [2.10, 2.25, 2.75, 3, 3.10, 3.15, 3.25, 3.50]\\n # a[24:30] = 9\\n # a[30:44] = [8, 8.5, 9, 10, 10.5, 11, 12, 12.5, 13, 13.5, 14, 14.5, 15, 16]\\n # a[44:] = [70, 75, 80, 85, 90, 99]\\n\\n a[0:2] = 0\\n a[2:4] = [0.005, 0.090]\\n a[4:7] = 2\\n a[7:11] = [2.10, 2.75, 3, 3.15]\\n a[11:15] = [8, 13, 13.5, 16]\\n a[15:] = [70, 75, 80, 85, 90, 99]\\n\\n x_names = ['x' + str(i+1) for i in range(21)]\\n len_params = len(x_names)\\n x_bounds = np.zeros((21, 2))\\n x_bounds[:, 0] = 0\\n x_bounds[:, 1] = 1\\n\\n problem = {\\n 'num_vars': len(x),\\n 'names': x_names,\\n 'bounds': x_bounds\\n }\\n return a, x, x_bounds, x_names, len_params, problem\",\n \"def getx(v, lb, ub, i, B):\\r\\n x = lb + np.multiply((ub - lb), v)\\r\\n x[i] = B - (x.sum() - x[i])\\r\\n # Test if variable x[i] is within the bounds\\r\\n if x[i] <= ub[i] and x[i] >= lb[i]:\\r\\n return x\\r\\n else:\\r\\n return np.array([])\",\n \"def _get_effect_interval(counts, effect, power_alpha=0.05, ci_alpha=None):\\n\\n if isinstance(effect, (int, float)):\\n l_bar = effect\\n ci = np.nan\\n\\n elif ci_alpha is None:\\n ci = np.nanstd(effect)\\n l_bar = np.nanmean(effect)\\n else:\\n ci = confidence_bound(effect, alpha=ci_alpha)\\n l_bar = np.nanmean(effect)\\n\\n l_low = l_bar - ci\\n l_hi = l_bar + ci\\n\\n power_bar = z_power(counts, l_bar, power_alpha)\\n if not np.isnan(ci):\\n power_low = z_power(counts, l_low, power_alpha)\\n power_hi = z_power(counts, l_hi, power_alpha)\\n else:\\n power_low = np.nan * power_bar\\n power_hi = np.nan * power_bar\\n\\n return power_bar, power_low, power_hi\",\n \"def interq_range(sig):\\n #ny.percentile(sig, 75) - ny.percentile(sig, 25)\\n return np.percentile(sig, 75) - np.percentile(sig, 25)\",\n \"def budget_problem3(balance, annualInterestRate):\\r\\n remaining = balance\\r\\n\\r\\n # creating the following bounds assists with bisection search\\r\\n lo = balance/12\\r\\n hi = ((balance * (annualInterestRate/12))**12)/12\\r\\n payment = (lo + hi)/2\\r\\n\\r\\n while remaining != 0:\\r\\n for month in range(12):\\r\\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\\r\\n if remaining > 0:\\r\\n lo = payment\\r\\n elif round(remaining,2) < -0.11:\\r\\n hi = payment\\r\\n else:\\r\\n break\\r\\n payment = (lo + hi)/2\\r\\n remaining = balance\\r\\n print 'Lowest Payment: ' + str(round(payment,2))\\r\\n return round(payment,2)\",\n \"def bisecter(func, step=0.1):\\n points = list(func.points(step))\\n area = sum(map(lambda p: p[1], points))\\n\\n current = 0.\\n for x, y in points:\\n current += y\\n if current >= area / 2:\\n return x\",\n \"def get_new_bracket(x1, x2, x3, x4):\\n points = [x1, x2, x3]\\n dist = float(inf)\\n for point in points:\\n if abs(x4 - point) < dist and f(point) * f(x4) < 0:\\n valid_point = point\\n dist = abs(x4 - point)\\n return valid_point\",\n \"def compute_interval_limits(bias, acceleration, n_boots, ci=95):\\n from scipy.stats import norm\\n from numpy import isnan, nan\\n\\n alpha = _compute_alpha_from_ci(ci)\\n\\n alpha_low = alpha / 2\\n alpha_high = 1 - (alpha / 2)\\n\\n z_low = norm.ppf(alpha_low)\\n z_high = norm.ppf(alpha_high)\\n\\n kws = {'bias': bias, 'acceleration': acceleration}\\n low = _compute_quantile(z_low, **kws)\\n high = _compute_quantile(z_high, **kws)\\n\\n if isnan(low) or isnan(high):\\n return low, high\\n\\n else:\\n low = int(norm.cdf(low) * n_boots)\\n high = int(norm.cdf(high) * n_boots)\\n return low, high\",\n \"def compound(ir, period):\\n\\treturn ir.compound(period)\",\n \"def _intersect_continuous(self, interval):\\n first = self.intervals.bisect_left(interval)\\n last = first\\n while first > 0 and \\\\\\n self.intervals[first - 1].upper >= interval.lower:\\n first -= 1\\n while last < len(self.intervals) and \\\\\\n self.intervals[last].lower <= interval.upper:\\n last += 1\\n return first, last\",\n \"def interval_prob(x1, x2, a, b):\\n with mp.extradps(5):\\n a, b = _validate_a_b(a, b)\\n x1 = mp.mpf(x1)\\n x2 = mp.mpf(x2)\\n if x1 > x2:\\n raise ValueError('x1 must not be greater than x2')\\n return mp.betainc(a, b, x1, x2, regularized=True)\",\n \"def bs(a, b):\\n if b - a == 1:\\n # Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)\\n if a == 0:\\n Pab = Qab = mpz(1)\\n else:\\n Pab = mpz((6*a-5)*(2*a-1)*(6*a-1))\\n Qab = mpz(a*a*a*C3_OVER_24)\\n Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)\\n if a & 1:\\n Tab = -Tab\\n else:\\n # Recursively compute P(a,b), Q(a,b) and T(a,b)\\n # m is the midpoint of a and b\\n m = (a + b) // 2\\n # Recursively calculate P(a,m), Q(a,m) and T(a,m)\\n Pam, Qam, Tam = bs(a, m)\\n # Recursively calculate P(m,b), Q(m,b) and T(m,b)\\n Pmb, Qmb, Tmb = bs(m, b)\\n # Now combine\\n Pab = Pam * Pmb\\n Qab = Qam * Qmb\\n Tab = Qmb * Tam + Pam * Tmb\\n return Pab, Qab, Tab\",\n \"def findInterval(intervals,interval):\\n low,ind = algorithms.binsearch(intervals,interval.start-1,lambda a,b: cmp(a.start,b))\\n return (low,ind)\",\n \"def boundary_conditions(x, t, z=None, nbsym=2):\\n indmax = argrelmax(x)[0]\\n indmin = argrelmin(x)[0]\\n lx = x.shape[0] - 1\\n if indmin.shape[0] + indmax.shape[0] < 3:\\n raise ValueError(\\\"Not enough extrema.\\\")\\n\\n if indmax[0] < indmin[0]:\\n if x[0] > x[indmin[0]]:\\n lmax = indmax[1:np.min([indmax.shape[0], nbsym + 1])][::-1]\\n lmin = indmin[:np.min([indmin.shape[0], nbsym])][::-1]\\n lsym = indmax[0]\\n else:\\n lmax = indmax[1:np.min([indmax.shape[0], nbsym])][::-1]\\n lmin = indmin[:np.min([indmin.shape[0], nbsym - 1])][::-1]\\n lmin = np.hstack((lmin, [1]))\\n lsym = 1\\n else:\\n if x[0] < x[indmax[0]]:\\n lmax = indmax[:np.min([indmax.shape[0], nbsym])][::-1]\\n lmin = indmin[1:np.min([indmin.shape[0], nbsym + 1])][::-1]\\n lsym = indmin[0]\\n else:\\n lmax = indmax[:np.min([indmin.shape[0], nbsym - 1])][::-1]\\n lmax = np.hstack((lmax, [1]))\\n lmin = indmin[:np.min([indmax.shape[0], nbsym])][::-1]\\n lsym = 1\\n\\n if indmax[-1] < indmin[-1]:\\n if x[-1] < x[indmax[-1]]:\\n rmax = indmax[(max([indmax.shape[0] - nbsym + 1, 1]) - 1):][::-1]\\n rmin = indmin[(max([indmin.shape[0] - nbsym, 1]) - 1):-1][::-1]\\n rsym = indmin[-1]\\n else:\\n rmax = indmax[max(indmax.shape[0] - nbsym + 1, 0):indmax.shape[0]][::-1]\\n rmax = np.hstack(([lx], rmax))\\n rmin = indmin[max(indmin.shape[0] - nbsym, 0):][::-1]\\n rsym = lx\\n else:\\n if x[-1] > x[indmin[-1]]:\\n rmax = indmax[max(indmax.shape[0] - nbsym - 1, 0):-1][::-1]\\n rmin = indmin[max(indmin.shape[0] - nbsym, 0):][::-1]\\n rsym = indmax[-1]\\n else:\\n rmax = indmax[max(indmax.shape[0] - nbsym, 0):][::-1]\\n rmin = indmin[max(indmin.shape[0] - nbsym + 1, 0):][::-1]\\n rmin = np.hstack(([lx], rmin))\\n rsym = lx\\n\\n tlmin = 2 * t[lsym] - t[lmin]\\n tlmax = 2 * t[lsym] - t[lmax]\\n trmin = 2 * t[rsym] - t[rmin]\\n trmax = 2 * t[rsym] - t[rmax]\\n\\n # In case symmetrized parts do not extend enough\\n if (tlmin[0] > t[0]) or (tlmax[0] > t[1]):\\n if lsym == indmax[0]:\\n lmax = indmax[:np.min((indmax.shape[0], nbsym))][::-1]\\n else:\\n lmin = indmin[:np.min((indmin.shape[0], nbsym))][::-1]\\n if lsym == 1:\\n raise Exception(\\\"Bug\\\")\\n lsym = 1\\n tlmin = 2 * t[lsym] - t[lmin]\\n tlmax = 2 * t[lsym] - t[lmax]\\n\\n if (trmin[-1] < t[lx]) or (trmax[-1] < t[lx]):\\n if rsym == indmax.shape[0]:\\n rmax = indmax[np.max([indmax.shape[0] - nbsym + 1,\\n 1]):indmax.shape[0]][::-1]\\n else:\\n rmin = indmin[np.max([indmax.shape[0] - nbsym + 1,\\n 1]):indmin.shape[0]][::-1]\\n\\n if rsym == lx:\\n raise Exception(\\\"bug\\\")\\n rsym = lx\\n trmin = 2 * t[rsym] - t[rmin]\\n trmax = 2 * t[rsym] - t[rmax]\\n\\n if z is None:\\n z = x\\n zlmax = z[lmax]\\n zlmin = z[lmin]\\n zrmax = z[rmax]\\n zrmin = z[rmin]\\n\\n tmin = map(np.array, [tlmin, t[indmin], trmin])\\n tmax = map(np.array, [tlmax, t[indmax], trmax])\\n zmin = map(np.array, [zlmin, z[indmin], zrmin])\\n zmax = map(np.array, [zlmax, z[indmax], zrmax])\\n\\n tmin, tmax, zmin, zmax = map(np.hstack, [tmin, tmax, zmin, zmax])\\n return tmin, tmax, zmin, zmax\",\n \"def find_balanced_budget_tax(c):\\n def steady_state_budget(t):\\n e, u, w = compute_steady_state_quantities(c, t)\\n return t - u * c\\n\\n tau = brentq(steady_state_budget, 0.0, 0.9 * c)\\n return tau\",\n \"def lagrange_coefficients_ASTME2022(interval=10, interval_type='inner'):\\n\\n global _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE\\n if _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE is None:\\n _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE = CaseInsensitiveMapping()\\n\\n name_lica = ', '.join((str(interval), interval_type))\\n if name_lica in _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE:\\n return _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE[name_lica]\\n\\n r_n = np.linspace(1 / interval, 1 - (1 / interval), interval - 1)\\n d = 3\\n if interval_type.lower() == 'inner':\\n r_n += 1\\n d = 4\\n\\n lica = _LAGRANGE_INTERPOLATING_COEFFICIENTS_CACHE[name_lica] = (\\n as_float_array([lagrange_coefficients(r, d) for r in r_n]))\\n\\n return lica\",\n \"def equation_level_calculation(element_x, element_y):\\n a = 4 * pow(element_x, 2) + pow(element_y, 2)\\n b = 3 * pow(element_x, 2) + pow(element_y, 2)\\n c = 3 * pow(element_x, 2) - pow(element_y, 2) if element_x > element_y else None\\n return [a, b, c]\",\n \"def bs(a, b):\\n if b - a == 1:\\n # Directly compute P(a,a+1), Q(a,a+1) and T(a,a+1)\\n if a == 0:\\n Pab = Qab = mpz(1)\\n else:\\n Pab = mpz((6*a-5)*(2*a-1)*(6*a-1))\\n Qab = mpz(a*a*a*C3_OVER_24)\\n Tab = Pab * (13591409 + 545140134*a) # a(a) * p(a)\\n if a & 1:\\n Tab = -Tab\\n else:\\n # Recursively compute P(a,b), Q(a,b) and T(a,b)\\n # m is the midpoint of a and b\\n m = (a + b) // 2\\n # Recursively calculate P(a,m), Q(a,m) and T(a,m)\\n Pam, Qam, Tam = bs(a, m)\\n # Recursively calculate P(m,b), Q(m,b) and T(m,b)\\n Pmb, Qmb, Tmb = bs(m, b)\\n # Now combine\\n Pab = Pam * Pmb\\n Qab = Qam * Qmb\\n Tab = Qmb * Tam + Pam * Tmb\\n return Pab, Qab, Tab\",\n \"def boundary_conditions(particle_outer_radius, boundary_temp):\\n\\n boundary_condition = [particle_outer_radius, boundary_temp]\\n\\n return boundary_condition\",\n \"def find_single_fit_range(lorentz_params):\\n f0 = lorentz_params[1]\\n FWHM = lorentz_params[2]\\n return (f0 - 4 * FWHM, f0 - 2 * FWHM, f0 + 2 * FWHM, f0 + 4 * FWHM)\",\n \"def get_bounds():\\n bounds = [\\n (0.1, 0.5), # Omega_m\\n (0.05, 0.15) # beta\\n ]\\n return np.array(bounds)\",\n \"def get_continuum_in_range(w,s,low_low, low_high, high_low, high_high,\\n pmin=12,pmax=88, only_correct_negative_values = False,\\n fit_degree=2, plot = True, verbose = True, warnings=True) :\\n s_low = s[np.where((w <= low_low))] \\n s_high = s[np.where((w >= high_high))] \\n \\n w_fit = w[np.where((w > low_low) & (w < high_high))]\\n w_fit_low = w[np.where((w > low_low) & (w < low_high))]\\n w_fit_high = w[np.where((w > high_low) & (w < high_high))]\\n\\n y_fit = s[np.where((w > low_low) & (w < high_high))]\\n y_fit_low = s[np.where((w > low_low) & (w < low_high))]\\n y_fit_high = s[np.where((w > high_low) & (w < high_high))]\\n\\n # Remove outliers\\n median_y_fit_low = np.nanmedian(y_fit_low)\\n for i in range(len(y_fit_low)):\\n if np.nanpercentile(y_fit_low,2) > y_fit_low[i] or y_fit_low[i] > np.nanpercentile(y_fit_low,98): y_fit_low[i] =median_y_fit_low\\n\\n median_y_fit_high = np.nanmedian(y_fit_high)\\n for i in range(len(y_fit_high)):\\n if np.nanpercentile(y_fit_high,2) > y_fit_high[i] or y_fit_high[i] > np.nanpercentile(y_fit_high,98): y_fit_high[i] =median_y_fit_high\\n \\n w_fit_cont = np.concatenate((w_fit_low,w_fit_high))\\n y_fit_cont = np.concatenate((y_fit_low,y_fit_high))\\n \\n try:\\n fit = np.polyfit(w_fit_cont,y_fit_cont, fit_degree)\\n yfit = np.poly1d(fit)\\n y_fitted = yfit(w_fit)\\n \\n y_fitted_low = yfit(w_fit_low)\\n median_low = np.nanmedian(y_fit_low-y_fitted_low)\\n rms=[]\\n for i in range(len(y_fit_low)):\\n rms.append(y_fit_low[i]-y_fitted_low[i]-median_low)\\n \\n # rms=y_fit-y_fitted\\n lowlimit=np.nanpercentile(rms,pmin)\\n highlimit=np.nanpercentile(rms,pmax)\\n \\n corrected_s_ =copy.deepcopy(y_fit)\\n for i in range(len(w_fit)):\\n if w_fit[i] >= low_high and w_fit[i] <= high_low: # ONLY CORRECT in [low_high,high_low] \\n if only_correct_negative_values:\\n if y_fit[i] <= 0 : \\n corrected_s_[i] = y_fitted[i]\\n else:\\n if y_fit[i]-y_fitted[i] <= lowlimit or y_fit[i]-y_fitted[i] >= highlimit: corrected_s_[i] = y_fitted[i]\\n \\n \\n corrected_s = np.concatenate((s_low,corrected_s_))\\n corrected_s = np.concatenate((corrected_s,s_high))\\n \\n \\n if plot:\\n ptitle = \\\"CorrectionBase in range \\\"+np.str(np.round(low_low,2))+\\\" - [ \\\"+np.str(np.round(low_high,2))+\\\" - \\\"+np.str(np.round(high_low,2))+\\\" ] - \\\"+np.str(np.round(high_high,2))\\n plot_plot(w_fit,[y_fit,y_fitted,y_fitted-highlimit,y_fitted-lowlimit,corrected_s_], color=[\\\"r\\\",\\\"b\\\", \\\"black\\\",\\\"black\\\",\\\"green\\\"], alpha=[0.3,0.7,0.2,0.2,0.5],xmin=low_low-40, xmax=high_high+40,vlines=[low_low,low_high,high_low,high_high],ptitle=ptitle, ylabel=\\\"Normalized flux\\\") \\n #plot_plot(w,[s,corrected_s],xmin=low_low-40, xmax=high_high+40,vlines=[low_low,low_high,high_low,high_high])\\n except Exception:\\n if warnings: print(\\\" Fitting the continuum failed! Nothing done.\\\")\\n corrected_s = s\\n\\n return corrected_s\",\n \"def three_stable_points(rational_function, invariant_list):\\n # define ground field and ambient function field\\n if rational_function.parent().is_field():\\n K = rational_function.parent()\\n R = K.ring()\\n else:\\n R = rational_function.parent()\\n K = R.fraction_field()\\n\\n z = R.gen(0)\\n phi = K(rational_function)\\n\\n T = invariant_list\\n\\n automorphisms = []\\n for t in permutations(range(len(T)),3):\\n a = (T[0][0]*T[1][1]*T[2][1]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] -\\n T[0][0]*T[1][1]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] +\\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] +\\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0])\\n\\n b = (T[0][0]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0] -\\n T[0][0]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] -\\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][0] *T[t[2]][1] +\\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][0] +\\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][0]*T[t[1]][0]*T[t[2]][1] -\\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][0])\\n\\n c = (T[0][0]*T[1][1]*T[2][1]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\\n T[0][0]*T[1][1]*T[2][1]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] -\\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] +\\n T[0][1]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] +\\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] -\\n T[0][1]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][0]*T[t[2]][1])\\n\\n d = (T[0][0]*T[1][0]*T[2][1]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] -\\n T[0][0]*T[1][0]*T[2][1]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][0]*T[t[1]][1]*T[t[2]][1] +\\n T[0][0]*T[1][1]*T[2][0]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0] +\\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][1]*T[t[1]][0] *T[t[2]][1]-\\n T[0][1]*T[1][0]*T[2][0]*T[t[0]][1]*T[t[1]][1]*T[t[2]][0])\\n\\n if a*d - b*c != 0:\\n s = K(a*z + b) / K(c*z + d)\\n if s(phi(z)) == phi(s(z)) and s not in automorphisms:\\n automorphisms.append(s)\\n return automorphisms\",\n \"def linesearch(f, x0, J0, g0, a, amax, mu1, mu2, p):\\r\\n J, g, a = bracketing(f, x0, J0, g0, a, amax, mu1, mu2, p)\\r\\n x = x0+a*p\\r\\n return x, J, g, a\",\n \"def interval(self, alpha: float = 0.32, printlevel: int = 1) -> dict[str, float]:\\n\\n bands = {}\\n poinull = self.poinull\\n observed = self.calculator.bestfit.params[poinull.parameter][\\\"value\\\"]\\n bands[\\\"observed\\\"] = observed\\n\\n if min(self.pvalues()) > alpha:\\n msg = f\\\"The minimum of the scanned p-values is {min(self.pvalues())} which is larger than the\\\"\\n msg += f\\\" confidence level alpha = {alpha}. Try to increase the range of POI values.\\\"\\n raise POIRangeError(msg)\\n\\n tck = interpolate.splrep(poinull.values, self.pvalues() - alpha, s=0)\\n roots = np.array(interpolate.sproot(tck))\\n\\n msg = f\\\" bound on the POI `{poinull.name}` cannot not be interpolated.\\\"\\n\\n if roots.size > 2:\\n msg_warn = \\\"Multiple roots have been founds.\\\"\\n if isinstance(self.calculator, FrequentistCalculator):\\n msg_warn += \\\" Try to increase the number of toys, 'ntoysnull', to reduce fluctuations.\\\"\\n warnings.warn(msg_warn)\\n\\n lower_roots = roots[roots < observed]\\n upper_roots = roots[roots > observed]\\n\\n if upper_roots.size == 0:\\n msg = \\\"Upper\\\" + msg + \\\" Try to increase the maximum POI value.\\\"\\n raise POIRangeError(msg)\\n else:\\n bands[\\\"upper\\\"] = max(upper_roots)\\n\\n if lower_roots.size == 0:\\n if self.qtilde:\\n bands[\\\"lower\\\"] = 0.0\\n else:\\n msg = \\\"Low\\\" + msg + \\\" Try to decrease the minimum POI value.\\\"\\n raise POIRangeError(msg)\\n else:\\n bands[\\\"lower\\\"] = min(lower_roots)\\n\\n if self.qtilde and bands[\\\"lower\\\"] < 0.0:\\n bands[\\\"lower\\\"] = 0.0\\n\\n if printlevel > 0:\\n msg = f\\\"\\\\nConfidence interval on {poinull.name}:\\\\n\\\"\\n msg += f\\\"\\\\t{bands['lower']} < {poinull.name} < {bands['upper']} at {(1 - alpha) * 100:.1f}% C.L.\\\"\\n print(msg)\\n\\n return bands\",\n \"def I_bisection(self,a,b,tol,itr):\\n \\n ibs=[]\\n iterations=0\\n ibs_x=[]\\n while iterations < itr:\\n \\n if (a+b)/2 > tol:\\n a=a\\n b=(a+b)/2\\n ibs_x.append(b)\\n #print(\\\"Upper Bound = \\\",b)\\n \\n \\n elif (a+b)/2 < tol :\\n a=(a+b)/2\\n b=b\\n #print(\\\"Lowe Bound =\\\",a)\\n ibs_x.append(a)\\n \\n \\n elif (a+b)/2 == tol:\\n ibs_x.append((a+b)/2)\\n #print(\\\" Sol =\\\" , (a+b)/2)\\n iterations=iterations+1\\n \\n \\n #print(\\\"IBS =\\\",self.Func((a+b)/2),\\\" iter=\\\",iterations) \\n ibs.append(ibs_x)\\n ibs.append((a+b)/2)\\n ibs.append(iterations)\\n \\n return ibs\",\n \"def computeBound(A, omega, Q, omega2, Q2, k):\\n A = A.todense()\\n M = Q2.T.dot(A).dot(Q2)\\n R = A.dot(Q2) - Q2.dot(M)\\n \\n normR = numpy.linalg.norm(R) \\n lmbda, U = numpy.linalg.eigh(M)\\n L2 = omega[k:]\\n\\n delta = float(\\\"inf\\\")\\n \\n for i in lmbda: \\n for j in L2: \\n if abs(i-j) < delta: \\n delta = abs(i-j) \\n \\n #print(lmbda, L2)\\n print(\\\"normR=\\\" + str(normR), \\\"delta=\\\"+ str(delta), \\\"bound=\\\"+str(normR/delta))\\n \\n return normR/delta\",\n \"def sf_bound(l0, l2, lmbdas, bidual, r, rank=False):\\n\\n xvals, bnd = [], []\\n if l0 == \\\"constr\\\":\\n offset = 2\\n if rank == False:\\n bnd_label = r\\\"$p^{\\\\ast \\\\ast}(k + r + 2)$\\\"\\n else:\\n bnd_label = r\\\"$p^{\\\\ast \\\\ast}(k + r + 2) - \\\\zeta_r$\\\"\\n\\n for l in lmbdas:\\n # if l - r - offset > 0:\\n # xvals.append(l)\\n # bnd.append(bidual[l-r-offset])\\n if l + r + offset < lmbdas[-1]:\\n bnd.append(bidual[l + r + offset])\\n else:\\n bnd.append(bidual[-1])\\n\\n xvals = lmbdas\\n\\n elif l0 == \\\"pen\\\":\\n offset = 1\\n if rank == False:\\n bnd_label = r\\\"$p^{\\\\ast \\\\ast}(\\\\lambda) + \\\\lambda(r + 1)$\\\"\\n else:\\n bnd_label = r\\\"$p^{\\\\ast \\\\ast}(\\\\lambda) + \\\\lambda(r + 1) + \\\\zeta$\\\"\\n\\n if rank == False:\\n bnd = [bd + l * (r + offset) for bd, l in zip(bidual, lmbdas)]\\n else:\\n # this is very confusing, but the code is set up such that the 3rd\\n # argument (lmbdas) is the one that varies, in this case we are\\n # letting the rank vary from 1,m so we artifically let lmbdas\\n # bet this and set r to be the value of l0 penalty\\n\\n bnd = [bd + r * (l + offset) for bd, l in zip(bidual, lmbdas)]\\n\\n xvals = lmbdas\\n\\n return xvals, bnd, bnd_label\",\n \"def sp_solve ( fun , xmin , xmax , C = 0 , args = () ) :\\n ##\\n if iszero ( C ) :\\n return findroot ( fun , xmin , xmax , args = args )\\n ##\\n func = lambda x , *a : fun(x,*a)-C\\n return findroot ( func , xmin , xmax , args = args )\",\n \"def find_optimal_strategy(prices, max_position=3, cost_per_trade=0.02):\\n buy_price = np.maximum(prices.bid_price, prices.ask_price).values\\n sell_price = np.minimum(prices.bid_price, prices.ask_price).values\\n\\n account = np.full((prices.shape[0] + 1, 2 * max_position + 3), -np.inf)\\n account[0, max_position + 1] = 0\\n\\n actions = np.empty((prices.shape[0], 2 * max_position + 3), dtype=int)\\n\\n for i in range(prices.shape[0]):\\n for j in range(1, account.shape[1] - 1):\\n buy = account[i, j - 1] - cost_per_trade - buy_price[i]\\n sell = account[i, j + 1] - cost_per_trade + sell_price[i]\\n hold = account[i, j]\\n if buy > sell and buy > hold:\\n account[i + 1, j] = buy\\n actions[i, j] = 1\\n elif sell > buy and sell > hold:\\n account[i + 1, j] = sell\\n actions[i, j] = -1\\n else:\\n account[i + 1, j] = hold\\n actions[i, j] = 0\\n\\n pnl = account[-1, 1:-1] + (np.arange(-max_position, max_position + 1) *\\n prices.market_price.iloc[-1])\\n j = np.argmax(pnl) + 1\\n optimal_sequence = []\\n for i in reversed(range(actions.shape[0])):\\n optimal_sequence.append(actions[i, j])\\n j -= actions[i, j]\\n optimal_sequence = np.array(list(reversed(optimal_sequence)))\\n\\n return optimal_sequence, np.max(pnl) / optimal_sequence.size\",\n \"def test_curve_apply():\\n c = Curve(data=data_num)\\n c2 = c.apply(window_length=3)\\n c3 = c.apply(window_length=3, func1d=np.min)\\n\\n assert c2.df.iloc[0][0] - 4.491228070175438 < 0.0001\\n assert c3.df.iloc[0][0] - 1 < 0.0001\",\n \"def the_function(interval):\\n if math.ceil(interval.upper) % 2:\\n return interval * type(interval).closed(\\n fractions.Fraction(3, 2),\\n fractions.Fraction(3, 2)\\n )\\n else:\\n return interval * type(interval).closed(\\n fractions.Fraction(1, 2),\\n fractions.Fraction(1, 2)\\n )\",\n \"def overlap_coefficient(input_adj):\\n adj = input_adj.copy()\\n d = np.diagonal(adj)\\n deg_dict = dict(zip(adj.columns, d))\\n \\n edges = get_upper_edges(adj, sorted=False)\\n df = pd.DataFrame(edges, columns=['weight'])\\n df['deg_A'] = df.index.map(lambda x: deg_dict[x[0]])\\n df['deg_B'] = df.index.map(lambda x: deg_dict[x[1]])\\n df['min_deg'] = df[['deg_A','deg_B']].min(axis=1)\\n df['oc'] = df['weight']/df['min_deg']\\n\\n return df\",\n \"def bracket(iterable, origin, interval_size, already_sorted=False, intervals_right_closed=False, coalesce=False):\\r\\n if not already_sorted:\\r\\n sorted_indices, iterable = zip(*sorted([(i, v) for i, v in enumerate(iterable)], key=operator.itemgetter(1)))\\r\\n \\r\\n brackets = []\\r\\n bracket_indices = []\\r\\n \\r\\n interval_offset = None\\r\\n interval_left = None\\r\\n interval_right = None\\r\\n \\r\\n for x in iterable:\\r\\n if interval_offset is None or x - interval_left >= interval_size:\\r\\n new_interval_offset = (x - origin) // interval_size\\r\\n new_interval_left = origin + new_interval_offset * interval_size\\r\\n \\r\\n if intervals_right_closed and x == new_interval_left:\\r\\n new_interval_offset -= 1\\r\\n new_interval_left -= interval_size\\r\\n \\r\\n if coalesce and (interval_offset is not None) and (new_interval_left <= brackets[-1].interval.right):\\r\\n interval_right = new_interval_left + interval_size\\r\\n brackets[-1].interval = brackets[-1].interval.replace_right(interval_right)\\r\\n elif interval_offset is None or new_interval_offset != interval_offset:\\r\\n interval_offset = new_interval_offset\\r\\n interval_left = new_interval_left\\r\\n interval_right = interval_left + interval_size\\r\\n brackets.append(\\r\\n Bracket(thalesians.tsa.intervals.Interval(interval_left,\\r\\n interval_right,\\r\\n not intervals_right_closed,\\r\\n intervals_right_closed),\\r\\n interval_offset))\\r\\n \\r\\n bracket_indices.append(len(brackets) - 1)\\r\\n \\r\\n if not already_sorted:\\r\\n new_bracket_indices = [None] * len(bracket_indices)\\r\\n for i in range(len(bracket_indices)):\\r\\n new_bracket_indices[sorted_indices[i]] = bracket_indices[i]\\r\\n bracket_indices = new_bracket_indices\\r\\n \\r\\n return brackets, bracket_indices\",\n \"def bisect(\\n f: Callable,\\n a: Array,\\n b: Array,\\n args: Tuple = (),\\n xtol: float = 1e-7,\\n ftol: float = 1e-7,\\n maxiter: int = 100,\\n full_output: bool = False,\\n range_check: bool = True,\\n) -> Union[Array, dict]:\\n\\n fa = f(*((a,) + args))\\n fb = f(*((b,) + args))\\n if range_check and snp.any(snp.sign(fa) == snp.sign(fb)):\\n raise ValueError(\\\"Initial bisection range does not bracket zero.\\\")\\n\\n for numiter in range(maxiter):\\n c = (a + b) / 2.0\\n fc = f(*((c,) + args))\\n fcs = snp.sign(fc)\\n a = snp.where(snp.logical_or(snp.sign(fa) * fcs == 1, fc == 0.0), c, a)\\n b = snp.where(snp.logical_or(fcs * snp.sign(fb) == 1, fc == 0.0), c, b)\\n fa = f(*((a,) + args))\\n fb = f(*((b,) + args))\\n xerr = snp.max(snp.abs(b - a))\\n ferr = snp.max(snp.abs(fc))\\n if xerr <= xtol and ferr <= ftol:\\n break\\n\\n idx = snp.argmin(snp.stack((snp.abs(fa), snp.abs(fb))), axis=0)\\n x = snp.choose(idx, (a, b))\\n if full_output:\\n r = x, {\\\"iter\\\": numiter, \\\"xerr\\\": xerr, \\\"ferr\\\": ferr, \\\"a\\\": a, \\\"b\\\": b}\\n else:\\n r = x\\n return r\",\n \"def selecting_a_representative_for_an_interval(begin, end, the_set):\\n save_tuple = None\\n the_min = float('inf')\\n for t in the_set:\\n if begin <= t[0] <= end:\\n if t[1] < the_min:\\n save_tuple = t\\n the_min = t[1]\\n\\n return save_tuple\",\n \"def eval_strategy_range(make_strategy, lower_bound, upper_bound):\\r\\n best_value, best_win_rate = 0, 0\\r\\n value = lower_bound\\r\\n while value <= upper_bound:\\r\\n strategy = make_strategy(value)\\r\\n win_rate = compare_strategies(strategy)\\r\\n print('Win rate against the baseline using', value, 'value:', win_rate)\\r\\n if win_rate > best_win_rate:\\r\\n best_win_rate, best_value = win_rate, value\\r\\n value += 1\\r\\n return best_value\",\n \"def find_instruments_in_range(self, df, strategy_range, posi):\\n sub = df[(df.strike >= min(strategy_range)) & (df.strike <= max(strategy_range))]#.head(self.allowed_position_size)\\n if 'call' in posi:\\n return sub[(sub.strike == min(sub.strike))]\\n else:\\n return sub[(sub.strike == max(sub.strike))]\",\n \"def alice(\\n partner1_salary_compound_rate: float,\\n partner1_salary_plateau: float,\\n partner2_salary_compound_rate: float,\\n partner2_salary_plateau: float,\\n base_spending: float,\\n spending_luxury_compound_rate: float,\\n rrsp_interest_rate: float,\\n tfsa_interest_rate: float,\\n):\\n\\n ruleset_func = ruleset.get_couple_ruleset(\\n salary_rules.get_compound_plateau(\\n partner1_salary_compound_rate, partner1_salary_plateau\\n ),\\n salary_rules.get_compound_plateau(\\n partner2_salary_compound_rate, partner2_salary_plateau\\n ),\\n couple_spending_rules.get_luxury_over_basic(\\n base_spending, spending_luxury_compound_rate\\n ),\\n couple_savings_rules.get_equalizing_rrsp_only_split(),\\n rrsp_interest_rate,\\n tfsa_interest_rate,\\n )\\n\\n return ruleset_func\",\n \"def _findBucket(self, node):\\n for bucket in buckets:\\n if bucket.inRange(node):\\n return bucket\\n #if bucket.low <= node and node <= bucket.high:\\n # return bucket\\n return None\",\n \"def calcBRange(c,n=10):\\n \\n bMin = -abs(c)/2.0 \\n bMax = abs(c)/2.0 \\n return np.linspace(bMin,bMax,n)\",\n \"def golden(func, args=(), brack=None, tol=1.e-4, full_output=0):\\n\\tif brack is None:\\n\\t\\txa,xb,xc,fa,fb,fc,funcalls = bracket(func, args=args)\\n\\telif len(brack) == 2:\\n\\t\\txa,xb,xc,fa,fb,fc,funcalls = bracket(func, xa=brack[0], xb=brack[1], args=args)\\n\\telif len(brack) == 3:\\n\\t\\txa,xb,xc = brack\\n\\t\\tif (xa > xc): # swap so xa < xc can be assumed\\n\\t\\t\\tdum = xa; xa=xc; xc=dum\\n\\t\\tassert ((xa < xb) and (xb < xc)), \\\"Not a bracketing interval.\\\"\\n\\t\\tfa = apply(func, (xa,)+args)\\n\\t\\tfb = apply(func, (xb,)+args)\\n\\t\\tfc = apply(func, (xc,)+args)\\n\\t\\tassert ((fb<fa) and (fb < fc)), \\\"Not a bracketing interval.\\\"\\n\\t\\tfuncalls = 3\\n\\telse:\\n\\t\\traise ValueError, \\\"Bracketing interval must be length 2 or 3 sequence.\\\"\\n\\n\\t_gR = 0.61803399\\n\\t_gC = 1.0-_gR\\n\\tx3 = xc\\n\\tx0 = xa\\n\\tif (abs(xc-xb) > abs(xb-xa)):\\n\\t\\tx1 = xb\\n\\t\\tx2 = xb + _gC*(xc-xb)\\n\\telse:\\n\\t\\tx2 = xb\\n\\t\\tx1 = xb - _gC*(xb-xa)\\n\\tf1 = apply(func, (x1,)+args)\\n\\tf2 = apply(func, (x2,)+args)\\n\\tfuncalls += 2\\n\\twhile (abs(x3-x0) > tol*(abs(x1)+abs(x2))):\\n\\t\\tif (f2 < f1):\\n\\t\\t\\tx0 = x1; x1 = x2; x2 = _gR*x1 + _gC*x3\\n\\t\\t\\tf1 = f2; f2 = apply(func, (x2,)+args)\\n\\t\\telse:\\n\\t\\t\\tx3 = x2; x2 = x1; x1 = _gR*x2 + _gC*x0\\n\\t\\t\\tf2 = f1; f1 = apply(func, (x1,)+args)\\n\\t\\tfuncalls += 1\\n\\tif (f1 < f2):\\n\\t\\txmin = x1\\n\\t\\tfval = f1\\n\\telse:\\n\\t\\txmin = x2\\n\\t\\tfval = f2\\n\\tif full_output:\\n\\t\\treturn xmin, fval, funcalls\\n\\telse:\\n\\t\\treturn xmin\",\n \"def find_combination(self, age, coef):\\n\\n # easy exit:\\n if (age < self.models[0].glb[iage]): return None\\n if (age > self.models[-1].glb[iage]): return None\\n\\n istart = 0\\n istop = len(self.models)-1\\n while (istop > istart+1):\\n itemp = (istop+istart)//2\\n if (age < self.models[itemp].glb[iage]):\\n istop = itemp\\n else:\\n istart = itemp\\n mu = (age - self.models[istart].glb[iage]) \\\\\\n / (self.models[istop].glb[iage] - self.models[istart].glb[iage])\\n return ((coef*(1.0-mu), self.models[istart].name), (coef*mu, self.models[istop].name))\",\n \"def find_B(self):\\n max_lb = 0\\n for arc in self.arcs():\\n lb = self.arc_info[arc[0]]['lower_bound']\\n max_lb = max(max_lb, lb)\\n n = len(self)\\n m = len(list(self.edges()))\\n return((m - n + 2)*max_lb)\",\n \"def make_initial_conditions(system, displacement, low):\\n C = sir.CurveSegment(system.sbar, system.imax, 0, system, 1)\\n C.s = C.s + displacement\\n s_inter, i_inter = C._curve_sol(low)\\n C = sir.CurveSegment(system.sbar, system.imax, 0, system, s_inter)\\n C.s = C.s + displacement\\n s0 = np.linspace(C.s[-1], 1)\\n i0 = np.array([i_inter]*len(s0))\\n s0 = np.concatenate((C.s, s0))\\n i0 = np.concatenate((C.i, i0))\\n return s0, i0\",\n \"def bucket_boundaries(self, bucket):\\n\\n if bucket < 0 or bucket >= self.total_buckets:\\n raise IndexError('bucket %d out of range' % bucket)\\n if bucket == self.total_buckets - 1:\\n return (self._lower_bounds[bucket], float('Inf'))\\n return (self._lower_bounds[bucket], self._lower_bounds[bucket + 1])\",\n \"def find_ab_params(spread, min_dist):\\n\\n def curve(x, a, b):\\n return 1.0 / (1.0 + a * x ** (2 * b))\\n\\n xv = np.linspace(0, spread * 3, 300)\\n yv = np.zeros(xv.shape)\\n yv[xv < min_dist] = 1.0\\n yv[xv >= min_dist] = np.exp(\\n -(xv[xv >= min_dist] - min_dist) / spread)\\n params, covar = curve_fit(curve, xv, yv)\\n return params[0], params[1]\",\n \"def lp_acent(A,b,c,x_0):\\n #Parameters\\n b = b.flatten()\\n c = c.flatten()\\n ALPHA = 0.01\\n BETA = 0.5\\n EPSILON = 1e-6\\n MAXITERS = 100\\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\\n print 'failed' \\n return 0\\n #m = len(b)\\n #n = len(x_0)\\n lambda_hist = []\\n x = x_0\\n for iter in range(MAXITERS):\\n # H = np.diag(1/np.power(x,3))\\n g = c-np.power(x,-1)\\n #print g.shape\\n #solving KKT system\\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\\n lambda_hist.append(lambdasqr/2)\\n if lambdasqr/2 <= EPSILON:\\n break\\n # backtracking line search\\n t = 1\\n # brin the point inside the domain\\n while np.min(x+t*dx)<=0:\\n t =BETA*t\\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\\n t = BETA*t\\n x = x+t*dx\\n if iter == MAXITERS:\\n print 'ERROR: MAXITERS reached'\\n else:\\n #plt.figure()\\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\\n return x,w,lambda_hist\",\n \"def calcrange(a4lim,data):\\r\\n a4range=N.intersect1d(N.where(data>a4lim[0])[0],N.where(data<a4lim[1])[0])\\r\\n return a4range\",\n \"def bisection(leaf, args):\\n #retrieve the lower/upper bound of given Most Promising Region\\n lb = leaf.lb\\n ub = leaf.ub\\n #find the dimension number of decision variabless\\n dimX = len(lb)\\n #determine the dimension that should be partitioned\\n dimID = (leaf.level + 1) % dimX \\n #determine the partition threshold\\n thr = (lb[dimID]+ub[dimID])/2.0\\n #create new lower/upper middle bound [lb,umb], [lmd,ub]\\n lmb,umb = [np.array([]) for i in range(2)]\\n for i in range(dimX):\\n lmb = np.append(lmb,[lb[i],thr][i==dimID])\\n umb = np.append(umb,[ub[i],thr][i==dimID])\\n subRegions = [[lb,umb],[lmb,ub]]\\n return {'parent':leaf,'thr':thr,'subRegions':subRegions}\",\n \"def basis_function(t, i, knots):\\n t_this = knots[i]\\n t_next = knots[i+1]\\n out = 1. if (t>=t_this and t<t_next) else 0.\\n return out\",\n \"def get_available_age_brackets_and_mapping():\\n brackets_dic = {}\\n dict_of_age_by_brackets = {}\\n\\n for num_agebrackets in [85, 18, 15, 12]:\\n brackets = []\\n if num_agebrackets == 85:\\n for i in range(84):\\n brackets.append([i])\\n brackets.append(np.arange(84, 101))\\n # # num_agebracket = 20 only works if you have an age distribution and\\n # # matrices that go in more detail than age 84+, so if you wanted\\n # # brackets of 85-89, 90-94, 95-100+, etc. it would be hard unless\\n # # you have those matrices (which we don't because of the European\\n # # matrices)\\n\\n # if num_agebrackets == 20:\\n # for i in range(19):\\n # brackets.append(np.arange(5 * i, 5 * (i + 1)))\\n # brackets.append(np.arange(95, 101))\\n if num_agebrackets == 18:\\n for i in range(16):\\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\\n brackets.append(np.arange(80, 84))\\n brackets.append(np.arange(84, 101))\\n if num_agebrackets == 15:\\n for i in range(14):\\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\\n brackets.append(np.arange(70, 101))\\n if num_agebrackets == 12:\\n for i in range(11):\\n brackets.append(np.arange(5 * i, 5 * (i + 1)))\\n brackets.append(np.arange(55, 101))\\n\\n age_by_brackets_dic = dict.fromkeys(np.arange(101), 0)\\n for n, b in enumerate(brackets):\\n for a in b:\\n age_by_brackets_dic[a] = n\\n\\n brackets_dic[num_agebrackets] = brackets\\n dict_of_age_by_brackets[num_agebrackets] = age_by_brackets_dic\\n\\n return brackets_dic, dict_of_age_by_brackets\",\n \"def _intersect(self, interval):\\n first = self.intervals.bisect_left(interval)\\n last = first\\n while first > 0 and \\\\\\n self.intervals[first - 1].upper > interval.lower:\\n first -= 1\\n while last < len(self.intervals) and \\\\\\n self.intervals[last].lower < interval.upper:\\n last += 1\\n return first, last\",\n \"def CI(x, alpha=0.05):\\n x = np.asarray(x)\\n xs = x.size\\n s = np.argsort(x)\\n c = int((alpha / 2) * xs)\\n return Interval(x[s[c-1]], x[s[xs-c]])\",\n \"def ofi(b, b_v, a, a_v):\\n b_, b_v_, a_, a_v_ = b.shift(1), b_v.shift(1), a.shift(1), a_v.shift(1)\\n ofi = i(b >= b_) * b_v - i(b <= b_) * b_v_ - i(a <= a_) * a_v + i(a >= a_) * a_v_\\n return ofi.fillna(0)\",\n \"def bucket_intervals(alpha, bucket_sizes, sigma):\\n heads = array(\\\"l\\\", [0] * sigma)\\n tails = array(\\\"l\\\", [0] * sigma)\\n j = 0\\n for i in range(len(alpha)):\\n heads[alpha[i]] = j\\n j += bucket_sizes[alpha[i]]\\n tails[alpha[i]] = j - 1\\n\\n # print_buckets(heads)\\n # print_buckets(tails)\\n return heads, tails\",\n \"def entry_condition(self, wage):\\n \\n #a. solve incumbant firm problem\\n pol_k, pol_n, pi, W = self.incumbant_firm(wage) \\n \\n # b. enter/stay in the market policy function\\n pol_enter=np.zeros((self.Ns,self.ntau)) #1 to enter/stay\\n \\n for i_s in range(self.Ns):\\n for j_t in range(self.ntau):\\n if W[i_s,j_t]>=0:\\n pol_enter[i_s,j_t]=1\\n \\n # c. present discounted value of a potential entrant\\n W_e = np.sum(np.sum( W * self.joint_pdf * pol_enter, axis=0) ) - self.ce\\n \\n return W_e, pol_k, pol_n, pi, W, pol_enter\",\n \"def f3_ab_b(self,a,b,c):\\n ans = (7.*(a*a - a*b*c) + (a*a/b)*(a*c - b))*self.g2(a,b,-c)/(a*a + b*b - 2.*a*b*c)\\n #print 'b_b:',ans,\\n return ans\",\n \"def budget(df, df_hist, harmonize_year=\\\"2015\\\"):\\n\\n harmonize_year = int(harmonize_year)\\n\\n df = df.set_axis(df.columns.astype(int), axis=\\\"columns\\\")\\n df_hist = df_hist.set_axis(df_hist.columns.astype(int), axis=\\\"columns\\\")\\n\\n data_years = df.columns\\n hist_years = df_hist.columns\\n\\n years = data_years[data_years >= harmonize_year]\\n\\n if data_years[0] not in hist_years:\\n hist_years = hist_years.insert(bisect(hist_years, data_years[0]), data_years[0])\\n df_hist = df_hist.reindex(columns=hist_years).interpolate(\\n method=\\\"slinear\\\", axis=1\\n )\\n\\n def carbon_budget(years, emissions):\\n # trapezoid rule\\n dyears = np.diff(years)\\n demissions = np.diff(emissions)\\n\\n budget = (dyears * (np.asarray(emissions)[:-1] + demissions / 2)).sum()\\n return budget\\n\\n solver = pyo.SolverFactory(\\\"ipopt\\\")\\n if solver.executable() is None:\\n raise RuntimeError(\\n \\\"No executable for the solver 'ipopt' found \\\"\\n \\\"(necessary for the budget harmonization). \\\"\\n \\\"Install from conda-forge or add to PATH.\\\"\\n )\\n\\n harmonized = []\\n\\n for region in df.index:\\n model = pyo.ConcreteModel()\\n\\n \\\"\\\"\\\"\\n PARAMETERS\\n \\\"\\\"\\\"\\n data_vals = df.loc[region, years]\\n hist_val = df_hist.loc[region, harmonize_year]\\n\\n budget_val = carbon_budget(data_years, df.loc[region, :])\\n\\n if data_years[0] < harmonize_year:\\n hist_in_overlap = df_hist.loc[region, data_years[0] : harmonize_year]\\n budget_val -= carbon_budget(hist_in_overlap.index, hist_in_overlap)\\n\\n \\\"\\\"\\\"\\n VARIABLES\\n \\\"\\\"\\\"\\n model.x = pyo.Var(years, initialize=0, domain=pyo.Reals)\\n x = np.array(\\n [model.x[y] for y in years]\\n ) # keeps pyomo VarData objects, ie. modelling vars not numbers\\n\\n \\\"\\\"\\\"\\n OBJECTIVE FUNCTION\\n \\\"\\\"\\\"\\n delta_years = np.diff(years)\\n delta_x = np.diff(x)\\n delta_m = np.diff(data_vals)\\n\\n def l2_norm():\\n return pyo.quicksum((delta_m / delta_years - delta_x / delta_years) ** 2)\\n\\n model.obj = pyo.Objective(expr=l2_norm(), sense=pyo.minimize)\\n\\n \\\"\\\"\\\"\\n CONSTRAINTS\\n \\\"\\\"\\\"\\n model.hist_val = pyo.Constraint(expr=model.x[harmonize_year] == hist_val)\\n\\n model.budget = pyo.Constraint(expr=carbon_budget(years, x) == budget_val)\\n\\n \\\"\\\"\\\"\\n RUN\\n \\\"\\\"\\\"\\n results = solver.solve(model)\\n\\n assert (results.solver.status == pyo.SolverStatus.ok) and (\\n results.solver.termination_condition == pyo.TerminationCondition.optimal\\n ), (\\n f\\\"ipopt terminated budget optimization with status: \\\"\\n f\\\"{results.solver.status}, {results.solver.termination_condition}\\\"\\n )\\n\\n harmonized.append([pyo.value(model.x[y]) for y in years])\\n\\n df_harm = pd.DataFrame(\\n harmonized,\\n index=df.index,\\n columns=years.astype(str),\\n )\\n\\n return df_harm\",\n \"def get_boundaries(outputs: list, inv_choices: str) -> list:\\n process_output = []\\n\\n def process_partition(partition):\\n boundaries = set()\\n if '-' in partition:\\n p = list(map(int, partition.split('-')))\\n boundaries.update({p[0] - 1, p[0], p[0] + 1, p[1] - 1, p[1], p[1] + 1})\\n\\n sort_bounds = sorted(boundaries)\\n inv_min_bound = [sort_bounds.pop(0), inv_choices]\\n inv_max_bound = [sort_bounds.pop(), inv_choices]\\n # Since it is sorted and starting from the lowest, only the lowest value need to be checked.\\n if not any(inv_min_bound[0] in sublist for sublist in process_output):\\n process_output.extend([inv_min_bound, inv_max_bound])\\n # Check if overlapping and if it is, check the answer (last item) and replace it if had the invalid choice.\\n for i in sort_bounds:\\n if any(i in sublist for sublist in process_output):\\n ind = get_index(process_output, i)\\n ans = process_output[ind][-1]\\n if ans == inv_choices:\\n process_output.pop(ind)\\n\\n process_output.append([i, output_answer])\\n\\n for part in outputs:\\n output_answer = part.pop()\\n if len(part) == 1 and isinstance(part, list):\\n\\n part = ''.join([p for p in part if isinstance(p, str)])\\n process_partition(part)\\n else:\\n logger.critical('LIMITATION: Not able to process more than 1 BVA variable per function!')\\n break\\n return process_output\",\n \"def first_order_conditions(geom: geometry.Geometry,\\n a: jnp.ndarray,\\n b: jnp.ndarray,\\n fg: jnp.ndarray):\\n grad_a, grad_b = grad_of_marginal_fit(\\n a, b, fg[:n], fg[n:], tau_a, tau_b, geom)\\n return jnp.concatenate((\\n jnp.where(a > 0,\\n marginal_a(geom, fg[:n], fg[n:]) - grad_a,\\n 0.0),\\n jnp.where(b > 0,\\n marginal_b(geom, fg[:n], fg[n:]) - grad_b,\\n 0.0)\\n ))\",\n \"def B(n, k):\\n assert 0 < k <= n\\n global lookup\\n for index_y in range(len(lookup), n + 1):\\n lookup.append([1])\\n min_value = min(index_y, k)\\n for index_x in range(min_value):\\n if index_x < len(lookup[index_y - 1]) - 1:\\n lookup[index_y].append(lookup[index_y - 1][index_x] + lookup[index_y - 1][index_x + 1])\\n else:\\n lookup[index_y].append(lookup[index_y - 1][index_x])\\n return lookup[n][k]\",\n \"def uniform_search(fun, a, b, E, n=3, counter=0):\\n if b - a < E:\\n return (b + a) / 2, counter\\n step = (b - a) / n\\n xn = a + step\\n min_x = a\\n min_f = fun(a)\\n while xn <= b:\\n counter += 1\\n f = fun(xn)\\n if f < min_f:\\n min_x = xn\\n min_f = f\\n xn += step\\n counter += 2\\n if fun(min_x - step) < fun(min_x + step):\\n return uniform_search(fun, min_x - step, min_x, E, n, counter)\\n return uniform_search(fun, min_x, min_x + step, E, n, counter)\",\n \"def compute_bounds(self, x=None, aux=None, C=None, method='backward', IBP=False, forward=False, \\n bound_lower=True, bound_upper=True, reuse_ibp=False,\\n return_A=False, needed_A_list=None, final_node_name=None, average_A=False, new_interval=None,\\n return_b=False, b_dict=None, reference_bounds=None, intermediate_constr=None, alpha_idx=None):\\n\\n # Several shortcuts.\\n method = method.lower() if method is not None else method\\n if method == 'ibp':\\n # Pure IBP bounds.\\n method = None\\n IBP = True\\n elif method == 'ibp+backward' or method == 'ibp+crown' or method == 'crown-ibp':\\n method = 'backward'\\n IBP = True\\n elif method == 'crown':\\n method = 'backward'\\n elif method == 'forward':\\n forward = True\\n elif method == 'forward+backward':\\n method = 'backward'\\n forward = True\\n elif method == \\\"crown-optimized\\\" or method == 'alpha-crown':\\n if bound_lower:\\n ret1 = self.get_optimized_bounds(x=x, IBP=False, C=C, method='backward', new_interval=new_interval, reference_bounds=reference_bounds,\\n bound_lower=bound_lower, bound_upper=False, return_A=return_A)\\n if bound_upper:\\n ret2 = self.get_optimized_bounds(x=x, IBP=False, C=C, method='backward', new_interval=new_interval, reference_bounds=reference_bounds,\\n bound_lower=False, bound_upper=bound_upper, return_A=return_A)\\n if bound_upper and bound_upper:\\n assert return_A is False\\n return ret1[0], ret2[1]\\n elif bound_lower:\\n return ret1\\n elif bound_upper:\\n return ret2\\n else:\\n raise NotImplementedError\\n\\n # If y in self.backward_node_pairs[x], then node y is visited when \\n # doing backward bound propagation starting from node x.\\n self.backward_from = dict([(node, []) for node in self._modules])\\n\\n if not bound_lower and not bound_upper:\\n raise ValueError('At least one of bound_lower and bound_upper in compute_bounds should be True')\\n A_dict = {} if return_A else None\\n\\n if x is not None:\\n self._set_input(*x, new_interval=new_interval)\\n\\n if IBP and method is None and reuse_ibp:\\n # directly return the previously saved ibp bounds\\n return self.ibp_lower, self.ibp_upper\\n root = [self._modules[name] for name in self.root_name]\\n batch_size = root[0].value.shape[0]\\n dim_in = 0\\n\\n for i in range(len(root)):\\n value = root[i].forward()\\n if hasattr(root[i], 'perturbation') and root[i].perturbation is not None: \\n root[i].linear, root[i].center, root[i].aux = \\\\\\n root[i].perturbation.init(value, aux=aux, forward=forward)\\n # This input/parameter has perturbation. Create an interval object.\\n if self.ibp_relative:\\n root[i].interval = Interval(\\n None, None, \\n root[i].linear.nominal, root[i].linear.lower_offset, root[i].linear.upper_offset)\\n else:\\n root[i].interval = \\\\\\n Interval(root[i].linear.lower, root[i].linear.upper, ptb=root[i].perturbation)\\n if forward:\\n root[i].dim = root[i].linear.lw.shape[1]\\n dim_in += root[i].dim\\n else:\\n if self.ibp_relative:\\n root[i].interval = Interval(\\n None, None, \\n value, torch.zeros_like(value), torch.zeros_like(value)) \\n else:\\n # This inpute/parameter does not has perturbation. \\n # Use plain tuple defaulting to Linf perturbation.\\n root[i].interval = (value, value)\\n root[i].forward_value = root[i].forward_value = root[i].value = root[i].lower = root[i].upper = value\\n\\n if self.ibp_relative:\\n root[i].lower = root[i].interval.lower\\n root[i].upper = root[i].interval.upper\\n else:\\n root[i].lower, root[i].upper = root[i].interval\\n\\n if forward:\\n self._init_forward(root, dim_in)\\n\\n final = self._modules[self.final_name] if final_node_name is None else self._modules[final_node_name]\\n logger.debug('Final node {}[{}]'.format(final, final.name))\\n\\n if IBP:\\n res = self._IBP_general(node=final, C=C)\\n if self.ibp_relative:\\n self.ibp_lower, self.ibp_upper = res.lower, res.upper\\n else:\\n self.ibp_lower, self.ibp_upper = res\\n\\n if method is None:\\n return self.ibp_lower, self.ibp_upper \\n\\n if C is None:\\n # C is an identity matrix by default \\n if final.output_shape is None:\\n raise ValueError('C is not provided while node {} has no default shape'.format(final.shape))\\n dim_output = int(np.prod(final.output_shape[1:]))\\n C = torch.eye(dim_output, device=self.device).unsqueeze(0).repeat(batch_size, 1, 1) # TODO: use an eyeC object here.\\n\\n # check whether weights are perturbed and set nonlinear for the BoundMatMul operation\\n for n in self._modules.values():\\n if isinstance(n, (BoundLinear, BoundConv, BoundBatchNormalization)):\\n n.nonlinear = False\\n for l_name in n.input_name[1:]:\\n node = self._modules[l_name]\\n if hasattr(node, 'perturbation'):\\n if node.perturbation is not None:\\n n.nonlinear = True\\n\\n # BFS to find out whether each node is used given the current final node\\n if final != self.last_final_node:\\n self.last_final_node = final\\n for i in self._modules.values():\\n i.used = False\\n final.used = True\\n queue = deque([final])\\n while len(queue) > 0:\\n n = queue.popleft()\\n for n_pre_name in n.input_name:\\n n_pre = self._modules[n_pre_name]\\n if not n_pre.used:\\n n_pre.used = True\\n queue.append(n_pre)\\n\\n for i in self._modules.values(): # for all nodes\\n if not i.used:\\n continue\\n if hasattr(i, 'nonlinear') and i.nonlinear:\\n for l_name in i.input_name:\\n node = self._modules[l_name]\\n # print('node', node, 'lower', hasattr(node, 'lower'), 'perturbed', node.perturbed, 'forward_value', hasattr(node, 'forward_value'), 'from_input', node.from_input)\\n if not hasattr(node, 'lower'):\\n assert not IBP, 'There should be no missing intermediate bounds when IBP is enabled'\\n if not node.perturbed and hasattr(node, 'forward_value'):\\n node.interval = node.lower, node.upper = \\\\\\n node.forward_value, node.forward_value\\n continue\\n # FIXME check that weight perturbation is not affected\\n # (from_input=True should be set for weights)\\n if not node.from_input and hasattr(node, 'forward_value'):\\n node.lower = node.upper = node.forward_value\\n continue\\n if forward:\\n l, u = self._forward_general(\\n node=node, root=root, dim_in=dim_in, concretize=True)\\n else:\\n # assign concretized bound for ReLU layer to save computational cost\\n # FIXME: Put ReLU after reshape will cause problem!\\n if (isinstance(node, BoundActivation) or isinstance(node, BoundTranspose)) and hasattr(\\n self._modules[node.input_name[0]], 'lower'):\\n node.lower = node.forward(self._modules[node.input_name[0]].lower)\\n node.upper = node.forward(self._modules[node.input_name[0]].upper)\\n elif isinstance(node, BoundReshape) and \\\\\\n hasattr(self._modules[node.input_name[0]], 'lower') and \\\\\\n hasattr(self._modules[node.input_name[1]], 'value'):\\n # Node for input value.\\n val_input = self._modules[node.input_name[0]]\\n # Node for input parameter (e.g., shape, permute)\\n arg_input = self._modules[node.input_name[1]]\\n node.lower = node.forward(val_input.lower, arg_input.value)\\n node.upper = node.forward(val_input.upper, arg_input.value)\\n else:\\n first_layer_flag = False\\n # This is the list of all intermediate layers where we need to refine.\\n if intermediate_constr is not None:\\n intermediate_beta_enabled_layers = [k for v in intermediate_constr.values() for k in v]\\n else:\\n intermediate_beta_enabled_layers = []\\n # Here we avoid creating a big C matrix in the first linear layer.\\n # Disable this optimization when we have beta for intermediate layer bounds.\\n if type(node) == BoundLinear or type(node) == BoundConv and node.name not in intermediate_beta_enabled_layers:\\n for l_pre in node.input_name:\\n if type(self._modules[l_pre]) == BoundInput:\\n node.lower, node.upper = self._IBP_general(node)\\n first_layer_flag = True\\n break\\n if not first_layer_flag:\\n reduced_dim = False # Only partial neurons (unstable neurons) are bounded.\\n unstable_idx = None\\n dim = int(np.prod(node.output_shape[1:]))\\n # FIXME: C matrix shape incorrect for BoundParams.\\n if (isinstance(node, BoundLinear) or isinstance(node, BoundMatMul)) and int(\\n os.environ.get('AUTOLIRPA_USE_FULL_C', 0)) == 0:\\n if intermediate_constr is not None and node.name in reference_bounds:\\n # If we are doing bound refinement and reference bounds are given, we only refine unstable neurons.\\n # For each batch element, we find the unstable neurons.\\n unstable_masks = torch.logical_and(reference_bounds[node.name][0] < 0, reference_bounds[node.name][1] > 0)\\n # unstable_masks = torch.ones(dtype=torch.bool, size=(batch_size, dim), device=self.device)\\n # For simplicity, merge unstable locations for all elements in this batch. TODO: use individual unstable mask.\\n unstable_locs = unstable_masks.sum(dim=0).bool()\\n # This is a 1-d indices, shared by all elements in this batch.\\n unstable_idx = unstable_locs.nonzero().squeeze()\\n # Number of unstable neurons after merging.\\n max_non_zero = unstable_locs.sum()\\n # Create an abstract C matrix, the unstable_idx are the non-zero elements in specifications for all batches.\\n newC = OneHotC([batch_size, max_non_zero, *node.output_shape[1:]], self.device, unstable_idx, None)\\n reduced_dim = True\\n # print(f'layer {node.name} total {dim} unstable {max_non_zero} newC {newC.shape}')\\n \\\"\\\"\\\"\\n newC = torch.eye(dim, device=self.device) \\\\\\n .unsqueeze(0).repeat(batch_size, 1, 1) \\\\\\n .view(batch_size, dim, *node.output_shape[1:])\\n print(f'creating new C {newC.size()}')\\n if int(os.environ.get('USE_EYE_C', 0)) == 1:\\n newC = eyeC([batch_size, dim, *node.output_shape[1:]], self.device)\\n \\\"\\\"\\\"\\n else:\\n newC = eyeC([batch_size, dim, *node.output_shape[1:]], self.device)\\n elif (isinstance(node, BoundConv) or isinstance(node,\\n BoundBatchNormalization)) and node.mode == \\\"patches\\\":\\n # import pdb; pdb.set_trace()\\n # Here we create an Identity Patches object \\n newC = Patches(None, 1, 0,\\n [batch_size, node.output_shape[-2] * node.output_shape[-1],\\n node.output_shape[-3], node.output_shape[-3], 1, 1], 1)\\n elif isinstance(node, BoundAdd) and node.mode == \\\"patches\\\":\\n num_channel = node.output_shape[-3]\\n L = node.output_shape[-2] * node.output_shape[-1]\\n patches = (torch.eye(num_channel, device=self.device)).unsqueeze(0).unsqueeze(\\n 0).unsqueeze(4).unsqueeze(5).expand(batch_size, L, num_channel, num_channel, 1, 1) # now [1 * 1 * in_C * in_C * 1 * 1]\\n newC = Patches(patches, 1, 0, [batch_size] + list(patches.shape[1:]))\\n else:\\n if intermediate_constr is not None and node.name in reference_bounds:\\n # If we are doing bound refinement and reference bounds are given, we only refine unstable neurons.\\n # For each batch element, we find the unstable neurons.\\n unstable_masks = torch.logical_and(reference_bounds[node.name][0] < 0, reference_bounds[node.name][1] > 0)\\n # Flatten the conv layer shape.\\n unstable_masks = unstable_masks.view(unstable_masks.size(0), -1)\\n # unstable_masks = torch.ones(dtype=torch.bool, size=(batch_size, dim), device=self.device)\\n # For simplicity, merge unstable locations for all elements in this batch. TODO: use individual unstable mask.\\n unstable_locs = unstable_masks.sum(dim=0).bool()\\n # This is always a 1-d indices. For conv layers it's flattened.\\n unstable_idx = unstable_locs.nonzero().squeeze()\\n # Number of unstable neurons after merging.\\n max_non_zero = unstable_locs.sum()\\n # Create a C matrix.\\n newC = torch.zeros([1, max_non_zero, dim], device=self.device)\\n # Fill the corresponding elements to 1.0\\n newC[0, torch.arange(max_non_zero), unstable_idx] = 1.0\\n newC = newC.repeat(batch_size, 1, 1).view(batch_size, max_non_zero, *node.output_shape[1:])\\n reduced_dim = True\\n # print(f'layer {node.name} total {dim} unstable {max_non_zero} newC {newC.size()}')\\n else:\\n if dim > 1000:\\n warnings.warn(f\\\"Creating an identity matrix with size {dim}x{dim} for node {node}. This may indicate poor performance for bound computation. If you see this message on a small network please submit a bug report.\\\", stacklevel=2)\\n newC = torch.eye(dim, device=self.device) \\\\\\n .unsqueeze(0).repeat(batch_size, 1, 1) \\\\\\n .view(batch_size, dim, *node.output_shape[1:])\\n # print('Creating new C', type(newC), 'for', node)\\n if False: # TODO: only return A_dict of final layer\\n _, _, A_dict = self._backward_general(C=newC, node=node, root=root,\\n return_A=return_A, A_dict=A_dict, intermedaite_constr=intermediate_constr)\\n else:\\n self._backward_general(C=newC, node=node, root=root, return_A=False, intermediate_constr=intermediate_constr, unstable_idx=unstable_idx)\\n\\n if reduced_dim:\\n # If we only calculated unstable neurons, we need to scatter the results back based on reference bounds.\\n new_lower = reference_bounds[node.name][0].detach().clone().view(batch_size, -1)\\n new_lower[:, unstable_idx] = node.lower.view(batch_size, -1)\\n node.lower = new_lower.view(batch_size, *node.output_shape[1:])\\n new_upper = reference_bounds[node.name][1].detach().clone().view(batch_size, -1)\\n new_upper[:, unstable_idx] = node.upper.view(batch_size, -1)\\n node.upper = new_upper.view(batch_size, *node.output_shape[1:])\\n # node.lower and node.upper (intermediate bounds) are computed in the above function.\\n # If we have bound references, we set them here to always obtain a better set of bounds.\\n if reference_bounds is not None and node.name in reference_bounds:\\n # Initially, the reference bound and the computed bound can be exactly the same when intermediate layer beta is 0. This will prevent gradients flow. So we need a small guard here.\\n if Check_against_base_lp:\\n if node.name == Check_against_base_lp_layer:\\n pass\\n # print(reference_bounds[node.name][0][1,0,0,3].item(), node.lower[1,0,0,3].item())\\n # node.lower = torch.max(reference_bounds[node.name][0] - 1e-5, node.lower)\\n # node.upper = torch.min(reference_bounds[node.name][1] + 1e-5, node.upper)\\n else:\\n # For LP checking, fix all other intermediate layer bounds.\\n node.lower = reference_bounds[node.name][0]\\n node.upper = reference_bounds[node.name][1]\\n else:\\n # Setting reference bounds are actually incorrect. Because the split constraints are computed using slightly\\n # different alpha (not the optimal), they can be slightly worse than original at the beginning.\\n # So we only update bounds to reference if they cross zero (split constraints).\\n node.lower = torch.max(reference_bounds[node.name][0] - 1e-5,\\n node.lower)\\n node.upper = torch.min(reference_bounds[node.name][1] + 1e-5,\\n node.upper)\\n \\\"\\\"\\\"\\n update_lower = reference_bounds[node.name][0] >= 0\\n node.lower[update_lower] = reference_bounds[node.name][0][update_lower]\\n update_upper = reference_bounds[node.name][0] <= 0\\n node.upper[update_upper] = reference_bounds[node.name][1][update_upper]\\n \\\"\\\"\\\"\\n\\n if method == 'backward':\\n # This is for the final output bound. No need to pass in intermediate layer beta constraints.\\n return self._backward_general(C=C, node=final, root=root, bound_lower=bound_lower, bound_upper=bound_upper,\\n return_A=return_A, needed_A_list=needed_A_list, average_A=average_A, A_dict=A_dict,\\n return_b=return_b, b_dict=b_dict, unstable_idx=alpha_idx)\\n elif method == 'forward':\\n return self._forward_general(C=C, node=final, root=root, dim_in=dim_in, concretize=True)\\n else:\\n raise NotImplementedError\",\n \"def Es_case_B(z, x, gamma):\\n \\n if z == 0 and x == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n #alp = alpha(z, x, beta2)\\n alp = alpha_exact_case_B_brentq(z, x, beta)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n\\n kap = 2*(alp - z)/beta\\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\\n \\n N1 = cos2a - (1+x)\\n N2 = (1+x)*sin2a - beta*kap\\n D = kap - beta*(1+x)*sin2a\\n \\n #print(N1, N2, D)\\n \\n # SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\\n NSC = (sin2a - beta*kap *cos2a)/ (gamma**2-1) \\n \\n return (N1*N2)/D**3\\n #return (N1*N2 + NSC)/D**3\",\n \"def p_donate_ci(self, a=5, alpha =1, beta=1):\\n ones = self.counts[1:]\\n zeros = self.counts[0]\\n dist = beta_dist(ones + alpha, zeros + beta, 10000)\\n lower_bound = np.percentile(dist, a / 2.0)\\n upper_bound = np.percentile(dist, 100 - a / 2.0)\\n mean = np.mean(dist)\\n return (lower_bound, self.p_donate, upper_bound)\",\n \"def findsubintervals (t ,x):\\n k, m = len(t), len(x)\\n if k<2:\\n return zeros(m,1)\\n else:\\n j = concatenate([t, x]).argsort()\\n i = nonzero(j >= k)\\n arr = arange(0,m)\\n arr = i - arr - 1\\n arr = arr[0]\\n return arr\",\n \"def findLinearFunction(data, x):\\n aData = []\\n bData = []\\n prevDs = ()\\n for ds in data:\\n if prevDs:\\n aData.append(findLinearA(prevDs[0], prevDs[1], ds[0], ds[1]))\\n prevDs = ds\\n if len(aData) > 1:\\n a = average(aData)\\n else:\\n return None\\n for ds in data:\\n bData.append(findLinearB(a, ds[0], ds[1]))\\n b = average(bData)\\n return makeLinearFunction(x, a, b)\",\n \"def find_span( knots, degree, x ):\\n # Knot index at left/right boundary\\n low = degree\\n high = 0\\n high = len(knots)-1-degree\\n\\n # Check if point is exactly on left/right boundary, or outside domain\\n if x <= knots[low ]: returnVal = low\\n elif x >= knots[high]: returnVal = high-1\\n else:\\n # Perform binary search\\n span = (low+high)//2\\n while x < knots[span] or x >= knots[span+1]:\\n if x < knots[span]:\\n high = span\\n else:\\n low = span\\n span = (low+high)//2\\n returnVal = span\\n\\n return returnVal\",\n \"def acq_max(ac, gp, ymax, restarts, bounds):\\n\\n x_max = bounds[:, 0]\\n ei_max = 0\\n\\n for i in range(restarts):\\n #Sample some points at random.\\n x_try = numpy.asarray([numpy.random.uniform(x[0], x[1], size=1) for x in bounds]).T\\n\\n #Find the minimum of minus the acquisition function\\n res = minimize(lambda x: -ac(x.reshape(1, -1), gp=gp, ymax=ymax), x_try, bounds=bounds, method='L-BFGS-B')\\n\\n #Store it if better than previous minimum(maximum).\\n if -res.fun >= ei_max:\\n x_max = res.x\\n ei_max = -res.fun\\n\\n return x_max\",\n \"def ab_finder(Func, Ind):\\n b = []\\n for i in range(len(Func)):\\n for j in range(i+1, len(Func)):\\n b.append(np.log(Func[i]/Func[j])/np.log(Ind[j]/Ind[i]))\\n print(b)\\n plt.plot([i for i in range(len(b))], b)\\n b = np.mean(b)\\n a = np.mean([Func[i]*(Ind[i]**b) for i in range(len(Func))])\\n return a, b\",\n \"def upper_bound_of_coefficient(f):\\n weight = 0\\n for c in f.itercoefficients():\\n weight += abs(c)**2\\n weight = arith1.floorsqrt(weight) + 1\\n degree = f.degree()\\n lc = f[degree]\\n m = (degree >> 1) + 1\\n bound = 1\\n for i in range(1, m):\\n b = combinatorial.binomial(m - 1, i) * weight + \\\\\\n combinatorial.binomial(m - 1, i - 1) * lc\\n if bound < b:\\n bound = b\\n return bound\",\n \"def find_approx(self, gamma):\\n if self.jumps != []:\\n # first we divide the jumps of the BSS into subarrays in each of which the subsequent jumps are closer to each other than \\\\gamma\\n jump_seq_list = identify_jump_subseq(self.jumps, gamma)\\n # jumps will store all jumps of the projection\\n jumps = []\\n # iteration over each separate subsequence\\n for jump_seq in jump_seq_list:\\n # if an array consists of only one jump there is nothing to project\\n if len(jump_seq) > 1:\\n # we initialize the DAG structure and find the shortest path in the graph which is equivalent to projecting in the given interval\\n graph = DAG(jump_seq, gamma)\\n shortestPathTuple = graph.shortestPath()\\n # we skip first and last element of the second entry of the shortestPathTuple since those are only auxiliary values specific to the graphs (-np.inf and np.inf); second entry of the shortestPathTuple is the set of jumps of the projection in the given interval\\n jumps.append(shortestPathTuple[1][1:-1])\\n else:\\n jumps.append(jump_seq)\\n else:\\n return BinaryStateSequence(first_value = self.first_value, jumps = [], time_horizon = self.time_horizon)\\n\\n return BinaryStateSequence(first_value = self.first_value, jumps = flatten_list(jumps), \\n time_horizon = self.time_horizon)\",\n \"def biseccion(func, a, b, tol=1e-4):\\n p = (a + b) / 2 \\n while np.fabs(func(p)) > tol:\\n p = (a + b) / 2 \\n if func(a) * func(p) < 0:\\n b = p\\n elif func(a) * func(p) > 0:\\n a = p\\n else:\\n return p\\n return p\",\n \"def bicgstab_iso(A, x, b, MVop, VVop, max_itr=500, atol=1E-14, rtol=1E-14):\\n r_prv = b - MVop(A, x)\\n \\n r0 = r_prv.copy()\\n \\n rho_prv = 1\\n alpha = 1\\n omega_prv = 1\\n \\n v_prv = sp.zeros_like(x)\\n p_prv = sp.zeros_like(x)\\n \\n for i in xrange(max_itr):\\n rho = sp.trace(sp.dot(r0, r_prv))\\n \\n beta = (rho / rho_prv) * (alpha / omega_prv)\\n \\n p = r_prv + beta * (p_prv - omega_prv * v_prv)\\n \\n v = MVop(A, p)\\n \\n alpha = rho / VVop(r0, v)\\n \\n s = r_prv - alpha * v\\n \\n t = MVop(A, s)\\n \\n omega = VVop(t, s) / VVop(t, t)\\n \\n x += alpha * p + omega * s\\n \\n #Test x\\n if sp.allclose(MVop(A, x), b, atol=atol, rtol=rtol):\\n break\\n \\n r_prv = s - omega * t\\n \\n rho_prv = rho\\n omega_prv = omega\\n \\n v_prv[:] = v\\n p_prv[:] = p\\n \\n convg = i < max_itr - 1\\n \\n return x, convg\",\n \"def _balance_scipy(self, data):\\n try:\\n from scipy.optimize import linprog\\n except ImportError:\\n raise ImportError(\\\"SciPy is required to balance systems\\\")\\n\\n c = -1 * np.ones(data['A_ub'].shape[1])\\n sol = linprog(c, **data)\\n assert sol.success\\n return sol.x\",\n \"def basis_generic(n, *, p, bound=1):\\r\\n if n == 0:\\r\\n return ((0,),) # \\r\\n if n == 1:\\r\\n return ((1,),)\\r\\n result = []\\r\\n \\r\\n # append P^{last} beta^{epsilon}\\r\\n for epsilon in [0,1]:\\r\\n # Without this lower bound edge case we lose the element (0, 1, 1) in degree 5.\\r\\n # I don't have a good explanation for what it means yet.\\r\\n lower_bound = bound + epsilon if bound > 1 else 1\\r\\n for last in range(lower_bound, 1 + (n // (2*(p - 1)))):\\r\\n remaining_degree = n - 2*(p-1)*last - epsilon\\r\\n basis_in_remaining_degree = basis_generic(remaining_degree, p=p, bound=p * last)\\r\\n for vec in basis_in_remaining_degree:\\r\\n result.append(vec + (last, epsilon))\\r\\n return tuple(result)\",\n \"def select_around_interval(string, beg, end, fst, snd):\\n assert 0 <= beg <= end <= len(string)\\n\\n # These edge cases should not yield a result\\n if beg == end == len(string) or beg == end == 0:\\n return\\n\\n match = expand_to_valid_structure(string, beg, end, fst, snd)\\n if match == None:\\n return None\\n nbeg, nend = match\\n #match1 = find_matching_pair(string, beg, end, fst, snd)\\n #match2 = find_matching_pair(string, max(0, end - 1), fst, snd)\\n #if match1 == None or match2 == None:\\n #return None\\n #nbeg, nend = max([match1, match2], key=interval_length)\\n\\n # If interval remains the same try selecting one level higher\\n if (beg, end) == (nbeg, nend):\\n if beg > 0:\\n return select_around_interval(string, beg - 1, end, fst, snd)\\n elif end < len(string):\\n return select_around_interval(string, beg, end + 1, fst, snd)\\n\\n # Decide whether to select exclusive or remain inclusive\\n if beg > nbeg + 1 or end < nend - 1:\\n # Select exclusive\\n nbeg += 1\\n nend -= 1\\n return Interval(nbeg, nend)\",\n \"def interval_intersect(b, a, d, c):\\n return (d <= a) and (b <= c) # int2 lower <= int1 upper AND int1 lower <= int2 upper\",\n \"def solve_eq(preswet,func):\\n\\n from numpy import sign,diff\\n\\n # Sorry to be annoying but I'm going to force you to use\\n # a monotonically increasing variable\\n #assert (sign(diff(preswet))==1).all(), \\\"Use a monotonically increasing abscissa\\\"\\n\\n # Identify changes in sign of function\\n dsign=sign(func)\\n isdiff=np.zeros(dsign.shape,dtype=bool)\\n isdiff[1:]=abs(diff(dsign)).astype(bool)\\n\\n # shift to get the value on the other side\\n # of the x-axis\\n shift=np.zeros(dsign.shape,dtype=bool)\\n shift[:-1]=isdiff[1:]; shift[-1]=isdiff[0]\\n\\n # solve by linear interpolation between \\n # values points\\n sols=np.zeros((isdiff.sum()))\\n stab=np.zeros((isdiff.sum()))\\n for ii in range(isdiff.sum()):\\n f0=func[isdiff][ii]\\n f1=func[shift][ii]\\n p0=preswet[isdiff][ii]\\n p1=preswet[shift][ii]\\n slope=(f1-f0)/(p1-p0)\\n sols[ii]=p0-f0/slope\\n stab[ii]=sign(slope)\\n\\n ### Debug with plots\\n #fig=plt.figure()\\n #ax=fig.add_subplot(111)\\n #ax.plot(preswet,func)\\n #ax.plot(sols,zeros(sols.shape),ls='',marker='o')\\n #ax.plot(preswet[isdiff],func[isdiff],ls='',marker='+',mew=2)\\n #ax.plot(preswet[shift],func[shift],ls='',marker='x',mew=2)\\n #ax.grid(True)\\n #show()\\n\\n return sols,stab\",\n \"def quanty_index(i,ang=2):\\n norb = 2*ang + 1\\n k = (i//(2*norb))*(2*norb)\\n if (i-k) < norb:\\n j = k + 2*(i-k)\\n else:\\n j = k + 2*((i-k)-norb) + 1\\n return j\",\n \"def get_boundary_position_of_index():\\n function = LegacyFunctionSpecification() \\n function.must_handle_array = True\\n for x in ['i','j','k']:\\n function.addParameter(x, dtype='i', direction=function.IN)\\n function.addParameter('index_of_boundary', dtype='i', direction=function.IN, default = 1)\\n for x in ['x','y','z']:\\n function.addParameter(x, dtype='d', direction=function.OUT)\\n function.addParameter('number_of_points', 'i', function.LENGTH) \\n function.result_type = 'i'\\n return function\",\n \"def alpha_exact_case_D(z, x, beta, lamb):\\n #beta = np.sqrt(beta2)\\n f = lambda a: a + 1/2 * (lamb - beta*sqrt(lamb**2 + x**2 + 4*(1+x)*sin(a)**2 + 2*lamb*sin(2*a))) - z\\n \\n res = scipy.optimize.root_scalar(f, bracket=(-1,1))\\n \\n return res.root\",\n \"def get_adl(adl_score,cog):\\n ranges = [(0),(1,2),(3,4),(5,6,7),(8,9),(10,11),(12,13),(14,15,16)]\\n modifier = [-2,-1,0,1,2,3,4,5]\\n #\\n found = True\\n while found:\\n for i,r in enumerate(ranges):\\n print(adl_score,range[i])\\n if adl_score in ranges[i]:\\n adl_score = adl_score+modifier[i]\\n found = False\\n break\\n return adl_score\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5546394","0.5514575","0.54493105","0.54006404","0.5219616","0.51849455","0.5173916","0.51624197","0.5160456","0.5154094","0.5153953","0.5153","0.5130451","0.5096638","0.5061676","0.5000963","0.49834117","0.49589533","0.49504474","0.4946693","0.49326152","0.49063364","0.48303807","0.48262146","0.48244995","0.48135385","0.48128518","0.4783525","0.47811946","0.47771418","0.47723174","0.47718725","0.47660416","0.473799","0.4737565","0.4734215","0.47324008","0.47314325","0.4727273","0.47227183","0.4721871","0.4714801","0.47070265","0.46934858","0.4692248","0.46894068","0.46832836","0.46738297","0.46731266","0.46660718","0.46644762","0.4655746","0.46385586","0.4637193","0.46349892","0.46340153","0.46324202","0.46245143","0.461901","0.46166924","0.46106067","0.46051234","0.460028","0.45993394","0.459841","0.4598048","0.4596674","0.45960817","0.45922083","0.45840508","0.45786342","0.45775416","0.45641637","0.45640942","0.45563766","0.45560977","0.45557836","0.45548216","0.45449805","0.45386395","0.4530112","0.45285207","0.45263514","0.45205504","0.45119795","0.4509131","0.4508618","0.45052776","0.45031187","0.4499033","0.44973534","0.44946608","0.4491825","0.44913548","0.44892275","0.44888607","0.4485202","0.44820204","0.44816843","0.44816163"],"string":"[\n \"0.5546394\",\n \"0.5514575\",\n \"0.54493105\",\n \"0.54006404\",\n \"0.5219616\",\n \"0.51849455\",\n \"0.5173916\",\n \"0.51624197\",\n \"0.5160456\",\n \"0.5154094\",\n \"0.5153953\",\n \"0.5153\",\n \"0.5130451\",\n \"0.5096638\",\n \"0.5061676\",\n \"0.5000963\",\n \"0.49834117\",\n \"0.49589533\",\n \"0.49504474\",\n \"0.4946693\",\n \"0.49326152\",\n \"0.49063364\",\n \"0.48303807\",\n \"0.48262146\",\n \"0.48244995\",\n \"0.48135385\",\n \"0.48128518\",\n \"0.4783525\",\n \"0.47811946\",\n \"0.47771418\",\n \"0.47723174\",\n \"0.47718725\",\n \"0.47660416\",\n \"0.473799\",\n \"0.4737565\",\n \"0.4734215\",\n \"0.47324008\",\n \"0.47314325\",\n \"0.4727273\",\n \"0.47227183\",\n \"0.4721871\",\n \"0.4714801\",\n \"0.47070265\",\n \"0.46934858\",\n \"0.4692248\",\n \"0.46894068\",\n \"0.46832836\",\n \"0.46738297\",\n \"0.46731266\",\n \"0.46660718\",\n \"0.46644762\",\n \"0.4655746\",\n \"0.46385586\",\n \"0.4637193\",\n \"0.46349892\",\n \"0.46340153\",\n \"0.46324202\",\n \"0.46245143\",\n \"0.461901\",\n \"0.46166924\",\n \"0.46106067\",\n \"0.46051234\",\n \"0.460028\",\n \"0.45993394\",\n \"0.459841\",\n \"0.4598048\",\n \"0.4596674\",\n \"0.45960817\",\n \"0.45922083\",\n \"0.45840508\",\n \"0.45786342\",\n \"0.45775416\",\n \"0.45641637\",\n \"0.45640942\",\n \"0.45563766\",\n \"0.45560977\",\n \"0.45557836\",\n \"0.45548216\",\n \"0.45449805\",\n \"0.45386395\",\n \"0.4530112\",\n \"0.45285207\",\n \"0.45263514\",\n \"0.45205504\",\n \"0.45119795\",\n \"0.4509131\",\n \"0.4508618\",\n \"0.45052776\",\n \"0.45031187\",\n \"0.4499033\",\n \"0.44973534\",\n \"0.44946608\",\n \"0.4491825\",\n \"0.44913548\",\n \"0.44892275\",\n \"0.44888607\",\n \"0.4485202\",\n \"0.44820204\",\n \"0.44816843\",\n \"0.44816163\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5270328"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":84676,"cells":{"query":{"kind":"string","value":"Compute the aggregate capital stock and employment, K and N FORWARD"},"document":{"kind":"string","value":"def CalculatePaths(self):\n agrid = self.agrid \n self.apath = array([0 for y in range(self.T)], dtype=float)\n self.cpath = array([0 for y in range(self.T)], dtype=float)\n self.npath = array([0 for y in range(self.T)], dtype=float)\n # generate each generation's asset, consumption and labor supply forward\n for y in range(self.T-1): # y = 0, 1,..., 58\n self.apath[y+1] = max(0,interp1d(agrid, self.a[y], kind='cubic')(self.apath[y]))\n if y >= self.W:\n self.cpath[y], self.npath[y] = (1+self.r)*self.apath[y] + self.b - self.apath[y+1], 0\n else:\n self.cpath[y], self.npath[y] = self.solve(self.apath[y], self.apath[y+1])\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\n # the oldest generation's consumption and labor supply\n self.cpath[self.T-1], self.npath[self.T-1] = (1+self.r)*self.apath[self.T-1]+self.b, 0\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])"},"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 calculate_industry_neutral_nway_return(df, name, sorts, cuts, long_bucket, short_bucket, ind_col='sic1', ret_col='ret'):\n df = df.copy()\n\n # n-way sort\n keys = ['time_idx', ind_col]\n for sort, cut in zip(sorts, cuts):\n df[sort] = df.groupby(keys, as_index=False)[sort].transform(lambda x: pd.qcut(x, cut, range(cut)))\n keys.append(sort)\n\n # calculate bucket returns\n port_ret = df.groupby(['time_idx', ind_col] + sorts, as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\n summary = port_ret.groupby(['time_idx'] + sorts, as_index=False)[[ret_col, 'permno']].apply(\n lambda x: pd.Series([np.average(x[ret_col], weights=x.permno), x.permno.sum()], index=['ret', 'avg count'])\n )\n\n hedged_bucket = summary.reset_index('time_idx').groupby('time_idx').apply(\n lambda x: pd.Series([\n (x.loc[long_bucket, 'ret'] - x.loc[short_bucket, 'ret']) / 2,\n (x.loc[long_bucket, 'avg count'] + x.loc[short_bucket, 'avg count']) / 2\n ], index=['ret', 'avg count'])\n )\n tmp = hedged_bucket.agg({'ret': ['mean', 'std'], 'avg count': 'mean'})\n hedged_bucket = pd.DataFrame({**{sorts[0]: ['hedged'],\n 'return': [tmp.loc['mean', 'ret']],\n 't stat': [tmp.loc['mean', 'ret'] / tmp.loc['std', 'ret']],\n 'avg count': [tmp.loc['mean', 'avg count']]}, **{x: '' for x in sorts[1:]}})\n\n summary = summary.groupby(sorts).agg({'ret': ['mean', 'std'], 'avg count': 'mean'}, axis=1)\n summary.columns = [\"_\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\n summary['t stat'] = summary.ret_mean / summary.ret_std\n summary = summary.drop('ret_std', axis=1).rename({'ret_mean': 'return', 'avg count_mean': 'avg count'}, axis=1)\n summary = summary.reset_index()[sorts + ['return', 't stat', 'avg count']]\n summary = pd.concat([summary, hedged_bucket], axis=0, sort=False)\n\n # calculate hedged returns\n agg = port_ret.set_index(sorts).groupby(['time_idx', ind_col]).apply(\n lambda x: pd.Series([\n (x.loc[long_bucket, ret_col] - x.loc[short_bucket, ret_col]) / 2, # to maintain unit leverage\n (x.loc[long_bucket, ret_col]) / 2, # division by 2 to match same leverage of the long side\n (x.loc[short_bucket, ret_col]) / 2, # division by 2 to match same leverage of the short side\n (x.loc[long_bucket, 'permno'] + x.loc[short_bucket, 'permno']) / 2\n ], index=['ret', 'long_ret', 'short_ret', 'count'])\n )\n hedged = agg.groupby(level=0).apply(lambda x: np.average(x.ret, weights=x['count']))\n long = agg.groupby(level=0).apply(lambda x: np.average(x.long_ret, weights=x['count']))\n short = agg.groupby(level=0).apply(lambda x: np.average(x.short_ret, weights=x['count']))\n\n # plot\n avg = hedged.rolling(4, min_periods=4).sum()\n fig = make_subplots(specs=[[{\"secondary_y\": True}]])\n fig.add_trace(go.Bar(y=avg, x=avg.index, name=name + ' Return'), secondary_y=False)\n fig.add_trace(go.Scatter(y=(1 + hedged).cumprod(), x=hedged.index, name=name + ' Equity'), secondary_y=True)\n fig.add_trace(go.Scatter(y=(1 + long).cumprod(), x=hedged.index, name=name + ' Long Equity'), secondary_y=True)\n fig.add_trace(go.Scatter(y=(1 + short).cumprod(), x=hedged.index, name=name + ' Short Equity'), secondary_y=True)\n fig.show()\n\n return {'name': name, 'equity': hedged, 'summary': summary, 'data': df}","def calculate_profit(self):","def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] is None:\n pass\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\n self.buys_made += 1\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\n self.shares_own = self.stock_quantity\n self.buys_made += 1\n else:\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\n self.final_capital = self.final_capital % data['Close'].iloc[i]\n #print(self.shares_own)\n\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n pass\n else:\n self.final_capital += self.shares_own * data['Close'].iloc[i]\n self.shares_own = 0\n self.sells_made +=1\n #Checar si es el momento mas alto o bajo de ganancias\n if self.shares_own == 0:\n if (self.highest_point is None\n or self.highest_point < self.final_capital):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > self.final_capital\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n else:\n if (self.highest_point is None\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n self.calcRealFinalCapital()\n self.calcDiferencePercentage()","def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\n total_capital = capital * leverage\n df = data\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\n lambda x: len(x))\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\n df['profit'] = df.eval('(sell-buy)*qty')\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\n df['net_profit'] = df.eval('profit - commission - slippage')\n return df","def IC(stock):\n return Invested_Book_Capital(stock)","def incumbant_firm(self, wage):\n \n \n \n # a. demand for capital (capital policy function)\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\n \n # b. demand of labor (labor policy function)\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\n \n # c. incumbant profit\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\n \n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\n W = pi / (1-self.rho)\n \n return pol_k, pol_n, pi, W","def aveVolumeCalc(ins, date):\n cal = ins.Currency().Calendar()\n enddate = cal.AdjustBankingDays(date, 0)\n startdate = cal.AdjustBankingDays(date, AVERAGING_PERIOD)\n\n prices=[]\n histprices = acm.FPrice.Select(\"instrument = %s and market = '%s' \\\n and day > '%s' and day <='%s'\" % \n (ins.Oid(), DAILY_MARKET, startdate, enddate))\n \n for price in histprices:\n settle = price.Settle()\n if settle >= 0:\n prices.append(settle)\n \n #upgrade 2013 fix for failure during run - acm.Math().AverageOf seems buggy\n try:\n avgprice = (sum(prices)/len(prices))\n except ZeroDivisionError:\n avgprice = 0\n \n #avgprice = acm.Math().AverageOf(prices, None)\n \n #Overwrite today's price if you find it \n newPrice = acm.FPrice.Select01(\"instrument = %s and market = '%s' and day = %s\" % \n (ins.Oid(), THREE_MONTH_MARKET, enddate),\n 'NaN')\n if not newPrice:\n newPrice = acm.FPrice()\n newPrice.Instrument(ins)\n newPrice.Day(enddate)\n newPrice.Market(THREE_MONTH_MARKET)\n newPrice.Currency(ins.Currency())\n\n newPrice.Settle(avgprice)\n try:\n newPrice.Commit()\n print 'INFO: %s price for %s was created on %s' %(THREE_MONTH_MARKET, ins.Name(), date)\n except Exception, err:\n print 'ERROR: %s price for %s did not commit: %s' %(THREE_MONTH_MARKET, ins.Name(), str(err))\n \n return newPrice","def _IC(df): # Balance\n # No adjustments for cash-flow and off-balance sheet yet\n return Invested_Book_Capital(df)","def calcAdl(self):\n adl = []\n for i,j in enumerate(self.stock_data['Close']):\n #Calculating money flow measure\n mfm_nom = ((j-self.stock_data['Low'][i])-(self.stock_data['High'][i]))\n mfm_deno = self.stock_data['High'][i]-self.stock_data['Low'][i]\n mfm = mfm_nom/mfm_deno\n #Calculating money flow volume\n mfv = mfm*self.stock_data['Volume'][i]\n #Calculating accumulated distributin line\n if not adl:\n print(mfm)\n adl.append(mfv)\n else:\n print(adl)\n adl.append(mfv+adl)\n def_dates, def_points, k = self.angle(self.dates, adl, self.type) \n return k","def calculate_hedeged_return_by_industry(df, factor, long, short, ind_col='sic1', ret_col='ret_1', ncuts=3):\n df = df.copy()\n\n # sorting\n df[factor] = df.groupby(['time_idx', ind_col], as_index=False)[factor].transform(lambda x: pd.qcut(x, ncuts, range(ncuts)))\n\n # calculate bucket returns\n port_ret = df.groupby(['time_idx', ind_col, factor], as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\n summary = port_ret.set_index(factor).groupby(['time_idx', ind_col], as_index=False).apply(\n lambda x: pd.Series([\n (x.loc[long, ret_col] - x.loc[short, ret_col]) / 2,\n (x.loc[long, 'permno'] + x.loc[short, 'permno'])\n ], index=['ret', 'count'])\n )\n\n summary = summary.groupby(level=1).agg({'ret': ['mean', 'std'], 'count': 'mean'})\n summary.columns = [\"_\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\n summary['t stat'] = summary.ret_mean / summary.ret_std\n summary = summary.rename({'ret_mean': 'return', 'count_mean': 'avg count'}, axis=1).drop('ret_std', axis=1)\n return summary.reset_index()[[ind_col, 'return', 't stat', 'avg count']]","def calc_annual_heating_savings (self):\n price = (self.diesel_prices + self.cd['heating fuel premium'])\n\n #~ self.base_heating_cost =\n\n #~ self.proposed_heating_cost =\n\n\n\n\n self.annual_heating_savings = self.reduction_diesel_used * price\n #~ print 'self.annual_heating_savings',self.annual_heating_savings","def stocks(values, maxSales):\n return 0","def capital_allocation_strategy(self, coins_to_invest, available_capital):\n coins_available_capital = 0\n used_capital = 0\n\n # Count positions which capital size is not equal to max capacity of investment\n total_positions_count = len(coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False])\n\n if total_positions_count > 0:\n\n # Divide all available capital equally by all the positions\n coins_available_capital = available_capital / total_positions_count\n\n # Stopping condition: If there are no more position not fully invested or coins_available_capital is smaller then min investment\n if total_positions_count == 0 or coins_available_capital < self.min_investment:\n return coins_to_invest\n\n # Iterate all coins to invest which are not fully invested\n for index, coins_prediction in coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False].copy().iterrows():\n\n coin_symbol = coins_prediction['coin_symbol']\n\n success, coin_current_volume = self.fetch_coins_24h_volumeto(coin_symbol)\n\n # exit if failed to fetch volume\n if not success:\n raise Exception\n\n if coin_current_volume == 0.0:\n logger.debug(\"Volume is zero. Not investing in: {}, at time: {}\".format(coin_symbol,\n TimeHelper.epoch_to_date_time(\n self.time_ticker.current_time)))\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\n continue\n\n # Volume boundary of the specific coin symbol at the specific time\n coins_max_capital_volume_boundary = self.max_percent_out_of_volume * coin_current_volume\n\n # If the volume boundary is smaller then available capital, then there is maximum capital in current position means = fully invested\n if coins_max_capital_volume_boundary < coins_available_capital:\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\n max_amount_to_invest_in_coin = coins_max_capital_volume_boundary\n else:\n max_amount_to_invest_in_coin = coins_available_capital\n\n # Risk indicator which decreases positions size according to probability\n capital_percent = self.percent_capital_according_to_probability(coins_prediction[Consts.PROB_POSITIVE_HEADER],\n coins_prediction[Consts.PROB_NEGATIVE_HEADER],\n coins_prediction['order_type'])\n\n current_capital_to_invest_in_position = capital_percent * max_amount_to_invest_in_coin\n\n # Add to capital to invest for current row\n coins_to_invest.loc[index, Consts.CAPITAL_TO_INVEST] = coins_to_invest.loc[\n index, Consts.CAPITAL_TO_INVEST] + current_capital_to_invest_in_position\n\n used_capital += current_capital_to_invest_in_position\n\n available_capital -= used_capital\n\n return self.capital_allocation_strategy(coins_to_invest, available_capital)","def market_income(df):\n return df.expanded_income - df[mdf.BENS].sum(axis=1)","def testAggregateCorrectly(self):\n\n\tscaler = pf.LinearScaler()\n\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(1, '1/gal'))\n\tesc = pf.NoEscalationEscalator()\n\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\n\n\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2012,01,01))\n\n\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(1, '1/(kW*hr)'))\n\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\n\n\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\n\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\n\n\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\n vals = [202320,202320,202320,202320]\n\tend_date = dt.datetime(2034,12,31)\n\tcosts = pf.VariableCosts()\n costs.add_variable_expense(vex1)\n costs.add_variable_expense(vex2)\n costs.build_vex_schedule(end_date)\n\t\n for d, v in zip(dates, vals):\n self.assertAlmostEqual(v, costs.schedule.loc[d, 'variable_costs'],4)","def find_max_profit(stock_prices,k):\n\teliminated_indices = set()\n\ttotal_profit = 0\n\n\t\n\tfor i in range(0,k):\n\t\tmax_profit = float('-inf')\n\t\tmin_price = float('inf')\n\t\t\n\t\tfor current_index,current_price in enumerate(stock_prices):\n\t\t\t# This condition takes care of note by making sure that \n\t\t\t# prices are not used in previous transaction.\n\t\t\tif current_index not in eliminated_indices:\n\t\t\t\tcurrent_profit = current_price - min_price\n\n\t\t\t\tif (current_profit > max_profit):\n\t\t\t\t\tbuying_price_index = min_price_index\n\t\t\t\t\tselling_price_index = current_index\n\t\t\t\t\tmax_profit = current_profit\n\n\t\t\t\t#min_price = min(min_price, current_price)\n\t\t\t\tif (current_price < min_price):\n\t\t\t\t\tmin_price = current_price\n\t\t\t\t\tmin_price_index = current_index\n\n\n\t\t# This for loop is to take care of Note\n\t\tfor i in range(buying_price_index,selling_price_index+1):\n\t\t\teliminated_indices.add(i)\n\n\t\ttotal_profit += max_profit\n\t\tprint('buying_price_index :',buying_price_index)\n\t\tprint(\"selling_price_index :\",selling_price_index)\n\n\treturn total_profit","def calculate_gamma(self):\n result = self.result\n # scaler = preprocessing.StandardScaler()\n # train_minmax = scaler.fit_transform(result)\n # st_rho, st_delta = train_minmax[:, 0], train_minmax[:, 1]\n # self.gamma = (st_delta + st_rho) / 2\n self.gamma = result[:, 0] * result[:, 1]\n self.gamma_des_index = np.argsort(-self.gamma)","def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):","def backtest_portfolio(self):\n self.rank=dict()\n self.accuracy=dict()\n portfolio = dict()\n \n for algo in self.algos:\n portfolio[algo]=pd.DataFrame(index=self.positions.index)\n self.pos_diff=dict()\n self.pos_diff[algo] = self.positions[algo].diff()\n \n portfolio[algo]['price_diff'] = self.bars['Close']-self.bars['Open']\n #portfolio['price_diff'][0:5] = 0.0\n portfolio[algo]['profit'] = self.positions[algo] * portfolio[algo]['price_diff']\n portfolio[algo]['total'] = self.initial_capital + portfolio[algo]['profit'].cumsum()\n portfolio[algo]['returns'] = portfolio[algo]['total'].pct_change()\n d=np.array(portfolio[algo]['profit']).copy()\n d[d>0]=1\n d[d<0]=0\n d[np.array(self.positions[algo])==0]=1\n for i in np.arange(1,len(d)+1):\n c=float(sum(d[0:i]))/(i)\n d[i-1]=c\n portfolio[algo]['accuracy']=d\n self.rank[algo]=float(portfolio[algo]['total'][-1] - portfolio[algo]['total'][0])\n self.returns=portfolio\n c=np.array(self.returns[algo]['profit'])\n c[c>0]=1\n c[c<0]=0\n c[np.array(self.positions[algo])==0]=1\n accuracy=round(float(c.sum())/len(c),2)*self.rank[algo]\n self.accuracy[algo]=accuracy\n #self.ranking= sorted(self.rank.items(), key=operator.itemgetter(1), reverse=True)\n self.ranking= sorted(self.accuracy.items(), key=operator.itemgetter(1))\n self.ready=True\n return (portfolio, self.rank, self.ranking)","def testAggregateDetailedCorrectly(self):\n\tscaler = pf.LinearScaler()\n\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\n\tesc = pf.NoEscalationEscalator()\n\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\n\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\n\n\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\n\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\n\n\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\n\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\n\n\n\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\n \n\tcosts = pf.VariableCosts()\n costs.add_variable_expense(vex1)\n costs.add_variable_expense(vex2)\n\tcosts.detailed = True\n\tend_date = dt.datetime(2034,12,31)\n costs.build_vex_schedule(end_date)\n\t\n for d in dates:\n self.assertTrue((vex1.schedule['variable_consumption'] == costs.schedule['Electricity_variable_consumption']).all())\n\t self.assertTrue((vex1.schedule['variable_costs'] == costs.schedule['Electricity_variable_costs']).all())\n\t self.assertTrue((vex2.schedule['variable_consumption'] == costs.schedule['Biomass_variable_consumption']).all())\n\t self.assertTrue((vex2.schedule['variable_costs'] == costs.schedule['Biomass_variable_costs']).all())","def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\n if not self.dates:\n self.dates = ['2010-01-01', '2012-12-31']\n self.load_data()\n\n num_months = len(self.df_all)\n first_purchase = True\n result = {}\n baseline_result = {}\n self.baseline_values = [0]\n self.update_values = [0]\n months = []\n\n # Define dataframe to save output data \n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\n self.opt_results_df = pd.DataFrame(columns=headers)\n row = []\n\n self.price_df = pd.DataFrame(columns=self.stocks)\n\n # Initialize the plot\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\n plt.xticks(list(range(0, num_months, 2)), \n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\n plt.locator_params(axis='x', nbins=num_months/2)\n plt.plot(list(range(0, num_months)), [0]*(num_months), \n color='red', label=\"Break-even\", linewidth=0.5)\n\n for i in range(3, num_months):\n\n # Look at just the data up to the current month\n df = self.df_all.iloc[0:i+1,:].copy()\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\n print(\"\\nDate:\", df.last_valid_index())\n months.append(df.last_valid_index().date()) \n\n if first_purchase:\n budget = self.budget\n initial_budget = self.budget\n baseline_shares = (budget / baseline_df_current.iloc[-1])\n baseline_result = {self.baseline[0]: baseline_shares} \n else:\n # Compute profit of current portfolio\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \n self.update_values.append(budget - initial_budget)\n\n # Compute profit of fund portfolio\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \n for s in self.baseline]) \n self.baseline_values.append(fund_value - initial_budget)\n\n self.budget = budget \n\n self.load_data(df=df)\n\n self.price_df.loc[i-2] = list(self.price.values)\n\n # Output for user on command-line and plot\n update_values = np.array(self.update_values, dtype=object)\n baseline_values = np.array(self.baseline_values, dtype=object)\n plt.plot(range(3, i+1), update_values, \n color='blue', label=\"Optimized portfolio\")\n plt.plot(range(3, i+1), baseline_values, \n color='gray', label=\"Fund portfolio\", linewidth=0.5)\n \n if first_purchase:\n plt.legend(loc=\"lower left\")\n plt.title(\"Start: {start}, End: {end}\".format\\\n (start=self.df_all.first_valid_index().date(), \n end=self.df_all.last_valid_index().date()))\n\n plt.savefig(\"portfolio.png\")\n plt.pause(0.05)\n \n # Making solve run\n if self.model_type == 'DQM':\n print(f\"\\nMulti-Period DQM Run...\")\n \n self.build_dqm()\n self.solution['DQM'] = self.solve_dqm()\n result = self.solution['DQM']\n else:\n print(f\"\\nMulti-Period CQM Run...\")\n\n # Set budget to 0 to enforce that portfolio is self-financing \n if self.t_cost and not first_purchase:\n self.budget = 0 \n\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \n min_return=min_return,\n init_holdings=init_holdings)\n result = self.solution['CQM']\n init_holdings = result['stocks']\n\n # Print results to command-line\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\n returns = result['return']\n variance = result['risk'] \n\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\n [result['stocks'][s] for s in self.stocks] + \\\n [variance, returns] \n self.opt_results_df.loc[i-2] = row \n \n first_purchase = False\n\n print(self.opt_results_df)\n print(f'\\nRun completed.\\n')\n\n plt.savefig(\"portfolio.png\")\n plt.show(block=False)","def get_stock_data(stock_name, ma=[],bollinger=[],exp_ma=[],ma_conv=[]):\n df = xl.parse(stock_name)\n #df.drop(['VOLUME'], 1, inplace=True)\n df.set_index('Date', inplace=True)\n \n # Renaming all the columns so that we can use the old version code\n df.rename(columns={'OPEN': 'Open', 'HIGH': 'High', 'LOW': 'Low', 'NUMBER_TICKS': 'Volume', 'LAST_PRICE': 'Adj Close'}, inplace=True)\n # Percentage change\n df['Pct'] = df['Adj Close'].pct_change()\n df.dropna(inplace=True)\n \n # Moving Average \n if ma != []:\n for moving in ma:\n df['{}ma'.format(moving)] = df['Adj Close'].rolling(window=moving).mean()\n # Bollinger \n if bollinger != []:\n def bbands(price, length=30, numsd=2):\n \"\"\" returns average, upper band, and lower band\"\"\"\n ave = pd.stats.moments.rolling_mean(price,length)\n sd = pd.stats.moments.rolling_std(price,length)\n upband = ave + (sd*numsd)\n dnband = ave - (sd*numsd)\n return np.round(upband,3), np.round(dnband,3)\n for moving in bollinger:\n df['{}bollingerup'.format(moving)],df['{}bollingerdown'.format(moving)] = bbands(df['Adj Close'], length=moving, numsd=2)\n \n # Exponential Moving Average \n if exp_ma != []:\n for moving in exp_ma:\n df['{}exp_ma'.format(moving)] = df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving).mean()\n \n # Moving Average Convergence \n if ma_conv!= []:\n for moving in ma_conv:\n df['{}ma_conv'.format(moving)] = df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving[0]).mean()-df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving[1]).mean()\n \n \n \n df.dropna(inplace=True)\n \n \n # Move Adj Close to the rightmost for the ease of training\n adj_close = df['Adj Close']\n df.drop(labels=['Adj Close'], axis=1, inplace=True)\n df = pd.concat([df, adj_close], axis=1)\n \n return df","def calc_annual_electric_savings (self):\n price = self.diesel_prices\n #TODO add rural v non rural\n self.base_generation_cost = self.electric_diesel_reduction * price\n\n\n self.proposed_generation_cost = self.maintenance_cost\n\n self.annual_electric_savings = self.base_generation_cost - \\\n self.proposed_generation_cost\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def stockdon2006(H,L,B):\n \n # Make sure parameters are double\n H = np.double(H)\n L = np.double(L)\n B = np.double(B)\n \n # Compute incident swash (equation 11) \n incSwash = 1.1 / 2 * 0.75 * B * (H*L)**0.5\n \n # Infragravity swash (Equation 12)\n igSwash = 1.1 / 2 * 0.06 * (H*L)**0.5\n \n # Compute R2% (Equation 19)\n setup = 1.1 * 0.35 * B * ((H * L)**0.5)\n swash = 1.1 / 2.0 * (H*L * (0.563 * B**2 + 0.004))**0.5 \n r2 = setup + swash\n \n return r2,setup,incSwash,igSwash","def example_reward(self,stock=None, action=None, current_date = None, products=None, orders=None, procurements=None):\n\n out = 0\n for key in stock:\n out += stock[key]\n return out * -1","def calc_annual_investment(devs, param):\n\n observation_time = param[\"observation_time\"]\n interest_rate = param[\"interest_rate\"]\n q = 1 + param[\"interest_rate\"]\n\n \n # Calculate capital recovery factor\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\n \n # Calculate annuity factor for each device\n for device in devs.keys():\n \n # Get device life time\n life_time = devs[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs[device][\"ann_factor\"] = (1 - res_value) * CRF \n else:\n devs[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF \n \n\n return devs","def analyse_rsi(stocks_data, oversold=25, overbought=85):\n print('\\n--- RSI ANALYSIS ---')\n for stock_symbol, df in stocks_data.items():\n rsi = find_rsi(df)\n min_rsi = oversold\n max_rsi = overbought\n for i in range(len(rsi[1])):\n r = rsi[1][i]\n if r < min_rsi:\n min_rsi = r\n elif r > max_rsi:\n max_rsi = r\n\n mins = []\n maxs = []\n for i in range(len(rsi[1])):\n r = rsi[1][i]\n if r <= min_rsi * 1.2:\n mins.append((rsi[0][i], rsi[1][i]))\n elif r >= max_rsi * 0.95:\n maxs.append((rsi[0][i], rsi[1][i]))\n\n if mins:\n print(stock_symbol)\n [print(m[0], m[1]) for m in mins]\n if maxs:\n print(stock_symbol)\n [print(m[0], m[1]) for m in maxs]","def mapk(actual, predicted, k):\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100","def calc_b_a(self, data):\n # Calculate our expected bid / ask\n mkt_bid = data['Bid'].values[-1]\n mkt_ask = data['Ask'].values[-1]\n last_trade = data['Trade Price'].values[-1]\n shares = self.calc_shares(data=data, last_trade=last_trade)\n\n k = (mkt_bid - mkt_ask) / (mkt_bid + mkt_ask) * -100\n\n our_bid = np.average(data['Bid'], weights=self.weights) - k\n our_ask = np.average(data['Ask'], weights=self.weights) + k\n\n self.portfoolio['Unrealized_PnL'] = self.portfoolio['Shares'] * last_trade - self.portfoolio['Avg_Cost'] * self.portfoolio['Shares']\n\n if shares == 0:\n # Skip 0 share orders\n pass\n elif abs(self.portfoolio['Cost']) >= self.max_pos * .75:\n # If position size at or above 95% of max, reduce position\n self.risk_control(bid=mkt_bid, ask=mkt_ask, last_trade=last_trade)\n\n elif our_bid >= mkt_bid:\n # Buy at bid\n self.trade(shares=shares, price=mkt_bid, last_trade=last_trade)\n elif our_ask <= mkt_ask:\n # Sell at ask\n self.trade(shares=-shares, price=mkt_ask, last_trade=last_trade)\n else:\n print('No order placed')","def calcul_buy_nb_action(self):\n nb_action = self.max_loss / (self.buy_price - self.stop_loss)\n invest = self.max_loss / (self.buy_price - self.stop_loss) * self.buy_price\n\n if invest > self.capital:\n return round(self.capital / self.buy_price, 9)\n else:\n return round(nb_action, 9)","def calc_annual_investment(devs, devs_dom, param):\n\n observation_time = param[\"observation_time\"]\n interest_rate = param[\"interest_rate\"]\n q = 1 + param[\"interest_rate\"]\n\n \n\n \n # Calculate capital recovery factor\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\n\n \n # Balancing Unit devices\n \n # Calculate annuity factor for each device\n for device in devs.keys():\n \n # Get device life time\n life_time = devs[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs[device][\"ann_factor\"] = (1 - res_value) * CRF \n else:\n devs[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF \n \n \n # Building devices\n \n for device in devs_dom.keys():\n \n # Get device life time\n life_time = devs_dom[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs_dom[device][\"ann_factor\"] = (1 - res_value) * CRF\n else: \n devs_dom[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF\n \n \n # Distribution devices (pipes, pumps)\n \n for dev in [\"pipe\", \"pump\"]: #PUmpe fehlt noch\n \n # Get device life time\n life_time = param[dev + \"_lifetime\"]\n \n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n param[\"ann_factor_\" + dev] = (1 - res_value) * CRF \n else:\n param[\"ann_factor_\" + dev] = ( 1 + invest_replacements - res_value) * CRF \n\n return devs","def _ebit(self):\n return self.net_income + self.tax_expense + self.interest_expense","def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\n m_over_N = float(m)/N \n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)","def cash_income(df):\n return (df.aftertax_income -\n (1 - tc.HOUSING_CASH_SHARE) * df.housing_ben -\n (1 - tc.MCAID_CASH_SHARE) * df.mcaid_ben -\n (1 - tc.MCARE_CASH_SHARE) * df.mcare_ben -\n (1 - tc.OTHER_CASH_SHARE) * df.other_ben -\n (1 - tc.SNAP_CASH_SHARE) * df.snap_ben -\n (1 - tc.SSI_CASH_SHARE) * df.ssi_ben -\n (1 - tc.TANF_CASH_SHARE) * df.tanf_ben -\n (1 - tc.VET_CASH_SHARE) * df.vet_ben -\n (1 - tc.WIC_CASH_SHARE) * df.wic_ben)","def Invested_Book_Capital(stock):\n df = _open_file(stock, 'balance')\n return _Invested_Book_Capital(df)","def stock_average(stock):\n closing_price=stock['Close']\n average=stats.mean(closing_price)\n return average","def envisaged_profit(self):\n profit = round(\n self.calcul_buy_nb_action() * self.take_profit - self.investment_price(),\n 2,\n )\n percent_profit = round(profit * 100 / self.capital, 2)\n return profit, percent_profit","def main():\n data = get_sales_data()\n sales_data = [int(num) for num in data]\n update_worksheet(sales_data, 'sales')\n new_surplus_data = calculate_surplus_sandwiches(sales_data)\n update_worksheet(new_surplus_data, 'surplus')\n list_of_last_five_sales = get_last_five_sales_entries()\n stock_data = get_average_sales(list_of_last_five_sales)\n update_worksheet(stock_data, 'stock')\n return stock_data","def backtest(self, strategy): \n \n # load data\n data = self.import_data(currency_ids = np.unique(self.signals.currency_id),\n start_date = self.start_date,\n end_date = self.end_date)\n \n # add cash and columns for currencies\n data[\"capital\"] = 0\n data[\"actions\"] = \"\" # should become a dictW \n data[\"description\"] = \"\"\n data[\"capital\"].iloc[0] = self.initial_capital\n data[\"worth_usd\"] = 0\n \n for currency_id in np.unique(self.signals.currency_id):\n data[currency_id + '_position'] = 0\n \n # a sell or buy can influence subsequent positions, so calculate iteratively\n for observation in range(1, len(data.index)):\n \n date = data.index[observation]\n \n # investment this period is zero\n investment_capital_period = 0\n \n # amount of currency_ids initially same as last period\n for currency_id in np.unique(self.signals.currency_id):\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] \n \n # at each point, compute size of each position (cash and currencies), and record actions\n if(data.index[observation] in self.signals.index):\n \n action_df = pd.DataFrame(columns=list([\"Currency\",\"NominalAmount\", \"CapitalAmount\"]))\n \n # could be multiple actions\n for index, action in self.signals.loc[date].iterrows(): \n currency_id = action['currency_id']\n signal = action['signal']\n \n # Buy\n if signal == 1:\n \n # buy for 10% currency_id\n investment_capital = data[\"capital\"].iloc[observation-1] * 0.10 \n\n # estimate how many coins\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\n \n # calculate exact capital needed\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\n investment_capital_period = investment_capital_period + investment_capital_exact \n \n # change the amount of currency hold\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] + investment_nominal\n \n # report action by appending a Series to the (empty) dataframe\n action_df = action_df.append(pd.Series({\"Currency\": currency_id, \n \"NominalAmount\": investment_nominal, \n \"CapitalAmount\": investment_capital_exact}),ignore_index=True)\n \n # report description\n data[\"description\"].iloc[observation] = (data[\"actions\"].iloc[observation] + \"\\n Buy \" + \n str(investment_nominal) + \" \" + str(currency_id) + \n \" for \" + str(investment_capital_exact))\n \n # Sell\n if signal == -1:\n \n # sell currency_id for 10% of total capital\n investment_capital = data[\"capital\"].iloc[observation-1] * 0.10 \n \n # estimate how many coins\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\n \n # calculate exact capital needed\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\n investment_capital_period = investment_capital_period - investment_capital_exact\n \n # change the amount of currency hold\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] - investment_nominal\n \n # report action\n action_df = action_df.append(pd.Series({\"Currency\": currency_id, \n \"NominalAmount\": investment_nominal, \n \"CapitalAmount\": investment_capital_exact}),ignore_index=True)\n \n # report description\n data[\"description\"].iloc[observation] = data[\"actions\"].iloc[observation] + \"Sell \" + str(investment_nominal) + \" \" + str(currency_id) + \" for \" + str(investment_capital_exact)\n \n # report actions\n data[\"actions\"].iloc[observation] = action_df.to_json()\n \n # calculate resulting cash capital\n data[\"capital\"].iloc[observation] = data[\"capital\"].iloc[observation-1] - investment_capital_period\n \n # calculate worth by capital (usd) and each currency * price\n data[\"worth_usd\"].iloc[observation] = data[\"capital\"].iloc[observation] \n return data","def _calculate_initial_bought(self): #计算初始化的 买卖 方向 ，初始都是OUT\n bought = {}\n for s in self.symbol_list: \n bought[s] = 'OUT'\n return bought","def upper_bound(stock):\n counter=0\n for i in stock_price(stock):\n if i >= resistance(stock):\n counter+=1\n return counter","def testAggregateCorrectly_simple(self):\n\n\tscaler = pf.LinearScaler()\n\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\n\tesc = pf.NoEscalationEscalator()\n\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\n\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\n\n\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\n\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\n\tend_date = dt.datetime(2034,12,31)\n\tvex1.preferred_units['variable_consumption'] = 'kW*hr'\t\n\tvex1.build_vex_schedule(end_date)\t\t#Do we need a term here? Yes? How do we control this...through the production? #maybe this should just be passed as an argument\n\n\tdates = [dt.datetime(2015,01,31), dt.datetime(2016,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\n ###!!!###Still need values here!\t--should really test escalation here to be sure\n vals_cost = [22320,22320,22320,22320]\n vals_cons = [360000,360000,360000,360000]\n \t\n for d, v1, v2 in zip(dates, vals_cons, vals_cost):\n self.assertAlmostEqual(v1, vex1.schedule.loc[d, 'variable_consumption'],4)\n\t self.assertAlmostEqual(v2, vex1.schedule.loc[d, 'variable_costs'],4)","def apk(y_true, y_pred, k):\n \n # initialize p@k list of values\n pk_values = []\n \n # loop over all k. from 1 to k+1\n for i in range(1, k + 1):\n # calculate p@i and append to list\n pk_values.append(pk(y_true, y_pred, i))\n \n # if we have no values in the list, return 0\n if len(pk_values) == 0:\n return 0\n # else, we return the sum of list over length of list\n return sum(pk_values) / len(pk_values)","def MK(df_train, df_test):\n\n # number of periods\n T = df_train.shape[0]\n\n # matrix of individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # number of agents\n K = df_test.shape[1]\n\n # true outcomes\n y = df_train.iloc[:, 0].values\n\n # initialize agent wealth (sum equal to 1 -> results in convex combination)\n w = np.full(K, 1/K, dtype=float)\n\n # initialize standard deviations\n sigma = np.full(K, 1, dtype=float)\n\n # run market for all observations (training the market)\n for i in range(T):\n\n # individual predictions in the current market\n ind_pred = F[i, :]\n\n # size of bet at the true outcome (kernel evaluated at true outcome)\n kernel_val = sps.norm.pdf(y[i], loc=ind_pred, scale=sigma)\n\n # scale by the size of budget of each agent\n w_kernel_val = np.multiply(w, kernel_val)\n\n # reward agents\n w = w_kernel_val / np.sum(w_kernel_val)\n\n # update sigma\n abs_error = np.abs(y[i] - ind_pred)\n sigma = ((i+1)*sigma + abs_error) / (i + 2)\n\n # using the trained market for out of sample forecasts\n # obtain the aggregated market prediction in each test market\n market_pred = np.dot(F_test, w)\n\n # output\n df_pred = pd.DataFrame(\n {\"Market for Kernels\": market_pred},\n index=df_test.index\n )\n\n return df_pred","def getStockPerformance(stock, start_idx, end_idx, number_years, rounded=True):\r\n total_return = (stock['Adj Close'][end_idx]- stock['Adj Close'][start_idx])/stock['Adj Close'][start_idx] + 1\r\n total_return_percentage = total_return * 100\r\n num = ((total_return ** (1/number_years)) - 1) * 100\r\n annual_return = np.round(num, decimals=2) if rounded else num\r\n return (total_return_percentage, annual_return)","def stoch_apply_nb(high_ts, low_ts, close_ts, k_window, d_window, d_ewm, adjust, cache_dict):\n h = hash(k_window)\n roll_min, roll_max = cache_dict[h]\n percent_k = 100 * (close_ts - roll_min) / (roll_max - roll_min)\n percent_d = ma_nb(percent_k, d_window, d_ewm, adjust=adjust)\n return percent_k, percent_d","def mid_market_price(orders: pandas.DataFrame):\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))","def support(stock):\n output= stock_min(stock)+(stock_min(stock)*.05)\n return output","def stock_price_summary(price_changes):\n\n gains = 0.0\n losses = 0.0\n\n for change in price_changes:\n if change > 0:\n gains += change\n elif change < 0:\n losses += change\n\n return (math.floor(gains*100)/100, math.ceil(losses*100)/100)","def get_avg(all_stock_data):\n try:\n sum_close_vol = 0.0\n sum_vol = 0.0\n for item in all_stock_data:\n adj_close = item[1]\n volume = item[2]\n sum_close_vol += adj_close * volume\n sum_vol += item[2]\n return sum_close_vol / sum_vol\n\n except Exception as e:\n print(e)\n exit()","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 bvcs():\r\n a = float(input(\"Please Enter Total Stockholders Equity Value: \"))\r\n b = float(input(\"Please Enter Preferred Equity Value: \"))\r\n c = float(input(\"Please Enter Number of Shares of Common Stock Outstanding: \"))\r\n d = (float(a)-float(b))/float(c)\r\n print \">> Your Book Value Per Share of Common Stock is\",round(d,2)","def _calculate(self):\n source = self.source\n res = {}\n l_cols = [[], [], [], []]\n r_lines = {}\n dateline=None\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\n if source[t.ror].min() > -99.0:\n pass\n else:\n source[t.ror] = np.where(\n source[t.ror] > -99.0, source[t.ror], -99.0)\n ###\n for account in self.accounts:\n source_account = source[source[t.account] == account]\n source_account = source_account.reset_index(drop=True)\n dateline=source_account[t.effective_date]\n ror=source_account[t.ror]/100\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\n # double_return_cum=round(double_return_cum,2)+1\n returns_cum = returns_cum + 1\n growth_amounts = returns_cum * self.starting_value\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\n round(growth_amounts, 2)\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\n 'series': l_cols}\n res['growth_of_unit'] = {'xAxis': list(dateline),\n 'series': r_lines}\n return res\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\n # return ret_dict","def ATR(stockData , ticker, n):\n start = dt.datetime(2020, 1, 1)\n data = pdr.get_data_yahoo(ticker, start)\n\n high_low = data['High'] - data['Low']\n high_close = np.abs(data['High'] - data['Close'].shift())\n low_close = np.abs(data['Low'] - data['Close'].shift())\n\n ranges = pd.concat([high_low, high_close, low_close], axis=1)\n true_range = np.max(ranges, axis=1)\n\n atr = true_range.rolling(n).sum() / n\n\n\n # Returns the Average True Range dataframe / with the dates.\n return atr","def calc_kwta_inhibition(self) -> None:\n top_m_units = self.units.top_k_net_indices(self.spec.k + 1)\n g_i_thr_m = self.units.g_i_thr(top_m_units[-1])\n g_i_thr_k = self.units.g_i_thr(top_m_units[-2])\n self.gc_i = g_i_thr_m + 0.5 * (g_i_thr_k - g_i_thr_m)","def calculate_kpis(cls, rollout_results: Dict) -> Dict[str, float]:\n service_level = (\n rollout_results[\"info\"][\"demand\"] - rollout_results[\"info\"][\"shortage\"]\n ).sum(axis=-1) / rollout_results[\"info\"][\"demand\"].sum(axis=-1)\n\n wastage = rollout_results[\"info\"][\"expiries\"].sum(axis=-1) / rollout_results[\n \"action\"\n ].sum(axis=(-1))\n\n holding_units = rollout_results[\"info\"][\"holding\"].mean(axis=-1)\n demand = rollout_results[\"info\"][\"demand\"].mean(axis=-1)\n order_q = rollout_results[\"action\"].mean(axis=-1)\n order_made = (rollout_results[\"action\"] > 0).mean(axis=-1)\n\n return {\n \"service_level_%\": service_level * 100,\n \"wastage_%\": wastage * 100,\n \"holding_units\": holding_units,\n \"demand\": demand,\n \"order_quantity\": order_q,\n \"wastage_units\": rollout_results[\"info\"][\"expiries\"].mean(axis=-1),\n \"shortage_units\": rollout_results[\"info\"][\"shortage\"].mean(axis=-1),\n \"order_made_%\": order_made,\n }","def calc_kdj_ma_ema( df ):\r\n # ------------------------------------------------------------\r\n df['ma5'] = MA( df['close'], 5 )\r\n df['ma10'] = MA( df['close'], 10 )\r\n df['ma20'] = MA( df['close'], 20 )\r\n df['ma30'] = MA( df['close'], 30 )\r\n df['ma40'] = MA( df['close'], 40 )\r\n df['ma60'] = MA( df['close'], 60 )\r\n df['ma89'] = MA( df['close'], 89 )\r\n df['ma144'] = MA( df['close'], 144 )\r\n df['ma233'] = MA( df['close'], 233 )\r\n df['ma377'] = MA( df['close'], 377 )\r\n df['ma610'] = MA( df['close'], 610 )\r\n\r\n kdj1 = KDJ( df, 45, 15, 15 )\r\n kdj2 = KDJ( df, 45*5, 15*5, 15*5 )\r\n kdj3 = KDJ( df, 45*5*5, 15*5*5, 15*5*5 )\r\n kdj4 = KDJ( df, 45*5*5*5, 15*5*5*5, 15*5*5*5 )\r\n \"\"\"\r\n #ema1 = EMA( kdj1['KDJ_J'], 5 )\r\n #ema2 = EMA( kdj2['KDJ_J'], 5*5 )\r\n #ema3 = EMA( kdj3['KDJ_J'], 5*5*5 )\r\n #ema4 = EMA( kdj4['KDJ_J'], 5*5*5*5 )\r\n \"\"\"\r\n\r\n df['k1'] = kdj1['KDJ_K']\r\n df['d1'] = kdj1['KDJ_D']\r\n df['j1'] = kdj1['KDJ_J']\r\n df['e1'] = EMA( kdj1['KDJ_J'], 5 )\r\n\r\n df['k2'] = kdj2['KDJ_K']\r\n df['d2'] = kdj2['KDJ_D']\r\n df['j2'] = kdj2['KDJ_J']\r\n df['e2'] = EMA( kdj2['KDJ_J'], 5*5 )\r\n\r\n df['k3'] = kdj3['KDJ_K']\r\n df['d3'] = kdj3['KDJ_D']\r\n df['j3'] = kdj3['KDJ_J']\r\n df['e3'] = EMA( kdj3['KDJ_J'], 5*5*5 )\r\n\r\n df['k4'] = kdj4['KDJ_K']\r\n df['d4'] = kdj4['KDJ_D']\r\n df['j4'] = kdj4['KDJ_J']\r\n df['e4'] = EMA( kdj4['KDJ_J'], 5*5*5*5 )\r\n\r\n df['x1'] = np.nan\r\n df['x2'] = np.nan\r\n df['x3'] = np.nan\r\n df['x4'] = np.nan\r\n\r\n n = 6\r\n x = np.arange( n )\r\n\r\n yy = df['e1'].values\r\n for i in range( n-1, len( df ) ):\r\n y1 = df['e1'][i-n+1:i+1].values\r\n y2 = df['e2'][i-n+1:i+1].values\r\n y3 = df['e3'][i-n+1:i+1].values\r\n y4 = df['e4'][i-n+1:i+1].values\r\n # print(x)\r\n # print(y)\r\n z1 = np.polyfit( x, y1, 3 )\r\n z2 = np.polyfit( x, y2, 3 )\r\n z3 = np.polyfit( x, y3, 3 )\r\n z4 = np.polyfit( x, y4, 3 )\r\n # print('zzzzzz',z)\r\n r1 = z1[0]*x[n-1]*x[n-1]+z1[1]*x[n-1]+z1[2]\r\n r2 = z2[0]*x[n-1]*x[n-1]+z2[1]*x[n-1]+z2[2]\r\n r3 = z3[0]*x[n-1]*x[n-1]+z3[1]*x[n-1]+z3[2]\r\n r4 = z4[0]*x[n-1]*x[n-1]+z4[1]*x[n-1]+z4[2]\r\n df['x1'].iat[i] = r1\r\n df['x2'].iat[i] = r2\r\n df['x3'].iat[i] = r3\r\n df['x4'].iat[i] = r4\r\n return df","def stock_market(no_profiles: int) -> tuple:\n all_companies = []\n Stocks = namedtuple(\"Stocks\", 'name symbol open high close company_weight')\n MkValue_ = random.uniform(1000, 50000, 100)\n wts_ = random.uniform(0, 1, 100)\n wts_ = wts_/sum(wts_)\n\n for _ in range(100):\n name = fake.company()\n open_ = round(MkValue_[_]*wts_[_],2)\n close = round(open_ * random.uniform(0.7, 1.15), 2)\n high = round(open_ * random.uniform(0.85, 1.15), 2)\n if high < open_:\n high = open_\n if high < close:\n high = close\n\n all_companies.append(\n Stocks(name=name, symbol=symbol(name), open=open_, high=round(high, 2), close=round(close, 2), company_weight=round(wts_[_], 4)))\n\n stock_index = round(\n sum(x.open * x.company_weight for x in all_companies), 4)\n highest_for_day = round(\n sum(x.high * x.company_weight for x in all_companies), 2)\n lowest_close_for_day = round(\n sum(x.close * x.company_weight for x in all_companies), 2)\n\n # print(f\"\\n------------------------------------Top 100 listed companies on Fake Stock Exchange------------------------------------\")\n # [print(x) for x in sorted(all_companies, key=lambda x:x.symbol)]\n # print(f\"\\n--------------Main details on {date.today()}--------------\")\n # print(f\"\\nStart of the day: {stock_index}\")\n # print(f\"Highest for the day: {highest_for_day}\")\n # print(f\"Lowest close for the day: {lowest_close_for_day}\")\n return sorted(all_companies, key=lambda x: x.symbol), stock_index, highest_for_day, lowest_close_for_day","def back_testing(self, func=None):\n # preallocate real statistics dict\n ism_label = []\n \n if not self.moving_average:\n # iterate on all ism packages\n for _i, ism_pack in enumerate(self.ism_data):\n ism_code = ism_pack[0][0]\n interval = float(ism_pack[0][-5])\n df = self.back_testing_data[ism_code]\n # using close price only now, check data is/not empty\n if df.empty:\n res = np.nan\n continue\n else:\n run_price = df['ClosePrice_run'].sum()\n stop_price = df['ClosePrice_stop'].sum()\n res = ((stop_price-run_price)/run_price)*243/interval # 243 market days/year\n ism_label.append([ism_code, res])\n \n else: # using moving_average\n # iterate on all ism packages\n # for _i, ism_pack in enumerate(self.ism_data):\n # ism_code = ism_pack[0][0]\n # interval = int(ism_pack[0][-5])\n # df = self.back_testing_data[ism_code]\n # \n # # using close price only now\n # dim = int(len(df)/(L_shift+R_shift-1)) \n # close_price = np.array_split(df['ClosePrice'], dim)\n # f1 = lambda x: float(x[-1]-x[0]) # real return for single stock\n # f2 = lambda x: float(x[0]) # initial value of single stock\n # if L_shift+R_shift >= interval:\n # ls1 = np.zeros((L_shift+R_shift-interval,), dtype=np.float32)\n # ls2 = np.zeros_like(ls1)\n # for _j, par in enumerate(close_price):\n # # sum over different stocks in one ism_pack\n # par_rolling = par.rolling(interval)\n # ls1 += np.asarray(par_rolling.apply(f1).dropna())\n # ls2 += np.asarray(par_rolling.apply(f2).dropna())\n # ism_label[ism_code] = {}\n # ism_label[ism_code]['real_return'] = (ls1/ls2/interval)\n # else:\n # print(\"L_shift+R_shift < interval\")\n pass \n \n return ism_label","def S(self):\n Ae = 1.0/float(len(self.K)) \n return (self.avg_Ao() - Ae)/(1.0 - Ae)","def calc_annual_electric_savings (self):\n costs = self.comp_specs['diesel generator o&m']\n\n for kW in costs.keys():\n try:\n if self.average_load < int(kW):\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n break\n except ValueError:\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n\n self.baseline_generation_cost = maintenance + \\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\n\n maintenance = self.capital_costs * \\\n (self.comp_specs['percent o&m'] / 100.0)\n self.proposed_generation_cost = maintenance + \\\n self.intertie_offset_generation_fuel_used * \\\n self.intertie_diesel_prices\n self.annual_electric_savings = self.baseline_generation_cost -\\\n self.proposed_generation_cost\n #~ print len(self.annual_electric_savings)\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def avancement(_,K):\n\t_=_+1\n\t#print(\"\\t\\t\\t\\t|\"+\"#\"*int(30*_/K)+\" \"*(30-int(30*_/K))+\"|\",_, \"out of\", K, \"\\t\\t\", end='\\r')","def test_interest_vs_stockprice(self):\n stock_prices = np.array([[5, 10, 20, 40]], dtype=float)\n interest_rate = 2.0 # 200%\n test_case = StockMarket(5, stock_prices, interest_rate)\n test_case.dynamic_programming_bottom_up()\n for portfolio in set(test_case.backtracing_portfolio()):\n self.assertEqual(0, portfolio)","def _calculate_stocks_after_baseline_period(\n baseline_stock_raster_path, yearly_accumulation_raster_path, n_years,\n target_raster_path):\n # Both of these values are assumed to be defined from earlier in the\n # model's execution.\n baseline_nodata = pygeoprocessing.get_raster_info(\n baseline_stock_raster_path)['nodata'][0]\n accum_nodata = pygeoprocessing.get_raster_info(\n yearly_accumulation_raster_path)['nodata'][0]\n\n def _calculate_accumulation_over_years(baseline_matrix, accum_matrix):\n target_matrix = numpy.empty(baseline_matrix.shape, dtype=numpy.float32)\n target_matrix[:] = NODATA_FLOAT32_MIN\n\n valid_pixels = (\n ~utils.array_equals_nodata(baseline_matrix, baseline_nodata) &\n ~utils.array_equals_nodata(accum_matrix, accum_nodata))\n\n target_matrix[valid_pixels] = (\n baseline_matrix[valid_pixels] + (\n accum_matrix[valid_pixels] * n_years))\n\n return target_matrix\n\n pygeoprocessing.raster_calculator(\n [(baseline_stock_raster_path, 1),\n (yearly_accumulation_raster_path, 1)],\n _calculate_accumulation_over_years, target_raster_path,\n gdal.GDT_Float32, NODATA_FLOAT32_MIN)","def investment_price(self):\n invest = self.max_loss / (self.buy_price - self.stop_loss) * self.buy_price\n if invest > self.capital:\n return round(self.capital, 2)\n else:\n return round(invest, 2)","def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn","def gamma(self, predictor):\n pred = predictor(self.X)\n pred_mean = pred.mean()\n\n self.tags[_PREDICTION] = pred\n expect_event = self.tags.groupby(_EVENT).mean()\n expect_group_event = self.tags.groupby(\n [_EVENT, _GROUP_ID]).mean()\n\n neg = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 0.0)].groupby([_EVENT]).mean()\n pos = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 1.0)].groupby([_EVENT]).mean()\n # print(pos)\n expect_group_event.loc[('label=1.0', 1), 'pred'] = (pred_mean + self.delta[1] * (pos.loc['label=1.0', 'pred'] - pos.loc['label=0.0', 'pred'])) / 2\n expect_group_event.loc[('label=0.0', 1), 'pred'] = (pred_mean + self.delta[1] * (pos.loc['label=0.0', 'pred'] - pos.loc['label=1.0', 'pred'])) / 2\n\n expect_group_event.loc[('label=1.0', 0), 'pred'] = (pred_mean + self.delta[0] * (neg.loc['label=1.0', 'pred'] - neg.loc['label=0.0', 'pred'])) / 2\n expect_group_event.loc[('label=0.0', 0), 'pred'] = (pred_mean + self.delta[0] * (neg.loc['label=0.0', 'pred'] - neg.loc['label=1.0', 'pred'])) / 2\n\n expect_event = expect_group_event.groupby(_EVENT).mean()\n expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\n\n # expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\n g_unsigned = expect_group_event[_DIFF]\n g_signed = pd.concat([g_unsigned, -g_unsigned],\n keys=[\"+\", \"-\"],\n names=[_SIGN, _EVENT, _GROUP_ID])\n self._gamma_descr = str(expect_group_event[[_PREDICTION, _DIFF]])\n return g_signed","def mean_payoffs(dist,benefit_function,b,c,*params):\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\n return dist.groupby('n')[['A_pay','B_pay']].sum()","def calc_savings_needed():\r\n annual_salary_real = float(input(\"Starting Salary: \"))\r\n #portion_saved = float(input(\"Enter the percent of your salary to save, as a decimal: \"))\r\n total_cost = 1000000#float(input(\"Enter the cost of your dream home: \"))\r\n semi_annual_raise = .07#float(input(\"Enter the semi annual raise as decimal: \"))\r\n portion_down_payment = .25\r\n current_savings = 0\r\n r = .04;\r\n monthly_salary = annual_salary_real / 12 \r\n \r\n months = 36\r\n epsilon = 100\r\n low = 0.0\r\n high = 1.0\r\n guess = (low + high) / 2.0\r\n num_guesses = 0\r\n breaked = False\r\n \r\n while(abs(current_savings - total_cost*portion_down_payment) > epsilon):\r\n if(guess == 1.0):\r\n breaked = True\r\n break\r\n #print(\"new guess: \",guess)\r\n annual_salary = annual_salary_real\r\n monthly_salary = annual_salary/12\r\n num_guesses += 1 \r\n \r\n month = 0\r\n current_savings = 0\r\n while( month < months):\r\n \r\n current_savings += (current_savings * r /12) + (guess * monthly_salary)\r\n month += 1\r\n if ((month % 6) == 0):\r\n annual_salary += annual_salary * semi_annual_raise\r\n monthly_salary = annual_salary / 12\r\n \r\n if(abs(current_savings - (total_cost*portion_down_payment)) > epsilon):\r\n #print(\"current_savings: \",current_savings)\r\n if(current_savings < (total_cost*portion_down_payment)):\r\n low = guess\r\n else:\r\n high = guess\r\n guess = (low + high) / 2.0\r\n \r\n if(breaked):\r\n print(\"It is not possible to pay down payment in 3 years.\")\r\n else: \r\n print(\"Best savings rate: \", guess)\r\n print(\"Steps in bisection search: \", num_guesses)","def sum_merch_stock(self):\n # Load data #\n df = self.parent.database['tblPoolIndicators']\n clifr = self.parent.classifiers.set_index(\"user_defd_class_set_id\")\n # Our index #\n index = ['time_step', 'forest_type', 'conifers_broadleaves']\n # Join #\n df = (df\n .set_index('user_defd_class_set_id')\n .join(clifr)\n .groupby(index)\n .agg({'hw_merch': 'sum',\n 'sw_merch': 'sum'})\n .reset_index())\n # Add year and remove TimeStep #\n df['year'] = self.country.timestep_to_year(df['time_step'])\n df = df.drop('time_step', axis=1)\n # Check for mixed species that would produce both hard and soft #\n import warnings\n for i, row in df.iterrows():\n if row['hw_merch'] > 0.0 and row['sw_merch'] > 0.0:\n warnings.warn(\"There is a mixed species at row %i.\\n%s\" % (i,row))\n df['mass'] = df['hw_merch'] + df['sw_merch']\n # calculate the volume in cubic meters over bark #\n # join density\n df = df.left_join(self.country.coefficients, 'forest_type')\n df['volume'] = df['mass'] / df['density']\n # Only if we are in the calibration scenario #\n if self.parent.parent.scenario.short_name == 'calibration':\n # Patch the harvest data frame to stop at the simulation year #\n selector = df['year'] <= self.country.base_year\n df = df.loc[selector].copy()\n # Return #\n return df","def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\n\n # number of periods in samples\n T = df_train.shape[0]\n T_test = df_test.shape[0]\n\n # number of agents\n K = df_test.shape[1]\n\n # individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # outcomes\n outcomes = df_train.iloc[:, 0].values\n\n # initialize matrices containing all predictions and bets\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\n\n # budget initialization\n budgets = np.full(K, 1, dtype=float)\n\n # training the market\n for i in range(T):\n\n # first round betting\n pred_mat[0, :] = F[i, :]\n bet_mat[0, :] = budgets * MaxRPT_r1\n budgets = budgets * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F[i, :]\n bet_mat[j, :] = budgets * MaxRPT\n budgets = budgets * (1-MaxRPT)\n\n # use IQR to determine outlier error threshold\n abs_errors = np.abs(outcomes[i] - pred_mat)\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\n IQR = Q3 - Q1\n oet = Q3 + (IQR*1.5)\n\n # reward the agents based on accuracy of their predictions\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\n score = np.log(accuracy)\n revenue = np.multiply(score, bet_mat)\n budgets = budgets + np.sum(revenue, axis=0)\n\n # rescaling the budget (only for computational reasons)\n budgets = budgets/np.sum(budgets)\n\n # using the market for the out-of-sample predictions\n pred = np.full(T_test, np.nan, dtype=float)\n for i in range(T_test):\n\n # reset test budget\n budgets_test = np.copy(budgets)\n\n # first round betting\n pred_mat[0, :] = F_test[i, :]\n bet_mat[0, :] = budgets_test * MaxRPT_r1\n budgets_test = budgets_test * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F_test[i, :]\n bet_mat[j, :] = budgets_test * MaxRPT\n budgets_test = budgets_test * (1-MaxRPT)\n\n # final round market prediction is the c-APM prediction\n pred[i] = np.dot(\n pred_mat[no_rounds-1, :],\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\n\n # output\n df_pred = pd.DataFrame(\n {\"c-APM (Constant)\": pred},\n index=df_test.index\n )\n\n return df_pred","def apk(actual, predicted, k):\n\n if len(predicted)>k:\n predicted = predicted[:k]\n \n score = 0.0\n num_hits = 0.0\n\n for i,p in enumerate(predicted):\n if p in actual and p not in predicted[:i]:\n num_hits += 1.0\n score += num_hits / (i+1.0)\n\n if not actual:\n return 0.0\n\n return round(score / min(len(actual), k), 5)","def americanprice(self):\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\n discount = math.exp( self.r*self.deltatime )\n for i in range(self.steps,0,-1):\n for j in range(i):\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\n return self.americanpay[0][0]","def portfolio_allocation(self, data, total_risk):\n total_rating = data[\"rating\"].sum()\n shares = {}\n risk_amt = total_risk\n for _, row in data.iterrows():\n numshares = int(float(row[\"rating\"]) / float(total_rating) * float(risk_amt) / float(row[\"price\"]))\n if numshares > 10:\n multiplier = int(numshares / 10)\n numshares = multiplier * 10\n shares[row[\"symbol\"]] = numshares\n\n risk_amt -= numshares * row[\"price\"]\n # debug\n # for k, v in shares.items():\n # print(\"[*] Ticker: {}, Shares: {}\".format(k, v))\n return shares","def recalculate_emission(self, i, k, corpus):\n num = sum(sum(self.gamma(i, t, O) for t in xrange(len(O)) if O[t] == k) for O in corpus)\n denom = sum(sum(self.gamma(i,t, O) for t in xrange(len(O))) for O in corpus)\n\n return num / denom","def entry_condition(self, wage):\n \n #a. solve incumbant firm problem\n pol_k, pol_n, pi, W = self.incumbant_firm(wage) \n \n # b. enter/stay in the market policy function\n pol_enter=np.zeros((self.Ns,self.ntau)) #1 to enter/stay\n \n for i_s in range(self.Ns):\n for j_t in range(self.ntau):\n if W[i_s,j_t]>=0:\n pol_enter[i_s,j_t]=1\n \n # c. present discounted value of a potential entrant\n W_e = np.sum(np.sum( W * self.joint_pdf * pol_enter, axis=0) ) - self.ce\n \n return W_e, pol_k, pol_n, pi, W, pol_enter","def _K_computations(self, X, X2):\r\n if self.ARD:\r\n pass\r\n else:\r\n if X2 is None:\r\n self._K_inner_prod = np.dot(X,X.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\r\n vec = np.diag(self._K_numer) + 1.\r\n self._K_denom = np.sqrt(np.outer(vec,vec))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\r\n else:\r\n self._K_inner_prod = np.dot(X,X2.T)\r\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\r\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\r\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\r\n self._K_asin_arg = self._K_numer/self._K_denom\r\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)","def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\n phi = 0.0\n\n ## Approach A - NREL Approach\n if approach_call == \"A\":\n\n phi = float(Q_load_W) / float(Q_design_W)\n eta_max = 0.425 # from energy.gov\n\n if phi >= phi_threshold: # from NREL-Shape\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\n\n if phi < phi_threshold:\n if phi <= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\n\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3.0 + \\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\n\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\n\n eta_therm_max = 0.45 # constant, after energy.gov\n\n if phi < phi_threshold:\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\n\n else:\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\n\n ## Approach B - Empiric Approach\n if approach_call == \"B\":\n\n if Q_design_W > 0:\n phi = float(Q_load_W) / float(Q_design_W)\n\n else:\n phi = 0\n\n eta_el_max = 0.39\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\n\n eta_el = eta_el_max * eta_el_score\n eta_therm = eta_therm_max * eta_therm_score\n\n if phi < 0.2:\n eta_el = 0\n\n return eta_el, eta_therm","def sector_metrics_fx():\r\n global df_sector_metrics\r\n \r\n df_sector_metrics = df_co_metrics\r\n drop_company = ['company_ref']\r\n df_sector_metrics.drop(labels = drop_company, axis = 1, inplace = True)\r\n df_sector_metrics = df_sector_metrics.groupby(['date_list', 'sector']).agg({'co_inv_overall': 'sum', 'co_inv_50k': 'sum', 'co_inv_100k': 'sum', 'co_inv_manager': 'sum', 'co_inv_sales': 'sum', 'co_inv_key_roles': 'sum', 'co_inv_it': 'sum', 'co_inv_hourly': 'sum','co_fut_cost_overall': 'sum', 'co_fut_cost_50k': 'sum', 'co_fut_cost_100k': 'sum', 'co_fut_cost_manager': 'sum', 'co_fut_cost_sales': 'sum', 'co_fut_cost_key_roles': 'sum', 'co_fut_cost_it': 'sum', 'co_fut_cost_hourly': 'sum','co_inv_overall_28d': 'sum', 'co_inv_50k_28d': 'sum', 'co_inv_100k_28d': 'sum', 'co_inv_manager_28d': 'sum', 'co_inv_sales_28d': 'sum', 'co_inv_key_roles_28d': 'sum', 'co_inv_it_28d': 'sum', 'co_inv_hourly_28d': 'sum','co_fut_cost_overall_28d': 'sum', 'co_fut_cost_50k_28d': 'sum', 'co_fut_cost_100k_28d': 'sum', 'co_fut_cost_manager_28d': 'sum', 'co_fut_cost_sales_28d': 'sum', 'co_fut_cost_key_roles_28d': 'sum', 'co_fut_cost_it_28d': 'sum', 'co_fut_cost_hourly_28d': 'sum'})","def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\n\n \"\"\"\n This function calculates American Opportunity Credit\n for up to four eligible students\n\n \"\"\"\n\n # Expense should not exceed the cap of $4000.\n if _cmp == 1:\n\n c87482 = max(0., min(e87482, 4000.))\n c87487 = max(0., min(e87487, 4000.))\n c87492 = max(0., min(e87492, 4000.))\n c87497 = max(0., min(e87497, 4000.))\n else:\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\n\n # Credit calculated as 100% of the first $2000 expense plus\n # 25% of amount exceeding $2000.\n if max(0, c87482 - 2000) == 0:\n c87483 = c87482\n else:\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\n\n if max(0, c87487 - 2000) == 0:\n c87488 = c87487\n else:\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\n\n if max(0, c87492 - 2000) == 0:\n c87493 = c87492\n else:\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\n\n if max(0, c87497 - 2000) == 0:\n c87498 = c87497\n else:\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\n\n # Sum of credits of all four students.\n c87521 = c87483 + c87488 + c87493 + c87498\n\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\n c87521)","def calc_capital_costs (self):\n powerhouse_control_cost = 0\n if not self.cd['switchgear suitable for renewables']:\n powerhouse_control_cost = self.cd['switchgear cost']\n\n #~ road_needed = self.comp_specs['road needed for transmission line']\n\n\n if str(self.comp_specs['transmission capital cost'])\\\n != 'UNKNOWN':\n transmission_line_cost = \\\n int(self.comp_specs['transmission capital cost'])\n else:\n if str(self.comp_specs['distance to resource']) \\\n != 'UNKNOWN':\n distance = \\\n float(self.comp_specs\\\n ['distance to resource'])\n transmission_line_cost = \\\n distance*self.comp_specs['est. transmission line cost']\n\n secondary_load_cost = 0\n if self.comp_specs['secondary load']:\n secondary_load_cost = self.comp_specs['secondary load cost']\n\n if str(self.comp_specs['generation capital cost']) \\\n != 'UNKNOWN':\n wind_cost = \\\n int(self.comp_specs['generation capital cost'])\n self.cost_per_kw = np.nan\n else:\n for i in range(len(self.comp_specs['estimated costs'])):\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\n self.load_offset_proposed:\n if i == len(self.comp_specs['estimated costs']) - 1:\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n continue\n\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n\n wind_cost = self.load_offset_proposed * cost\n self.cost_per_kw = cost\n\n #~ print powerhouse_control_cost\n #~ print transmission_line_cost\n #~ print secondary_load_cost\n #~ print wind_cost\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\n secondary_load_cost + wind_cost\n\n #~ print 'self.capital_costs',self.capital_costs","def dblcal(self, lowstrike, highstrike, expiry1, expiry2):\n assert lowstrike < highstrike\n assert pd.Timestamp(expiry1) < pd.Timestamp(expiry2)\n _rows1 = {}\n _rows2 = {}\n _prices1 = {}\n _prices2 = {}\n _index = ['Near Call', 'Far Call', 'Call Ratio', 'Near Put', 'Far Put', \n 'Put Ratio', 'Near to Far Ratio', 'Debit', 'Underlying_Price', 'Quote_Time']\n _metrics = pd.DataFrame(index=_index, columns=['Value'])\n _errmsg = \"No key for {} strike {} {}\"\n _opttype = 'call'\n _rows1[_opttype] = _relevant_rows(self.data, (highstrike, expiry1, _opttype),\n _errmsg.format(expiry1, highstrike, _opttype))\n _prices1[_opttype] = _getprice(_rows1[_opttype])\n _rows2[_opttype] = _relevant_rows(self.data, (highstrike, expiry2, _opttype),\n _errmsg.format(expiry2, highstrike, _opttype))\n _prices2[_opttype] = _getprice(_rows2[_opttype])\n _metrics.loc['Near Call', 'Value'] = _prices1[_opttype]\n _metrics.loc['Far Call', 'Value'] = _prices2[_opttype]\n _metrics.loc['Call Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\n _metrics.loc['Underlying_Price', 'Value'], _metrics.loc['Quote_Time', 'Value'] =\\\n _getkeys(_rows1[_opttype], ['Underlying_Price', 'Quote_Time'])\n _opttype = 'put'\n _rows1[_opttype] = _relevant_rows(self.data, (lowstrike, expiry1, _opttype),\n _errmsg.format(expiry1, lowstrike, _opttype))\n _prices1[_opttype] = _getprice(_rows1[_opttype])\n _rows2[_opttype] = _relevant_rows(self.data, (lowstrike, expiry2, _opttype),\n _errmsg.format(expiry2, lowstrike, _opttype))\n _prices2[_opttype] = _getprice(_rows2[_opttype])\n _metrics.loc['Near Put', 'Value'] = _prices1[_opttype]\n _metrics.loc['Far Put', 'Value'] = _prices2[_opttype]\n _metrics.loc['Put Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\n _neartot = sum(_prices1.values())\n _fartot = sum(_prices2.values())\n _metrics.loc['Near to Far Ratio', 'Value'] = float(_neartot) / _fartot\n _metrics.loc['Debit', 'Value'] = _fartot - _neartot\n return _metrics","def book_value():\r\n a = float(input(\"Please Enter Total Stockholders Equity Value: \"))\r\n b = float(input(\"Please Enter Preferred Equity Value: \"))\r\n c = float(input(\"Please Enter Number of Shares of Common Stock Outstanding: \"))\r\n d = (float(a)-float(b))/float(c)\r\n print \">> Your Book Value Per Share of Common Stock is\",round(d,2)","def sell_function(data_points, n_days):\n\n prediction_df = model_arima(data_points, n_days)\n\n # Calculates the profit for each day predicted taking into account running\n # costs and compares it with the highest profit so far.\n profit_array = [None] * (n_days + 1)\n\n for count in range(n_days):\n price = prediction_df.iloc[count][\"Prediction\"]\n profit_array[count + 1] = price\n\n return profit_array","def co_average_metrics_fx():\r\n co_inv_overall_28d_list = []\r\n co_inv_50k_28d_list = []\r\n co_inv_100k_28d_list = []\r\n co_inv_manager_28d_list = []\r\n co_inv_sales_28d_list = []\r\n co_inv_key_roles_28d_list = []\r\n co_inv_it_28d_list = []\r\n co_inv_hourly_28d_list = []\r\n\r\n co_fut_cost_overall_28d_list = []\r\n co_fut_cost_50k_28d_list = []\r\n co_fut_cost_100k_28d_list = []\r\n co_fut_cost_manager_28d_list = []\r\n co_fut_cost_sales_28d_list = []\r\n co_fut_cost_key_roles_28d_list = []\r\n co_fut_cost_it_28d_list = []\r\n co_fut_cost_hourly_28d_list = []\r\n\r\n for x in range(len(start_list)):\r\n a = start_list[x]\r\n b = end_list[x]\r\n\r\n co_inv_overall_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_overall')].rolling(window=28).mean()\r\n co_inv_50k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_50k')].rolling(window=28).mean()\r\n co_inv_100k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_100k')].rolling(window=28).mean()\r\n co_inv_manager_28d_values = df_co_metrics.iloc[a:b,df_co_metrics.columns.get_loc('co_inv_manager')].rolling(window=28).mean()\r\n co_inv_sales_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_sales')].rolling(window=28).mean()\r\n co_inv_key_roles_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_key_roles')].rolling(window=28).mean()\r\n co_inv_it_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_it')].rolling(window=28).mean()\r\n co_inv_hourly_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_hourly')].rolling(window=28).mean()\r\n\r\n co_fut_cost_overall_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_overall')].rolling(window=28).mean()\r\n co_fut_cost_50k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_50k')].rolling(window=28).mean()\r\n co_fut_cost_100k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_100k')].rolling(window=28).mean()\r\n co_fut_cost_manager_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_manager')].rolling(window=28).mean()\r\n co_fut_cost_sales_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_sales')].rolling(window=28).mean()\r\n co_fut_cost_key_roles_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_key_roles')].rolling(window=28).mean()\r\n co_fut_cost_it_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_it')].rolling(window=28).mean()\r\n co_fut_cost_hourly_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_hourly')].rolling(window=28).mean()\r\n\r\n co_inv_overall_28d_list.append(co_inv_overall_28d_values)\r\n co_inv_50k_28d_list.append(co_inv_50k_28d_values)\r\n co_inv_100k_28d_list.append(co_inv_100k_28d_values)\r\n co_inv_manager_28d_list.append(co_inv_manager_28d_values)\r\n co_inv_sales_28d_list.append(co_inv_sales_28d_values)\r\n co_inv_key_roles_28d_list.append(co_inv_key_roles_28d_values)\r\n co_inv_it_28d_list.append(co_inv_it_28d_values)\r\n co_inv_hourly_28d_list.append(co_inv_hourly_28d_values)\r\n\r\n co_fut_cost_overall_28d_list.append(co_fut_cost_overall_28d_values)\r\n co_fut_cost_50k_28d_list.append(co_fut_cost_50k_28d_values)\r\n co_fut_cost_100k_28d_list.append(co_fut_cost_100k_28d_values)\r\n co_fut_cost_manager_28d_list.append(co_fut_cost_manager_28d_values)\r\n co_fut_cost_sales_28d_list.append(co_fut_cost_sales_28d_values)\r\n co_fut_cost_key_roles_28d_list.append(co_fut_cost_key_roles_28d_values)\r\n co_fut_cost_it_28d_list.append(co_fut_cost_it_28d_values)\r\n co_fut_cost_hourly_28d_list.append(co_fut_cost_hourly_28d_values)\r\n\r\n print('avaerages calculated...') \r\n df_co_metrics['co_inv_overall_28d'] = pd.concat(co_inv_overall_28d_list)\r\n df_co_metrics['co_inv_50k_28d'] = pd.concat(co_inv_50k_28d_list)\r\n df_co_metrics['co_inv_100k_28d'] = pd.concat(co_inv_100k_28d_list)\r\n df_co_metrics['co_inv_manager_28d'] = pd.concat(co_inv_manager_28d_list)\r\n df_co_metrics['co_inv_sales_28d'] = pd.concat(co_inv_sales_28d_list)\r\n df_co_metrics['co_inv_key_roles_28d'] = pd.concat(co_inv_key_roles_28d_list)\r\n df_co_metrics['co_inv_it_28d'] = pd.concat(co_inv_it_28d_list)\r\n df_co_metrics['co_inv_hourly_28d'] = pd.concat(co_inv_hourly_28d_list)\r\n\r\n df_co_metrics['co_fut_cost_overall_28d'] = pd.concat(co_fut_cost_overall_28d_list)\r\n df_co_metrics['co_fut_cost_50k_28d'] = pd.concat(co_fut_cost_50k_28d_list)\r\n df_co_metrics['co_fut_cost_100k_28d'] = pd.concat(co_fut_cost_100k_28d_list)\r\n df_co_metrics['co_fut_cost_manager_28d'] = pd.concat(co_fut_cost_manager_28d_list)\r\n df_co_metrics['co_fut_cost_sales_28d'] = pd.concat(co_fut_cost_sales_28d_list)\r\n df_co_metrics['co_fut_cost_key_roles_28d'] = pd.concat(co_fut_cost_key_roles_28d_list)\r\n df_co_metrics['co_fut_cost_it_28d'] = pd.concat(co_fut_cost_it_28d_list)\r\n df_co_metrics['co_fut_cost_hourly_28d'] = pd.concat(co_fut_cost_hourly_28d_list)\r\n print(columns added...)","def get_greatest_stock_price():\n greatest_stock_price = 0\n // your code here","def doSummary(self):\n for name in self.stockList:\n tempVolume=0.\n for dateStr in self.listOfDates:\n rawTradeDataPath = FileNames.BinRTTradesDir + '/' + dateStr + '/' + name + '_trades.binRT'\n tradeReader = TAQTradesReader(rawTradeDataPath)\n tempVolume=tempVolume+np.nansum(tradeReader._s)/10000.0 # divide 10000 because otherwise the sum could exceed the range of int32\n self.dict[name]=tempVolume","def compute_derbeko_2007_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05): \n m_over_N = float(m)/N \n log_complexity_term = 7 * log( m*(N+1) )\n return empirical_gibbs_risk + sqrt( ((1.-m_over_N)/(2*m-2)) * (KLQP + log_complexity_term - log(delta) ) )","def __cacula_agio(table):\n from m2py.misc.vectorize import column\n\n PV = table[0][-1]\n total = sum(column(table, 1))\n premium = total/PV - 1\n return round(premium, 2)","def getAvgMarketCosts(self):\n try:\n avgAL = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldAL']\n avgEC = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldEC']\n avgIA = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldIA']\n except:\n avgAL = 0.0\n avgEC = 0.0\n avgIA = 0.0\n \n return (avgAL, avgEC, avgIA)","def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n\n for i in range(total_days):\n if i==0:\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n elif i==total_days-1: # last day\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n invt_daily_list.append(today_invt_dict)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Baseline Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Baseline (1st day buy->hold->last day sell) Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()\n return","def invest(self, new_positions):\n\n # Add three columns to df and initialize\n new_positions.loc[:, Consts.FULLY_INVESTED] = False\n new_positions.loc[:, Consts.CAPITAL_TO_INVEST] = 0\n new_positions.loc[:, Consts.LEVERAGED_CAPITAL] = 0\n\n # Available capital for current round\n available_capital = self.liquid_capital * self.max_percent_cap_investment_in_a_round\n\n if available_capital < self.min_investment:\n logger.debug(\n \"The available capital for this round is smaller then the min investment. There are no new positions for time:{}\".format(\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\n return\n\n # Adds 'capital_to_invest' column and 'fully_invested' column to each row\n new_positions = self.capital_allocation_strategy(new_positions,\n available_capital)\n\n if len(new_positions) == 0:\n logger.debug(\n \"There are no new positions for time:{}\".format(\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\n return\n\n # If simulation has leverage, fills Consts.LEVERAGE_CAPITAL with relevant leverage\n if self.leverage > 1:\n new_positions = self.add_leverage_by_conditions(new_positions)\n\n # Create new positions\n for index, position in new_positions.iterrows():\n order_type = position['order_type']\n\n # Create a new position\n pos = Position.Position(position['coin_symbol'], order_type, self.time_ticker,\n position['high_boundary'], position['low_boundary'],\n position['capital_to_invest'] + position[Consts.LEVERAGED_CAPITAL],\n self.trailing_strategy, self.fees, position[Consts.LEVERAGED_CAPITAL],\n self.apply_leverage_fees_on_all_capital, self.leverage, self.long_trailing_strategy,\n self.short_trailing_strategy, position['time_predict'],\n self.active_long_investment_strategy, self.active_short_investment_strategy)\n\n # Allocates each order to its relevant statistics\n if order_type == Consts.SHORT:\n self.active_short_positions.append(pos)\n self.short_capital += pos.get_current_liquid_capital()\n else:\n self.active_long_positions.append(pos)\n self.long_capital += pos.get_current_liquid_capital()\n\n # Update portfolio liquid capital and leverage capital\n self.liquid_capital -= pos.get_current_liquid_capital()\n self.leverage_capital += pos.leverage_capital\n\n logger.debug(\"Finished investment cycle for time {}\".format(\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\n logger.debug(\n \"liquid capital: {}, leverage capital: {}, long capital: {}, short capital: {}\".format(self.liquid_capital,\n self.leverage_capital,\n self.long_capital,\n self.short_capital))","def ALRA(X, k=None, n_iter=10):\n if k is None:\n k = choose_k(X)\n log.info(f\"No `k` given. Automatically determined `k={k}`.\")\n\n # Compute the SVD and compute the rank-k reconstruction\n U, s, Va = pca(X, k=k, n_iter=n_iter, raw=True)\n X_rank_k = U * s @ Va\n\n X_rank_k = np.ma.masked_array(X_rank_k)\n\n # Find the absolute values of the minimum expression levels for each gene\n minimum_expressions = np.abs(np.min(X_rank_k, axis=0))\n # Zero out all expressions with values below the gene minimum value\n X_rank_k[X_rank_k <= minimum_expressions] = np.ma.masked\n\n # Rescale the expressions so the first two moments match the original matrix\n X_mean, X_std = nonzero_mean(X, axis=0), nonzero_std(X, axis=0, ddof=1)\n X_rk_mean, X_rk_std = X_rank_k.mean(axis=0), X_rank_k.std(axis=0, ddof=1)\n\n scale = X_std / X_rk_std\n translate = -X_rk_mean * scale + X_mean\n\n scale_columns = ~np.isnan(X_std) & ~np.isnan(X_rk_std)\n X_rank_k[:, scale_columns] *= scale[scale_columns]\n X_rank_k[:, scale_columns] += translate[scale_columns]\n\n # Values can become negative during rescaling, so we zero those out\n X_rank_k[X_rank_k < 0] = np.ma.masked\n\n # Restore potentially zeroed out expression values which appeared in the\n # original expression matrix. Where both values are non-zero, prefer the\n # rank-k approximation\n zeroed_out_indices = find_zeroed_indices(X_rank_k, X)\n X_rank_k[zeroed_out_indices] = X[zeroed_out_indices]\n\n log.info(\n f\"{len(zeroed_out_indices[0])} original expression values were \"\n f\"zeroed out during imputation and restored to original values.\"\n )\n\n X_rank_k = X_rank_k.filled(0)\n\n return X_rank_k","def overall_reduction(self):\n return 84","def BacktestStrategy2(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n recent_max=0 # recent max = 전고점 가격\n for i in range(total_days):\n if i==0: # 첫날은 일단 풀매수\n recent_max=stock_exchange.GetDayHighestPrice(i)\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n else: # 다른날은 전부 전략대로 수행\n recent_max=max(recent_max, stock_exchange.GetDayHighestPrice(i-1)) # 전고점 갱신 확인\n # 만약 어제 종가가 전고점*threshold 미만이라면: 풀매도 \n if (stock_exchange.GetDayClosePrice(i-1) < \n (start_cond_dict['sell_threshold_percent']/100)*recent_max):\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n # 매도조건을 만족 안 시킨 상황에서 n개월 모멘텀이 (+)면: 풀매수 -- n개월이 안지났으면 스킵\n elif (i > start_cond_dict['buy_momentum_days'] and \n stock_exchange.GetDayHighestPrice(i-start_cond_dict['buy_momentum_days']) <\n stock_exchange.GetDayOpenPrice(i)):\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n # 나머지 상황에선 포지션 홀드\n else:\n pass\n invt_daily_list.append(today_invt_dict)\n #print(today_invt_dict) # for debug :)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Experimental Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Experimental Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()","def _ei_halluc_acq(x):\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\n Z = (mu - curr_best) / sigma\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)","def summary(self, risk_free=None, market_return=None, top_holdings=None, round_digit=4):\n\n moment_dict = defaultdict(lambda: \"Moment\")\n moment_dict[3] = \"Skewness\"\n moment_dict[4] = \"Kurtosis\"\n\n weight_dict = dict(zip(self.assets, self.weight_sols))\n metric_dict = {'Expected Return': self.metric_creator.expected_return(self.weight_sols),\n \"Leverage\": self.metric_creator.leverage(self.weight_sols),\n \"Number of Holdings\": self.metric_creator.num_assets(self.weight_sols)}\n\n # Portfolio Composition\n if top_holdings:\n metric_dict[f\"Top {top_holdings} Holdings Concentrations\"] = self.metric_creator.concentration(\n self.weight_sols, top_holdings)\n\n # Risk Only\n if self.moment == 2:\n metric_dict[\"Volatility\"] = self.metric_creator.volatility(self.weight_sols)\n # metric_dict[\"Correlation\"] = self.metric_creator.correlation(self.weight_sols)\n else:\n metric_dict[f'{moment_dict[int(self.moment)]}'] = self.metric_creator.higher_moment(self.weight_sols)\n\n # Risk-Reward\n if self.beta_vec is not None:\n metric_dict[\"Portfolio Beta\"] = self.metric_creator.beta(self.weight_sols)\n\n if risk_free is not None:\n metric_dict[\"Sharpe Ratio\"] = self.metric_creator.sharpe(self.weight_sols, risk_free)\n\n if self.beta_vec is not None and risk_free is not None:\n metric_dict[\"Treynor Ratio\"] = self.metric_creator.treynor(self.weight_sols, risk_free)\n if market_return is not None:\n metric_dict[\"Jenson's Alpha\"] = self.metric_creator.jenson_alpha(self.weight_sols, risk_free, market_return)\n\n for item in metric_dict:\n metric_dict[item] = np.round(metric_dict[item], round_digit)\n\n weight_dict = {k: v for k, v in weight_dict.items() if v}\n return weight_dict, metric_dict","def gamma(self, predictor):\n pred = predictor(self.X)\n self.tags[_PREDICTION] = pred\n expect_event = self.tags.groupby(_EVENT).mean()\n expect_group_event = self.tags.groupby(\n [_EVENT, _GROUP_ID]).mean()\n\n num_grp = len(self.error_rate)\n tprs = [0 for _ in range(num_grp)]\n # print(expect_group_event)\n for i in range(num_grp):\n tprs[i] = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == i)].groupby([_EVENT]).mean()\n expect_group_event.loc[('label=1', i), 'pred'] = (1 - self.error_rate[i][0]) * tprs[i].loc['label=1', 'pred'] + self.error_rate[i][0] * tprs[i].loc['label=0', 'pred']\n expect_group_event.loc[('label=0', i), 'pred'] = (1 - self.error_rate[i][1]) * tprs[i].loc['label=0', 'pred'] + self.error_rate[i][1] * tprs[i].loc['label=1', 'pred']\n\n # neg = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 0.0)].groupby([_EVENT]).mean()\n # pos = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 1.0)].groupby([_EVENT]).mean()\n\n # expect_group_event.loc[('label=1.0', 1), 'pred'] = (1 - self.error_rate[1][0]) * pos.loc['label=1.0', 'pred'] + self.error_rate[1][1] * pos.loc['label=0.0', 'pred']\n # expect_group_event.loc[('label=0.0', 1), 'pred'] = (1 - self.error_rate[1][1]) * pos.loc['label=0.0', 'pred'] + self.error_rate[1][0] * pos.loc['label=1.0', 'pred']\n\n # expect_group_event.loc[('label=1.0', 0), 'pred'] = (1 - self.error_rate[0][0]) * neg.loc['label=1.0', 'pred'] + self.error_rate[0][1] * neg.loc['label=0.0', 'pred']\n # expect_group_event.loc[('label=0.0', 0), 'pred'] = (1 - self.error_rate[0][1]) * neg.loc['label=0.0', 'pred'] + self.error_rate[0][0] * neg.loc['label=1.0', 'pred']\n\n expect_event = expect_group_event.groupby(_EVENT).mean()\n expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\n\n # expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\n g_unsigned = expect_group_event[_DIFF]\n g_signed = pd.concat([g_unsigned, -g_unsigned],\n keys=[\"+\", \"-\"],\n names=[_SIGN, _EVENT, _GROUP_ID])\n self._gamma_descr = str(expect_group_event[[_PREDICTION, _DIFF]])\n return g_signed","def calc_annual_heating_savings (self):\n price = self.diesel_prices + self.cd['heating fuel premium']\n maintenance = self.comp_specs['heat recovery o&m']\n self.annual_heating_savings = -1 * \\\n (maintenance + (self.lost_heat_recovery * price))","def compute_portvals(start_date, end_date, orders_file, start_val):\n \n #Read order file\n orders = pd.read_csv( orders_file, parse_dates = [0])\n \n #Get symbols making up the portfolio\n stock_symbols = list( set( orders[\"Symbol\"] ) )\n dates = pd.date_range(start_date, end_date)\n \n #Read stock prices\n stock_prices = get_data(stock_symbols, dates)\n \n #Create a portfolio keeping track of positions, \n #_CASH column indicates cash position, _VALUE total portfolio value\n #_LEVERAGE the leverage of portfolio when we allow for short selling\n symbols = stock_symbols[:] #Shallow copy of the list\n symbols.append(\"_CASH\")\n symbols.append(\"_VALUE\")\n symbols.append(\"_LEVERAGE\")\n \n #Index contains only business days, same dates as stock prices\n portfolio = pd.DataFrame(index=stock_prices.index, columns = symbols )\n portfolio.fillna(0) \n portfolio[\"_CASH\"][0] = start_val\n portfolio[\"_VALUE\"][0] = start_val\n \n #Snapshot of a portfolio at any time. To avoid using numerical indexes\n portfolio_snapshot = dict.fromkeys ( symbols, 0 )\n portfolio_snapshot[\"_CASH\"] = start_val\n portfolio[\"_VALUE\"] = start_val\n \n #Now calcualte portfolio day by day\n for date in portfolio.index:\n #Check transactions for the day\n day_orders = orders[ orders[\"Date\"] == date ] \n \n for ord in day_orders.iterrows():\n symbol = ord[1][ \"Symbol\"] \n stock_price = stock_prices[ symbol ][ date ]\n shares = ord[1][\"Shares\" ]\n side = ord[1][\"Order\"]\n \n if side == \"BUY\":\n portfolio_snapshot[ \"_CASH\" ] -= stock_price * shares\n portfolio_snapshot[ symbol ] += shares \n elif side == \"SELL\":\n portfolio_snapshot[ \"_CASH\" ] += stock_price * shares\n portfolio_snapshot[ symbol ] -= shares\n else:\n raise \"Order not recognized.\"\n \n #Compute portfolio value\n portfolio_snapshot[ \"_VALUE\" ] = portfolio_snapshot[ \"_CASH\" ]\n shorts = longs = 0\n for symbol in stock_symbols: \n stock_price = stock_prices[ symbol ][ date ]\n shares = portfolio_snapshot[ symbol ]\n notional = stock_price*shares\n if shares > 0:\n longs += notional\n else:\n shorts += notional\n \n portfolio_snapshot[ \"_VALUE\" ] += notional\n \n #Compute leverage\n leverage = (longs+shorts)/(longs-shorts + portfolio_snapshot[ \"_CASH\" ] )\n portfolio_snapshot[ \"_LEVERAGE\" ] = leverage\n \n #Assert we never achieve a leverage > 2.0\n if leverage > 2:\n raise \"Leverage > 2.0 achieved\"\n \n #Update portfolio from the daily snapshot\n #TODO: Is this causing performance issues?\n for symbol in portfolio.keys():\n portfolio[ symbol ][ date ] = portfolio_snapshot[ symbol ]\n \n return portfolio","def getIdealSec(context, data): #This replaced before_trading_start(context, data)\n record(Leverage = \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t context.account.leverage,pos=len(context.portfolio.positions))\n context.output = pipeline_output('my_pipeline')\n #print('Pipeout: ')\n #print(context.output)\n \n # These are the securities that we are interested in trading each day.\n # Note: As it stands, the securities in this list are from two different industries (defense and\n # consumer electronics). Although more computationally expensive then dividing them out into their \n # two respective industries prior to cross correlating, leaving them in the same matrix/data set and \n # cross correlating them gives us a way to 'check' that the crosscorrelation is valid, since securities within the same industry should typically cross correlate to a higher degree than across industries. ***\n context.security_list = context.output.index \n context.defenseList = context.output[context.output['defenseFilt']].index.tolist()\n #print(context.defenseList)\n context.autoList = context.output[context.output['autoFilt']].index.tolist()\n #print(context.autoList)\n context.chemList = context.output[context.output['chemFilt']].index.tolist()\n #print(context.chemList)\n context.techList = context.output[context.output['techFilt']].index.tolist()\n #print(context.techList)\n context.depList = context.output[context.output['depFilt']].index.tolist()\n # Within each sector, calculate the mean (and max, since we may choose only to trade the maximally correlated securities regardless of industry) crosscorrelation between all combinations of stocks. \n #This will only run every trading day to prevent computational expense. In that \n #respect, performs identically to a pipeline add-on (but allows the use of \"history\") \n #Try block here incase pipe returns no valid securities. \n try:\n \tprice_history = np.transpose(data.history(context.security_list, fields=\"price\", bar_count=context.lookback,frequency=\"1m\"))\n \tprice_history=price_history.as_matrix()\n except:\n price_history=[[0],[0],[0]]\n #This returns three arrays, containing a filtered set of maximally cross correlated securities within the last time range (given by context.lookback), their associated (and filtered) time delays corresponding to their maximum correlation, and the degree of their correlation in the given time frame. Essentially, since tau has already been filtered for, the degree of their correlation should be used as a confidence feature to make predictions off of, and tau should be used to determine when to make purchases/sales. \n #hCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context)\n #The best securities to trade using this algorithm (each day) are listed in the below lists ***\n try:\n \thCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context) \n except: \n print('Crosscorr Failed')\n maxSecs,hCorrVals,timeDelays,short_timeDelays=[],[],[],[]\n #\"Globalize\" the returned information so that we can handle these commodities every minute. \n context.Securities=maxSecs\n context.CorrVals=hCorrVals\n context.timeDelays=short_timeDelays #************Used to be timeDelays, now however, we calculate a more recent tau\n context.actionList,context.timerList,context.tradeList,context.tradingNow=[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities) #list of zeros indicating that no stocks should currently be trading\n #(Note that all stocks should be sold at end of every tradinng day.) "],"string":"[\n \"def calculate_industry_neutral_nway_return(df, name, sorts, cuts, long_bucket, short_bucket, ind_col='sic1', ret_col='ret'):\\n df = df.copy()\\n\\n # n-way sort\\n keys = ['time_idx', ind_col]\\n for sort, cut in zip(sorts, cuts):\\n df[sort] = df.groupby(keys, as_index=False)[sort].transform(lambda x: pd.qcut(x, cut, range(cut)))\\n keys.append(sort)\\n\\n # calculate bucket returns\\n port_ret = df.groupby(['time_idx', ind_col] + sorts, as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\\n summary = port_ret.groupby(['time_idx'] + sorts, as_index=False)[[ret_col, 'permno']].apply(\\n lambda x: pd.Series([np.average(x[ret_col], weights=x.permno), x.permno.sum()], index=['ret', 'avg count'])\\n )\\n\\n hedged_bucket = summary.reset_index('time_idx').groupby('time_idx').apply(\\n lambda x: pd.Series([\\n (x.loc[long_bucket, 'ret'] - x.loc[short_bucket, 'ret']) / 2,\\n (x.loc[long_bucket, 'avg count'] + x.loc[short_bucket, 'avg count']) / 2\\n ], index=['ret', 'avg count'])\\n )\\n tmp = hedged_bucket.agg({'ret': ['mean', 'std'], 'avg count': 'mean'})\\n hedged_bucket = pd.DataFrame({**{sorts[0]: ['hedged'],\\n 'return': [tmp.loc['mean', 'ret']],\\n 't stat': [tmp.loc['mean', 'ret'] / tmp.loc['std', 'ret']],\\n 'avg count': [tmp.loc['mean', 'avg count']]}, **{x: '' for x in sorts[1:]}})\\n\\n summary = summary.groupby(sorts).agg({'ret': ['mean', 'std'], 'avg count': 'mean'}, axis=1)\\n summary.columns = [\\\"_\\\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\\n summary['t stat'] = summary.ret_mean / summary.ret_std\\n summary = summary.drop('ret_std', axis=1).rename({'ret_mean': 'return', 'avg count_mean': 'avg count'}, axis=1)\\n summary = summary.reset_index()[sorts + ['return', 't stat', 'avg count']]\\n summary = pd.concat([summary, hedged_bucket], axis=0, sort=False)\\n\\n # calculate hedged returns\\n agg = port_ret.set_index(sorts).groupby(['time_idx', ind_col]).apply(\\n lambda x: pd.Series([\\n (x.loc[long_bucket, ret_col] - x.loc[short_bucket, ret_col]) / 2, # to maintain unit leverage\\n (x.loc[long_bucket, ret_col]) / 2, # division by 2 to match same leverage of the long side\\n (x.loc[short_bucket, ret_col]) / 2, # division by 2 to match same leverage of the short side\\n (x.loc[long_bucket, 'permno'] + x.loc[short_bucket, 'permno']) / 2\\n ], index=['ret', 'long_ret', 'short_ret', 'count'])\\n )\\n hedged = agg.groupby(level=0).apply(lambda x: np.average(x.ret, weights=x['count']))\\n long = agg.groupby(level=0).apply(lambda x: np.average(x.long_ret, weights=x['count']))\\n short = agg.groupby(level=0).apply(lambda x: np.average(x.short_ret, weights=x['count']))\\n\\n # plot\\n avg = hedged.rolling(4, min_periods=4).sum()\\n fig = make_subplots(specs=[[{\\\"secondary_y\\\": True}]])\\n fig.add_trace(go.Bar(y=avg, x=avg.index, name=name + ' Return'), secondary_y=False)\\n fig.add_trace(go.Scatter(y=(1 + hedged).cumprod(), x=hedged.index, name=name + ' Equity'), secondary_y=True)\\n fig.add_trace(go.Scatter(y=(1 + long).cumprod(), x=hedged.index, name=name + ' Long Equity'), secondary_y=True)\\n fig.add_trace(go.Scatter(y=(1 + short).cumprod(), x=hedged.index, name=name + ' Short Equity'), secondary_y=True)\\n fig.show()\\n\\n return {'name': name, 'equity': hedged, 'summary': summary, 'data': df}\",\n \"def calculate_profit(self):\",\n \"def calc_earning(self, data=None):\\n result = Result()\\n if data is None:\\n data = self.security\\n self.calcDecision()\\n first_purchase_method = self.check_first_purchase_method()\\n for i in np.arange(len(data['Close'])):\\n if data['FinalDecision'].iloc[i] is None:\\n pass\\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\\n self.buys_made += 1\\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\\n self.shares_own = self.stock_quantity\\n self.buys_made += 1\\n else:\\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\\n self.final_capital = self.final_capital % data['Close'].iloc[i]\\n #print(self.shares_own)\\n\\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n pass\\n else:\\n self.final_capital += self.shares_own * data['Close'].iloc[i]\\n self.shares_own = 0\\n self.sells_made +=1\\n #Checar si es el momento mas alto o bajo de ganancias\\n if self.shares_own == 0:\\n if (self.highest_point is None\\n or self.highest_point < self.final_capital):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > self.final_capital\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n else:\\n if (self.highest_point is None\\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n self.calcRealFinalCapital()\\n self.calcDiferencePercentage()\",\n \"def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\\n total_capital = capital * leverage\\n df = data\\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\\n lambda x: len(x))\\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\\n df['profit'] = df.eval('(sell-buy)*qty')\\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\\n df['net_profit'] = df.eval('profit - commission - slippage')\\n return df\",\n \"def IC(stock):\\n return Invested_Book_Capital(stock)\",\n \"def incumbant_firm(self, wage):\\n \\n \\n \\n # a. demand for capital (capital policy function)\\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\\\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\\\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\\n \\n # b. demand of labor (labor policy function)\\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\\n \\n # c. incumbant profit\\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\\\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\\n \\n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\\n W = pi / (1-self.rho)\\n \\n return pol_k, pol_n, pi, W\",\n \"def aveVolumeCalc(ins, date):\\n cal = ins.Currency().Calendar()\\n enddate = cal.AdjustBankingDays(date, 0)\\n startdate = cal.AdjustBankingDays(date, AVERAGING_PERIOD)\\n\\n prices=[]\\n histprices = acm.FPrice.Select(\\\"instrument = %s and market = '%s' \\\\\\n and day > '%s' and day <='%s'\\\" % \\n (ins.Oid(), DAILY_MARKET, startdate, enddate))\\n \\n for price in histprices:\\n settle = price.Settle()\\n if settle >= 0:\\n prices.append(settle)\\n \\n #upgrade 2013 fix for failure during run - acm.Math().AverageOf seems buggy\\n try:\\n avgprice = (sum(prices)/len(prices))\\n except ZeroDivisionError:\\n avgprice = 0\\n \\n #avgprice = acm.Math().AverageOf(prices, None)\\n \\n #Overwrite today's price if you find it \\n newPrice = acm.FPrice.Select01(\\\"instrument = %s and market = '%s' and day = %s\\\" % \\n (ins.Oid(), THREE_MONTH_MARKET, enddate),\\n 'NaN')\\n if not newPrice:\\n newPrice = acm.FPrice()\\n newPrice.Instrument(ins)\\n newPrice.Day(enddate)\\n newPrice.Market(THREE_MONTH_MARKET)\\n newPrice.Currency(ins.Currency())\\n\\n newPrice.Settle(avgprice)\\n try:\\n newPrice.Commit()\\n print 'INFO: %s price for %s was created on %s' %(THREE_MONTH_MARKET, ins.Name(), date)\\n except Exception, err:\\n print 'ERROR: %s price for %s did not commit: %s' %(THREE_MONTH_MARKET, ins.Name(), str(err))\\n \\n return newPrice\",\n \"def _IC(df): # Balance\\n # No adjustments for cash-flow and off-balance sheet yet\\n return Invested_Book_Capital(df)\",\n \"def calcAdl(self):\\n adl = []\\n for i,j in enumerate(self.stock_data['Close']):\\n #Calculating money flow measure\\n mfm_nom = ((j-self.stock_data['Low'][i])-(self.stock_data['High'][i]))\\n mfm_deno = self.stock_data['High'][i]-self.stock_data['Low'][i]\\n mfm = mfm_nom/mfm_deno\\n #Calculating money flow volume\\n mfv = mfm*self.stock_data['Volume'][i]\\n #Calculating accumulated distributin line\\n if not adl:\\n print(mfm)\\n adl.append(mfv)\\n else:\\n print(adl)\\n adl.append(mfv+adl)\\n def_dates, def_points, k = self.angle(self.dates, adl, self.type) \\n return k\",\n \"def calculate_hedeged_return_by_industry(df, factor, long, short, ind_col='sic1', ret_col='ret_1', ncuts=3):\\n df = df.copy()\\n\\n # sorting\\n df[factor] = df.groupby(['time_idx', ind_col], as_index=False)[factor].transform(lambda x: pd.qcut(x, ncuts, range(ncuts)))\\n\\n # calculate bucket returns\\n port_ret = df.groupby(['time_idx', ind_col, factor], as_index=False).agg({ret_col: 'mean', 'permno': 'count'})\\n summary = port_ret.set_index(factor).groupby(['time_idx', ind_col], as_index=False).apply(\\n lambda x: pd.Series([\\n (x.loc[long, ret_col] - x.loc[short, ret_col]) / 2,\\n (x.loc[long, 'permno'] + x.loc[short, 'permno'])\\n ], index=['ret', 'count'])\\n )\\n\\n summary = summary.groupby(level=1).agg({'ret': ['mean', 'std'], 'count': 'mean'})\\n summary.columns = [\\\"_\\\".join(x) if x[1] != '' else x[0] for x in summary.columns.ravel()]\\n summary['t stat'] = summary.ret_mean / summary.ret_std\\n summary = summary.rename({'ret_mean': 'return', 'count_mean': 'avg count'}, axis=1).drop('ret_std', axis=1)\\n return summary.reset_index()[[ind_col, 'return', 't stat', 'avg count']]\",\n \"def calc_annual_heating_savings (self):\\n price = (self.diesel_prices + self.cd['heating fuel premium'])\\n\\n #~ self.base_heating_cost =\\n\\n #~ self.proposed_heating_cost =\\n\\n\\n\\n\\n self.annual_heating_savings = self.reduction_diesel_used * price\\n #~ print 'self.annual_heating_savings',self.annual_heating_savings\",\n \"def stocks(values, maxSales):\\n return 0\",\n \"def capital_allocation_strategy(self, coins_to_invest, available_capital):\\n coins_available_capital = 0\\n used_capital = 0\\n\\n # Count positions which capital size is not equal to max capacity of investment\\n total_positions_count = len(coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False])\\n\\n if total_positions_count > 0:\\n\\n # Divide all available capital equally by all the positions\\n coins_available_capital = available_capital / total_positions_count\\n\\n # Stopping condition: If there are no more position not fully invested or coins_available_capital is smaller then min investment\\n if total_positions_count == 0 or coins_available_capital < self.min_investment:\\n return coins_to_invest\\n\\n # Iterate all coins to invest which are not fully invested\\n for index, coins_prediction in coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False].copy().iterrows():\\n\\n coin_symbol = coins_prediction['coin_symbol']\\n\\n success, coin_current_volume = self.fetch_coins_24h_volumeto(coin_symbol)\\n\\n # exit if failed to fetch volume\\n if not success:\\n raise Exception\\n\\n if coin_current_volume == 0.0:\\n logger.debug(\\\"Volume is zero. Not investing in: {}, at time: {}\\\".format(coin_symbol,\\n TimeHelper.epoch_to_date_time(\\n self.time_ticker.current_time)))\\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\\n continue\\n\\n # Volume boundary of the specific coin symbol at the specific time\\n coins_max_capital_volume_boundary = self.max_percent_out_of_volume * coin_current_volume\\n\\n # If the volume boundary is smaller then available capital, then there is maximum capital in current position means = fully invested\\n if coins_max_capital_volume_boundary < coins_available_capital:\\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\\n max_amount_to_invest_in_coin = coins_max_capital_volume_boundary\\n else:\\n max_amount_to_invest_in_coin = coins_available_capital\\n\\n # Risk indicator which decreases positions size according to probability\\n capital_percent = self.percent_capital_according_to_probability(coins_prediction[Consts.PROB_POSITIVE_HEADER],\\n coins_prediction[Consts.PROB_NEGATIVE_HEADER],\\n coins_prediction['order_type'])\\n\\n current_capital_to_invest_in_position = capital_percent * max_amount_to_invest_in_coin\\n\\n # Add to capital to invest for current row\\n coins_to_invest.loc[index, Consts.CAPITAL_TO_INVEST] = coins_to_invest.loc[\\n index, Consts.CAPITAL_TO_INVEST] + current_capital_to_invest_in_position\\n\\n used_capital += current_capital_to_invest_in_position\\n\\n available_capital -= used_capital\\n\\n return self.capital_allocation_strategy(coins_to_invest, available_capital)\",\n \"def market_income(df):\\n return df.expanded_income - df[mdf.BENS].sum(axis=1)\",\n \"def testAggregateCorrectly(self):\\n\\n\\tscaler = pf.LinearScaler()\\n\\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(1, '1/gal'))\\n\\tesc = pf.NoEscalationEscalator()\\n\\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\\n\\n\\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2012,01,01))\\n\\n\\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(1, '1/(kW*hr)'))\\n\\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\\n\\n\\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\\n\\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\\n\\n\\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\\n vals = [202320,202320,202320,202320]\\n\\tend_date = dt.datetime(2034,12,31)\\n\\tcosts = pf.VariableCosts()\\n costs.add_variable_expense(vex1)\\n costs.add_variable_expense(vex2)\\n costs.build_vex_schedule(end_date)\\n\\t\\n for d, v in zip(dates, vals):\\n self.assertAlmostEqual(v, costs.schedule.loc[d, 'variable_costs'],4)\",\n \"def find_max_profit(stock_prices,k):\\n\\teliminated_indices = set()\\n\\ttotal_profit = 0\\n\\n\\t\\n\\tfor i in range(0,k):\\n\\t\\tmax_profit = float('-inf')\\n\\t\\tmin_price = float('inf')\\n\\t\\t\\n\\t\\tfor current_index,current_price in enumerate(stock_prices):\\n\\t\\t\\t# This condition takes care of note by making sure that \\n\\t\\t\\t# prices are not used in previous transaction.\\n\\t\\t\\tif current_index not in eliminated_indices:\\n\\t\\t\\t\\tcurrent_profit = current_price - min_price\\n\\n\\t\\t\\t\\tif (current_profit > max_profit):\\n\\t\\t\\t\\t\\tbuying_price_index = min_price_index\\n\\t\\t\\t\\t\\tselling_price_index = current_index\\n\\t\\t\\t\\t\\tmax_profit = current_profit\\n\\n\\t\\t\\t\\t#min_price = min(min_price, current_price)\\n\\t\\t\\t\\tif (current_price < min_price):\\n\\t\\t\\t\\t\\tmin_price = current_price\\n\\t\\t\\t\\t\\tmin_price_index = current_index\\n\\n\\n\\t\\t# This for loop is to take care of Note\\n\\t\\tfor i in range(buying_price_index,selling_price_index+1):\\n\\t\\t\\teliminated_indices.add(i)\\n\\n\\t\\ttotal_profit += max_profit\\n\\t\\tprint('buying_price_index :',buying_price_index)\\n\\t\\tprint(\\\"selling_price_index :\\\",selling_price_index)\\n\\n\\treturn total_profit\",\n \"def calculate_gamma(self):\\n result = self.result\\n # scaler = preprocessing.StandardScaler()\\n # train_minmax = scaler.fit_transform(result)\\n # st_rho, st_delta = train_minmax[:, 0], train_minmax[:, 1]\\n # self.gamma = (st_delta + st_rho) / 2\\n self.gamma = result[:, 0] * result[:, 1]\\n self.gamma_des_index = np.argsort(-self.gamma)\",\n \"def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):\",\n \"def backtest_portfolio(self):\\n self.rank=dict()\\n self.accuracy=dict()\\n portfolio = dict()\\n \\n for algo in self.algos:\\n portfolio[algo]=pd.DataFrame(index=self.positions.index)\\n self.pos_diff=dict()\\n self.pos_diff[algo] = self.positions[algo].diff()\\n \\n portfolio[algo]['price_diff'] = self.bars['Close']-self.bars['Open']\\n #portfolio['price_diff'][0:5] = 0.0\\n portfolio[algo]['profit'] = self.positions[algo] * portfolio[algo]['price_diff']\\n portfolio[algo]['total'] = self.initial_capital + portfolio[algo]['profit'].cumsum()\\n portfolio[algo]['returns'] = portfolio[algo]['total'].pct_change()\\n d=np.array(portfolio[algo]['profit']).copy()\\n d[d>0]=1\\n d[d<0]=0\\n d[np.array(self.positions[algo])==0]=1\\n for i in np.arange(1,len(d)+1):\\n c=float(sum(d[0:i]))/(i)\\n d[i-1]=c\\n portfolio[algo]['accuracy']=d\\n self.rank[algo]=float(portfolio[algo]['total'][-1] - portfolio[algo]['total'][0])\\n self.returns=portfolio\\n c=np.array(self.returns[algo]['profit'])\\n c[c>0]=1\\n c[c<0]=0\\n c[np.array(self.positions[algo])==0]=1\\n accuracy=round(float(c.sum())/len(c),2)*self.rank[algo]\\n self.accuracy[algo]=accuracy\\n #self.ranking= sorted(self.rank.items(), key=operator.itemgetter(1), reverse=True)\\n self.ranking= sorted(self.accuracy.items(), key=operator.itemgetter(1))\\n self.ready=True\\n return (portfolio, self.rank, self.ranking)\",\n \"def testAggregateDetailedCorrectly(self):\\n\\tscaler = pf.LinearScaler()\\n\\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\\n\\tesc = pf.NoEscalationEscalator()\\n\\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\\n\\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\\n\\n\\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\\n\\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\\n\\n\\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\\n\\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\\n\\n\\n\\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\\n \\n\\tcosts = pf.VariableCosts()\\n costs.add_variable_expense(vex1)\\n costs.add_variable_expense(vex2)\\n\\tcosts.detailed = True\\n\\tend_date = dt.datetime(2034,12,31)\\n costs.build_vex_schedule(end_date)\\n\\t\\n for d in dates:\\n self.assertTrue((vex1.schedule['variable_consumption'] == costs.schedule['Electricity_variable_consumption']).all())\\n\\t self.assertTrue((vex1.schedule['variable_costs'] == costs.schedule['Electricity_variable_costs']).all())\\n\\t self.assertTrue((vex2.schedule['variable_consumption'] == costs.schedule['Biomass_variable_consumption']).all())\\n\\t self.assertTrue((vex2.schedule['variable_costs'] == costs.schedule['Biomass_variable_costs']).all())\",\n \"def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\\n if not self.dates:\\n self.dates = ['2010-01-01', '2012-12-31']\\n self.load_data()\\n\\n num_months = len(self.df_all)\\n first_purchase = True\\n result = {}\\n baseline_result = {}\\n self.baseline_values = [0]\\n self.update_values = [0]\\n months = []\\n\\n # Define dataframe to save output data \\n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\\n self.opt_results_df = pd.DataFrame(columns=headers)\\n row = []\\n\\n self.price_df = pd.DataFrame(columns=self.stocks)\\n\\n # Initialize the plot\\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\\n plt.xticks(list(range(0, num_months, 2)), \\n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\\n plt.locator_params(axis='x', nbins=num_months/2)\\n plt.plot(list(range(0, num_months)), [0]*(num_months), \\n color='red', label=\\\"Break-even\\\", linewidth=0.5)\\n\\n for i in range(3, num_months):\\n\\n # Look at just the data up to the current month\\n df = self.df_all.iloc[0:i+1,:].copy()\\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\\n print(\\\"\\\\nDate:\\\", df.last_valid_index())\\n months.append(df.last_valid_index().date()) \\n\\n if first_purchase:\\n budget = self.budget\\n initial_budget = self.budget\\n baseline_shares = (budget / baseline_df_current.iloc[-1])\\n baseline_result = {self.baseline[0]: baseline_shares} \\n else:\\n # Compute profit of current portfolio\\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \\n self.update_values.append(budget - initial_budget)\\n\\n # Compute profit of fund portfolio\\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \\n for s in self.baseline]) \\n self.baseline_values.append(fund_value - initial_budget)\\n\\n self.budget = budget \\n\\n self.load_data(df=df)\\n\\n self.price_df.loc[i-2] = list(self.price.values)\\n\\n # Output for user on command-line and plot\\n update_values = np.array(self.update_values, dtype=object)\\n baseline_values = np.array(self.baseline_values, dtype=object)\\n plt.plot(range(3, i+1), update_values, \\n color='blue', label=\\\"Optimized portfolio\\\")\\n plt.plot(range(3, i+1), baseline_values, \\n color='gray', label=\\\"Fund portfolio\\\", linewidth=0.5)\\n \\n if first_purchase:\\n plt.legend(loc=\\\"lower left\\\")\\n plt.title(\\\"Start: {start}, End: {end}\\\".format\\\\\\n (start=self.df_all.first_valid_index().date(), \\n end=self.df_all.last_valid_index().date()))\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.pause(0.05)\\n \\n # Making solve run\\n if self.model_type == 'DQM':\\n print(f\\\"\\\\nMulti-Period DQM Run...\\\")\\n \\n self.build_dqm()\\n self.solution['DQM'] = self.solve_dqm()\\n result = self.solution['DQM']\\n else:\\n print(f\\\"\\\\nMulti-Period CQM Run...\\\")\\n\\n # Set budget to 0 to enforce that portfolio is self-financing \\n if self.t_cost and not first_purchase:\\n self.budget = 0 \\n\\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \\n min_return=min_return,\\n init_holdings=init_holdings)\\n result = self.solution['CQM']\\n init_holdings = result['stocks']\\n\\n # Print results to command-line\\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\\n returns = result['return']\\n variance = result['risk'] \\n\\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\\\\n [result['stocks'][s] for s in self.stocks] + \\\\\\n [variance, returns] \\n self.opt_results_df.loc[i-2] = row \\n \\n first_purchase = False\\n\\n print(self.opt_results_df)\\n print(f'\\\\nRun completed.\\\\n')\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.show(block=False)\",\n \"def get_stock_data(stock_name, ma=[],bollinger=[],exp_ma=[],ma_conv=[]):\\n df = xl.parse(stock_name)\\n #df.drop(['VOLUME'], 1, inplace=True)\\n df.set_index('Date', inplace=True)\\n \\n # Renaming all the columns so that we can use the old version code\\n df.rename(columns={'OPEN': 'Open', 'HIGH': 'High', 'LOW': 'Low', 'NUMBER_TICKS': 'Volume', 'LAST_PRICE': 'Adj Close'}, inplace=True)\\n # Percentage change\\n df['Pct'] = df['Adj Close'].pct_change()\\n df.dropna(inplace=True)\\n \\n # Moving Average \\n if ma != []:\\n for moving in ma:\\n df['{}ma'.format(moving)] = df['Adj Close'].rolling(window=moving).mean()\\n # Bollinger \\n if bollinger != []:\\n def bbands(price, length=30, numsd=2):\\n \\\"\\\"\\\" returns average, upper band, and lower band\\\"\\\"\\\"\\n ave = pd.stats.moments.rolling_mean(price,length)\\n sd = pd.stats.moments.rolling_std(price,length)\\n upband = ave + (sd*numsd)\\n dnband = ave - (sd*numsd)\\n return np.round(upband,3), np.round(dnband,3)\\n for moving in bollinger:\\n df['{}bollingerup'.format(moving)],df['{}bollingerdown'.format(moving)] = bbands(df['Adj Close'], length=moving, numsd=2)\\n \\n # Exponential Moving Average \\n if exp_ma != []:\\n for moving in exp_ma:\\n df['{}exp_ma'.format(moving)] = df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving).mean()\\n \\n # Moving Average Convergence \\n if ma_conv!= []:\\n for moving in ma_conv:\\n df['{}ma_conv'.format(moving)] = df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving[0]).mean()-df['Adj Close'].ewm(min_periods=1, adjust=True,com=moving[1]).mean()\\n \\n \\n \\n df.dropna(inplace=True)\\n \\n \\n # Move Adj Close to the rightmost for the ease of training\\n adj_close = df['Adj Close']\\n df.drop(labels=['Adj Close'], axis=1, inplace=True)\\n df = pd.concat([df, adj_close], axis=1)\\n \\n return df\",\n \"def calc_annual_electric_savings (self):\\n price = self.diesel_prices\\n #TODO add rural v non rural\\n self.base_generation_cost = self.electric_diesel_reduction * price\\n\\n\\n self.proposed_generation_cost = self.maintenance_cost\\n\\n self.annual_electric_savings = self.base_generation_cost - \\\\\\n self.proposed_generation_cost\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def stockdon2006(H,L,B):\\n \\n # Make sure parameters are double\\n H = np.double(H)\\n L = np.double(L)\\n B = np.double(B)\\n \\n # Compute incident swash (equation 11) \\n incSwash = 1.1 / 2 * 0.75 * B * (H*L)**0.5\\n \\n # Infragravity swash (Equation 12)\\n igSwash = 1.1 / 2 * 0.06 * (H*L)**0.5\\n \\n # Compute R2% (Equation 19)\\n setup = 1.1 * 0.35 * B * ((H * L)**0.5)\\n swash = 1.1 / 2.0 * (H*L * (0.563 * B**2 + 0.004))**0.5 \\n r2 = setup + swash\\n \\n return r2,setup,incSwash,igSwash\",\n \"def example_reward(self,stock=None, action=None, current_date = None, products=None, orders=None, procurements=None):\\n\\n out = 0\\n for key in stock:\\n out += stock[key]\\n return out * -1\",\n \"def calc_annual_investment(devs, param):\\n\\n observation_time = param[\\\"observation_time\\\"]\\n interest_rate = param[\\\"interest_rate\\\"]\\n q = 1 + param[\\\"interest_rate\\\"]\\n\\n \\n # Calculate capital recovery factor\\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\\n \\n # Calculate annuity factor for each device\\n for device in devs.keys():\\n \\n # Get device life time\\n life_time = devs[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF \\n else:\\n devs[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF \\n \\n\\n return devs\",\n \"def analyse_rsi(stocks_data, oversold=25, overbought=85):\\n print('\\\\n--- RSI ANALYSIS ---')\\n for stock_symbol, df in stocks_data.items():\\n rsi = find_rsi(df)\\n min_rsi = oversold\\n max_rsi = overbought\\n for i in range(len(rsi[1])):\\n r = rsi[1][i]\\n if r < min_rsi:\\n min_rsi = r\\n elif r > max_rsi:\\n max_rsi = r\\n\\n mins = []\\n maxs = []\\n for i in range(len(rsi[1])):\\n r = rsi[1][i]\\n if r <= min_rsi * 1.2:\\n mins.append((rsi[0][i], rsi[1][i]))\\n elif r >= max_rsi * 0.95:\\n maxs.append((rsi[0][i], rsi[1][i]))\\n\\n if mins:\\n print(stock_symbol)\\n [print(m[0], m[1]) for m in mins]\\n if maxs:\\n print(stock_symbol)\\n [print(m[0], m[1]) for m in maxs]\",\n \"def mapk(actual, predicted, k):\\n return round(np.mean([apk(a,p,k) for a,p in zip(actual, predicted)]), 4) * 100\",\n \"def calc_b_a(self, data):\\n # Calculate our expected bid / ask\\n mkt_bid = data['Bid'].values[-1]\\n mkt_ask = data['Ask'].values[-1]\\n last_trade = data['Trade Price'].values[-1]\\n shares = self.calc_shares(data=data, last_trade=last_trade)\\n\\n k = (mkt_bid - mkt_ask) / (mkt_bid + mkt_ask) * -100\\n\\n our_bid = np.average(data['Bid'], weights=self.weights) - k\\n our_ask = np.average(data['Ask'], weights=self.weights) + k\\n\\n self.portfoolio['Unrealized_PnL'] = self.portfoolio['Shares'] * last_trade - self.portfoolio['Avg_Cost'] * self.portfoolio['Shares']\\n\\n if shares == 0:\\n # Skip 0 share orders\\n pass\\n elif abs(self.portfoolio['Cost']) >= self.max_pos * .75:\\n # If position size at or above 95% of max, reduce position\\n self.risk_control(bid=mkt_bid, ask=mkt_ask, last_trade=last_trade)\\n\\n elif our_bid >= mkt_bid:\\n # Buy at bid\\n self.trade(shares=shares, price=mkt_bid, last_trade=last_trade)\\n elif our_ask <= mkt_ask:\\n # Sell at ask\\n self.trade(shares=-shares, price=mkt_ask, last_trade=last_trade)\\n else:\\n print('No order placed')\",\n \"def calcul_buy_nb_action(self):\\n nb_action = self.max_loss / (self.buy_price - self.stop_loss)\\n invest = self.max_loss / (self.buy_price - self.stop_loss) * self.buy_price\\n\\n if invest > self.capital:\\n return round(self.capital / self.buy_price, 9)\\n else:\\n return round(nb_action, 9)\",\n \"def calc_annual_investment(devs, devs_dom, param):\\n\\n observation_time = param[\\\"observation_time\\\"]\\n interest_rate = param[\\\"interest_rate\\\"]\\n q = 1 + param[\\\"interest_rate\\\"]\\n\\n \\n\\n \\n # Calculate capital recovery factor\\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\\n\\n \\n # Balancing Unit devices\\n \\n # Calculate annuity factor for each device\\n for device in devs.keys():\\n \\n # Get device life time\\n life_time = devs[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF \\n else:\\n devs[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF \\n \\n \\n # Building devices\\n \\n for device in devs_dom.keys():\\n \\n # Get device life time\\n life_time = devs_dom[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs_dom[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF\\n else: \\n devs_dom[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF\\n \\n \\n # Distribution devices (pipes, pumps)\\n \\n for dev in [\\\"pipe\\\", \\\"pump\\\"]: #PUmpe fehlt noch\\n \\n # Get device life time\\n life_time = param[dev + \\\"_lifetime\\\"]\\n \\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n param[\\\"ann_factor_\\\" + dev] = (1 - res_value) * CRF \\n else:\\n param[\\\"ann_factor_\\\" + dev] = ( 1 + invest_replacements - res_value) * CRF \\n\\n return devs\",\n \"def _ebit(self):\\n return self.net_income + self.tax_expense + self.interest_expense\",\n \"def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\\n m_over_N = float(m)/N \\n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \\n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)\",\n \"def cash_income(df):\\n return (df.aftertax_income -\\n (1 - tc.HOUSING_CASH_SHARE) * df.housing_ben -\\n (1 - tc.MCAID_CASH_SHARE) * df.mcaid_ben -\\n (1 - tc.MCARE_CASH_SHARE) * df.mcare_ben -\\n (1 - tc.OTHER_CASH_SHARE) * df.other_ben -\\n (1 - tc.SNAP_CASH_SHARE) * df.snap_ben -\\n (1 - tc.SSI_CASH_SHARE) * df.ssi_ben -\\n (1 - tc.TANF_CASH_SHARE) * df.tanf_ben -\\n (1 - tc.VET_CASH_SHARE) * df.vet_ben -\\n (1 - tc.WIC_CASH_SHARE) * df.wic_ben)\",\n \"def Invested_Book_Capital(stock):\\n df = _open_file(stock, 'balance')\\n return _Invested_Book_Capital(df)\",\n \"def stock_average(stock):\\n closing_price=stock['Close']\\n average=stats.mean(closing_price)\\n return average\",\n \"def envisaged_profit(self):\\n profit = round(\\n self.calcul_buy_nb_action() * self.take_profit - self.investment_price(),\\n 2,\\n )\\n percent_profit = round(profit * 100 / self.capital, 2)\\n return profit, percent_profit\",\n \"def main():\\n data = get_sales_data()\\n sales_data = [int(num) for num in data]\\n update_worksheet(sales_data, 'sales')\\n new_surplus_data = calculate_surplus_sandwiches(sales_data)\\n update_worksheet(new_surplus_data, 'surplus')\\n list_of_last_five_sales = get_last_five_sales_entries()\\n stock_data = get_average_sales(list_of_last_five_sales)\\n update_worksheet(stock_data, 'stock')\\n return stock_data\",\n \"def backtest(self, strategy): \\n \\n # load data\\n data = self.import_data(currency_ids = np.unique(self.signals.currency_id),\\n start_date = self.start_date,\\n end_date = self.end_date)\\n \\n # add cash and columns for currencies\\n data[\\\"capital\\\"] = 0\\n data[\\\"actions\\\"] = \\\"\\\" # should become a dictW \\n data[\\\"description\\\"] = \\\"\\\"\\n data[\\\"capital\\\"].iloc[0] = self.initial_capital\\n data[\\\"worth_usd\\\"] = 0\\n \\n for currency_id in np.unique(self.signals.currency_id):\\n data[currency_id + '_position'] = 0\\n \\n # a sell or buy can influence subsequent positions, so calculate iteratively\\n for observation in range(1, len(data.index)):\\n \\n date = data.index[observation]\\n \\n # investment this period is zero\\n investment_capital_period = 0\\n \\n # amount of currency_ids initially same as last period\\n for currency_id in np.unique(self.signals.currency_id):\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] \\n \\n # at each point, compute size of each position (cash and currencies), and record actions\\n if(data.index[observation] in self.signals.index):\\n \\n action_df = pd.DataFrame(columns=list([\\\"Currency\\\",\\\"NominalAmount\\\", \\\"CapitalAmount\\\"]))\\n \\n # could be multiple actions\\n for index, action in self.signals.loc[date].iterrows(): \\n currency_id = action['currency_id']\\n signal = action['signal']\\n \\n # Buy\\n if signal == 1:\\n \\n # buy for 10% currency_id\\n investment_capital = data[\\\"capital\\\"].iloc[observation-1] * 0.10 \\n\\n # estimate how many coins\\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\\n \\n # calculate exact capital needed\\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\\n investment_capital_period = investment_capital_period + investment_capital_exact \\n \\n # change the amount of currency hold\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] + investment_nominal\\n \\n # report action by appending a Series to the (empty) dataframe\\n action_df = action_df.append(pd.Series({\\\"Currency\\\": currency_id, \\n \\\"NominalAmount\\\": investment_nominal, \\n \\\"CapitalAmount\\\": investment_capital_exact}),ignore_index=True)\\n \\n # report description\\n data[\\\"description\\\"].iloc[observation] = (data[\\\"actions\\\"].iloc[observation] + \\\"\\\\n Buy \\\" + \\n str(investment_nominal) + \\\" \\\" + str(currency_id) + \\n \\\" for \\\" + str(investment_capital_exact))\\n \\n # Sell\\n if signal == -1:\\n \\n # sell currency_id for 10% of total capital\\n investment_capital = data[\\\"capital\\\"].iloc[observation-1] * 0.10 \\n \\n # estimate how many coins\\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\\n \\n # calculate exact capital needed\\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\\n investment_capital_period = investment_capital_period - investment_capital_exact\\n \\n # change the amount of currency hold\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] - investment_nominal\\n \\n # report action\\n action_df = action_df.append(pd.Series({\\\"Currency\\\": currency_id, \\n \\\"NominalAmount\\\": investment_nominal, \\n \\\"CapitalAmount\\\": investment_capital_exact}),ignore_index=True)\\n \\n # report description\\n data[\\\"description\\\"].iloc[observation] = data[\\\"actions\\\"].iloc[observation] + \\\"Sell \\\" + str(investment_nominal) + \\\" \\\" + str(currency_id) + \\\" for \\\" + str(investment_capital_exact)\\n \\n # report actions\\n data[\\\"actions\\\"].iloc[observation] = action_df.to_json()\\n \\n # calculate resulting cash capital\\n data[\\\"capital\\\"].iloc[observation] = data[\\\"capital\\\"].iloc[observation-1] - investment_capital_period\\n \\n # calculate worth by capital (usd) and each currency * price\\n data[\\\"worth_usd\\\"].iloc[observation] = data[\\\"capital\\\"].iloc[observation] \\n return data\",\n \"def _calculate_initial_bought(self): #计算初始化的 买卖 方向 ，初始都是OUT\\n bought = {}\\n for s in self.symbol_list: \\n bought[s] = 'OUT'\\n return bought\",\n \"def upper_bound(stock):\\n counter=0\\n for i in stock_price(stock):\\n if i >= resistance(stock):\\n counter+=1\\n return counter\",\n \"def testAggregateCorrectly_simple(self):\\n\\n\\tscaler = pf.LinearScaler()\\n\\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\\n\\tesc = pf.NoEscalationEscalator()\\n\\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\\n\\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\\n\\n\\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\\n\\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\\n\\tend_date = dt.datetime(2034,12,31)\\n\\tvex1.preferred_units['variable_consumption'] = 'kW*hr'\\t\\n\\tvex1.build_vex_schedule(end_date)\\t\\t#Do we need a term here? Yes? How do we control this...through the production? #maybe this should just be passed as an argument\\n\\n\\tdates = [dt.datetime(2015,01,31), dt.datetime(2016,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\\n ###!!!###Still need values here!\\t--should really test escalation here to be sure\\n vals_cost = [22320,22320,22320,22320]\\n vals_cons = [360000,360000,360000,360000]\\n \\t\\n for d, v1, v2 in zip(dates, vals_cons, vals_cost):\\n self.assertAlmostEqual(v1, vex1.schedule.loc[d, 'variable_consumption'],4)\\n\\t self.assertAlmostEqual(v2, vex1.schedule.loc[d, 'variable_costs'],4)\",\n \"def apk(y_true, y_pred, k):\\n \\n # initialize p@k list of values\\n pk_values = []\\n \\n # loop over all k. from 1 to k+1\\n for i in range(1, k + 1):\\n # calculate p@i and append to list\\n pk_values.append(pk(y_true, y_pred, i))\\n \\n # if we have no values in the list, return 0\\n if len(pk_values) == 0:\\n return 0\\n # else, we return the sum of list over length of list\\n return sum(pk_values) / len(pk_values)\",\n \"def MK(df_train, df_test):\\n\\n # number of periods\\n T = df_train.shape[0]\\n\\n # matrix of individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # true outcomes\\n y = df_train.iloc[:, 0].values\\n\\n # initialize agent wealth (sum equal to 1 -> results in convex combination)\\n w = np.full(K, 1/K, dtype=float)\\n\\n # initialize standard deviations\\n sigma = np.full(K, 1, dtype=float)\\n\\n # run market for all observations (training the market)\\n for i in range(T):\\n\\n # individual predictions in the current market\\n ind_pred = F[i, :]\\n\\n # size of bet at the true outcome (kernel evaluated at true outcome)\\n kernel_val = sps.norm.pdf(y[i], loc=ind_pred, scale=sigma)\\n\\n # scale by the size of budget of each agent\\n w_kernel_val = np.multiply(w, kernel_val)\\n\\n # reward agents\\n w = w_kernel_val / np.sum(w_kernel_val)\\n\\n # update sigma\\n abs_error = np.abs(y[i] - ind_pred)\\n sigma = ((i+1)*sigma + abs_error) / (i + 2)\\n\\n # using the trained market for out of sample forecasts\\n # obtain the aggregated market prediction in each test market\\n market_pred = np.dot(F_test, w)\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"Market for Kernels\\\": market_pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def getStockPerformance(stock, start_idx, end_idx, number_years, rounded=True):\\r\\n total_return = (stock['Adj Close'][end_idx]- stock['Adj Close'][start_idx])/stock['Adj Close'][start_idx] + 1\\r\\n total_return_percentage = total_return * 100\\r\\n num = ((total_return ** (1/number_years)) - 1) * 100\\r\\n annual_return = np.round(num, decimals=2) if rounded else num\\r\\n return (total_return_percentage, annual_return)\",\n \"def stoch_apply_nb(high_ts, low_ts, close_ts, k_window, d_window, d_ewm, adjust, cache_dict):\\n h = hash(k_window)\\n roll_min, roll_max = cache_dict[h]\\n percent_k = 100 * (close_ts - roll_min) / (roll_max - roll_min)\\n percent_d = ma_nb(percent_k, d_window, d_ewm, adjust=adjust)\\n return percent_k, percent_d\",\n \"def mid_market_price(orders: pandas.DataFrame):\\n return numpy.mean((best_bid_price(orders), best_ask_price(orders)))\",\n \"def support(stock):\\n output= stock_min(stock)+(stock_min(stock)*.05)\\n return output\",\n \"def stock_price_summary(price_changes):\\n\\n gains = 0.0\\n losses = 0.0\\n\\n for change in price_changes:\\n if change > 0:\\n gains += change\\n elif change < 0:\\n losses += change\\n\\n return (math.floor(gains*100)/100, math.ceil(losses*100)/100)\",\n \"def get_avg(all_stock_data):\\n try:\\n sum_close_vol = 0.0\\n sum_vol = 0.0\\n for item in all_stock_data:\\n adj_close = item[1]\\n volume = item[2]\\n sum_close_vol += adj_close * volume\\n sum_vol += item[2]\\n return sum_close_vol / sum_vol\\n\\n except Exception as e:\\n print(e)\\n exit()\",\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 bvcs():\\r\\n a = float(input(\\\"Please Enter Total Stockholders Equity Value: \\\"))\\r\\n b = float(input(\\\"Please Enter Preferred Equity Value: \\\"))\\r\\n c = float(input(\\\"Please Enter Number of Shares of Common Stock Outstanding: \\\"))\\r\\n d = (float(a)-float(b))/float(c)\\r\\n print \\\">> Your Book Value Per Share of Common Stock is\\\",round(d,2)\",\n \"def _calculate(self):\\n source = self.source\\n res = {}\\n l_cols = [[], [], [], []]\\n r_lines = {}\\n dateline=None\\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\\n if source[t.ror].min() > -99.0:\\n pass\\n else:\\n source[t.ror] = np.where(\\n source[t.ror] > -99.0, source[t.ror], -99.0)\\n ###\\n for account in self.accounts:\\n source_account = source[source[t.account] == account]\\n source_account = source_account.reset_index(drop=True)\\n dateline=source_account[t.effective_date]\\n ror=source_account[t.ror]/100\\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\\n # double_return_cum=round(double_return_cum,2)+1\\n returns_cum = returns_cum + 1\\n growth_amounts = returns_cum * self.starting_value\\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\\\\n round(growth_amounts, 2)\\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\\n 'series': l_cols}\\n res['growth_of_unit'] = {'xAxis': list(dateline),\\n 'series': r_lines}\\n return res\\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\\n # return ret_dict\",\n \"def ATR(stockData , ticker, n):\\n start = dt.datetime(2020, 1, 1)\\n data = pdr.get_data_yahoo(ticker, start)\\n\\n high_low = data['High'] - data['Low']\\n high_close = np.abs(data['High'] - data['Close'].shift())\\n low_close = np.abs(data['Low'] - data['Close'].shift())\\n\\n ranges = pd.concat([high_low, high_close, low_close], axis=1)\\n true_range = np.max(ranges, axis=1)\\n\\n atr = true_range.rolling(n).sum() / n\\n\\n\\n # Returns the Average True Range dataframe / with the dates.\\n return atr\",\n \"def calc_kwta_inhibition(self) -> None:\\n top_m_units = self.units.top_k_net_indices(self.spec.k + 1)\\n g_i_thr_m = self.units.g_i_thr(top_m_units[-1])\\n g_i_thr_k = self.units.g_i_thr(top_m_units[-2])\\n self.gc_i = g_i_thr_m + 0.5 * (g_i_thr_k - g_i_thr_m)\",\n \"def calculate_kpis(cls, rollout_results: Dict) -> Dict[str, float]:\\n service_level = (\\n rollout_results[\\\"info\\\"][\\\"demand\\\"] - rollout_results[\\\"info\\\"][\\\"shortage\\\"]\\n ).sum(axis=-1) / rollout_results[\\\"info\\\"][\\\"demand\\\"].sum(axis=-1)\\n\\n wastage = rollout_results[\\\"info\\\"][\\\"expiries\\\"].sum(axis=-1) / rollout_results[\\n \\\"action\\\"\\n ].sum(axis=(-1))\\n\\n holding_units = rollout_results[\\\"info\\\"][\\\"holding\\\"].mean(axis=-1)\\n demand = rollout_results[\\\"info\\\"][\\\"demand\\\"].mean(axis=-1)\\n order_q = rollout_results[\\\"action\\\"].mean(axis=-1)\\n order_made = (rollout_results[\\\"action\\\"] > 0).mean(axis=-1)\\n\\n return {\\n \\\"service_level_%\\\": service_level * 100,\\n \\\"wastage_%\\\": wastage * 100,\\n \\\"holding_units\\\": holding_units,\\n \\\"demand\\\": demand,\\n \\\"order_quantity\\\": order_q,\\n \\\"wastage_units\\\": rollout_results[\\\"info\\\"][\\\"expiries\\\"].mean(axis=-1),\\n \\\"shortage_units\\\": rollout_results[\\\"info\\\"][\\\"shortage\\\"].mean(axis=-1),\\n \\\"order_made_%\\\": order_made,\\n }\",\n \"def calc_kdj_ma_ema( df ):\\r\\n # ------------------------------------------------------------\\r\\n df['ma5'] = MA( df['close'], 5 )\\r\\n df['ma10'] = MA( df['close'], 10 )\\r\\n df['ma20'] = MA( df['close'], 20 )\\r\\n df['ma30'] = MA( df['close'], 30 )\\r\\n df['ma40'] = MA( df['close'], 40 )\\r\\n df['ma60'] = MA( df['close'], 60 )\\r\\n df['ma89'] = MA( df['close'], 89 )\\r\\n df['ma144'] = MA( df['close'], 144 )\\r\\n df['ma233'] = MA( df['close'], 233 )\\r\\n df['ma377'] = MA( df['close'], 377 )\\r\\n df['ma610'] = MA( df['close'], 610 )\\r\\n\\r\\n kdj1 = KDJ( df, 45, 15, 15 )\\r\\n kdj2 = KDJ( df, 45*5, 15*5, 15*5 )\\r\\n kdj3 = KDJ( df, 45*5*5, 15*5*5, 15*5*5 )\\r\\n kdj4 = KDJ( df, 45*5*5*5, 15*5*5*5, 15*5*5*5 )\\r\\n \\\"\\\"\\\"\\r\\n #ema1 = EMA( kdj1['KDJ_J'], 5 )\\r\\n #ema2 = EMA( kdj2['KDJ_J'], 5*5 )\\r\\n #ema3 = EMA( kdj3['KDJ_J'], 5*5*5 )\\r\\n #ema4 = EMA( kdj4['KDJ_J'], 5*5*5*5 )\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n df['k1'] = kdj1['KDJ_K']\\r\\n df['d1'] = kdj1['KDJ_D']\\r\\n df['j1'] = kdj1['KDJ_J']\\r\\n df['e1'] = EMA( kdj1['KDJ_J'], 5 )\\r\\n\\r\\n df['k2'] = kdj2['KDJ_K']\\r\\n df['d2'] = kdj2['KDJ_D']\\r\\n df['j2'] = kdj2['KDJ_J']\\r\\n df['e2'] = EMA( kdj2['KDJ_J'], 5*5 )\\r\\n\\r\\n df['k3'] = kdj3['KDJ_K']\\r\\n df['d3'] = kdj3['KDJ_D']\\r\\n df['j3'] = kdj3['KDJ_J']\\r\\n df['e3'] = EMA( kdj3['KDJ_J'], 5*5*5 )\\r\\n\\r\\n df['k4'] = kdj4['KDJ_K']\\r\\n df['d4'] = kdj4['KDJ_D']\\r\\n df['j4'] = kdj4['KDJ_J']\\r\\n df['e4'] = EMA( kdj4['KDJ_J'], 5*5*5*5 )\\r\\n\\r\\n df['x1'] = np.nan\\r\\n df['x2'] = np.nan\\r\\n df['x3'] = np.nan\\r\\n df['x4'] = np.nan\\r\\n\\r\\n n = 6\\r\\n x = np.arange( n )\\r\\n\\r\\n yy = df['e1'].values\\r\\n for i in range( n-1, len( df ) ):\\r\\n y1 = df['e1'][i-n+1:i+1].values\\r\\n y2 = df['e2'][i-n+1:i+1].values\\r\\n y3 = df['e3'][i-n+1:i+1].values\\r\\n y4 = df['e4'][i-n+1:i+1].values\\r\\n # print(x)\\r\\n # print(y)\\r\\n z1 = np.polyfit( x, y1, 3 )\\r\\n z2 = np.polyfit( x, y2, 3 )\\r\\n z3 = np.polyfit( x, y3, 3 )\\r\\n z4 = np.polyfit( x, y4, 3 )\\r\\n # print('zzzzzz',z)\\r\\n r1 = z1[0]*x[n-1]*x[n-1]+z1[1]*x[n-1]+z1[2]\\r\\n r2 = z2[0]*x[n-1]*x[n-1]+z2[1]*x[n-1]+z2[2]\\r\\n r3 = z3[0]*x[n-1]*x[n-1]+z3[1]*x[n-1]+z3[2]\\r\\n r4 = z4[0]*x[n-1]*x[n-1]+z4[1]*x[n-1]+z4[2]\\r\\n df['x1'].iat[i] = r1\\r\\n df['x2'].iat[i] = r2\\r\\n df['x3'].iat[i] = r3\\r\\n df['x4'].iat[i] = r4\\r\\n return df\",\n \"def stock_market(no_profiles: int) -> tuple:\\n all_companies = []\\n Stocks = namedtuple(\\\"Stocks\\\", 'name symbol open high close company_weight')\\n MkValue_ = random.uniform(1000, 50000, 100)\\n wts_ = random.uniform(0, 1, 100)\\n wts_ = wts_/sum(wts_)\\n\\n for _ in range(100):\\n name = fake.company()\\n open_ = round(MkValue_[_]*wts_[_],2)\\n close = round(open_ * random.uniform(0.7, 1.15), 2)\\n high = round(open_ * random.uniform(0.85, 1.15), 2)\\n if high < open_:\\n high = open_\\n if high < close:\\n high = close\\n\\n all_companies.append(\\n Stocks(name=name, symbol=symbol(name), open=open_, high=round(high, 2), close=round(close, 2), company_weight=round(wts_[_], 4)))\\n\\n stock_index = round(\\n sum(x.open * x.company_weight for x in all_companies), 4)\\n highest_for_day = round(\\n sum(x.high * x.company_weight for x in all_companies), 2)\\n lowest_close_for_day = round(\\n sum(x.close * x.company_weight for x in all_companies), 2)\\n\\n # print(f\\\"\\\\n------------------------------------Top 100 listed companies on Fake Stock Exchange------------------------------------\\\")\\n # [print(x) for x in sorted(all_companies, key=lambda x:x.symbol)]\\n # print(f\\\"\\\\n--------------Main details on {date.today()}--------------\\\")\\n # print(f\\\"\\\\nStart of the day: {stock_index}\\\")\\n # print(f\\\"Highest for the day: {highest_for_day}\\\")\\n # print(f\\\"Lowest close for the day: {lowest_close_for_day}\\\")\\n return sorted(all_companies, key=lambda x: x.symbol), stock_index, highest_for_day, lowest_close_for_day\",\n \"def back_testing(self, func=None):\\n # preallocate real statistics dict\\n ism_label = []\\n \\n if not self.moving_average:\\n # iterate on all ism packages\\n for _i, ism_pack in enumerate(self.ism_data):\\n ism_code = ism_pack[0][0]\\n interval = float(ism_pack[0][-5])\\n df = self.back_testing_data[ism_code]\\n # using close price only now, check data is/not empty\\n if df.empty:\\n res = np.nan\\n continue\\n else:\\n run_price = df['ClosePrice_run'].sum()\\n stop_price = df['ClosePrice_stop'].sum()\\n res = ((stop_price-run_price)/run_price)*243/interval # 243 market days/year\\n ism_label.append([ism_code, res])\\n \\n else: # using moving_average\\n # iterate on all ism packages\\n # for _i, ism_pack in enumerate(self.ism_data):\\n # ism_code = ism_pack[0][0]\\n # interval = int(ism_pack[0][-5])\\n # df = self.back_testing_data[ism_code]\\n # \\n # # using close price only now\\n # dim = int(len(df)/(L_shift+R_shift-1)) \\n # close_price = np.array_split(df['ClosePrice'], dim)\\n # f1 = lambda x: float(x[-1]-x[0]) # real return for single stock\\n # f2 = lambda x: float(x[0]) # initial value of single stock\\n # if L_shift+R_shift >= interval:\\n # ls1 = np.zeros((L_shift+R_shift-interval,), dtype=np.float32)\\n # ls2 = np.zeros_like(ls1)\\n # for _j, par in enumerate(close_price):\\n # # sum over different stocks in one ism_pack\\n # par_rolling = par.rolling(interval)\\n # ls1 += np.asarray(par_rolling.apply(f1).dropna())\\n # ls2 += np.asarray(par_rolling.apply(f2).dropna())\\n # ism_label[ism_code] = {}\\n # ism_label[ism_code]['real_return'] = (ls1/ls2/interval)\\n # else:\\n # print(\\\"L_shift+R_shift < interval\\\")\\n pass \\n \\n return ism_label\",\n \"def S(self):\\n Ae = 1.0/float(len(self.K)) \\n return (self.avg_Ao() - Ae)/(1.0 - Ae)\",\n \"def calc_annual_electric_savings (self):\\n costs = self.comp_specs['diesel generator o&m']\\n\\n for kW in costs.keys():\\n try:\\n if self.average_load < int(kW):\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n break\\n except ValueError:\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n\\n self.baseline_generation_cost = maintenance + \\\\\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\\n\\n maintenance = self.capital_costs * \\\\\\n (self.comp_specs['percent o&m'] / 100.0)\\n self.proposed_generation_cost = maintenance + \\\\\\n self.intertie_offset_generation_fuel_used * \\\\\\n self.intertie_diesel_prices\\n self.annual_electric_savings = self.baseline_generation_cost -\\\\\\n self.proposed_generation_cost\\n #~ print len(self.annual_electric_savings)\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def avancement(_,K):\\n\\t_=_+1\\n\\t#print(\\\"\\\\t\\\\t\\\\t\\\\t|\\\"+\\\"#\\\"*int(30*_/K)+\\\" \\\"*(30-int(30*_/K))+\\\"|\\\",_, \\\"out of\\\", K, \\\"\\\\t\\\\t\\\", end='\\\\r')\",\n \"def test_interest_vs_stockprice(self):\\n stock_prices = np.array([[5, 10, 20, 40]], dtype=float)\\n interest_rate = 2.0 # 200%\\n test_case = StockMarket(5, stock_prices, interest_rate)\\n test_case.dynamic_programming_bottom_up()\\n for portfolio in set(test_case.backtracing_portfolio()):\\n self.assertEqual(0, portfolio)\",\n \"def _calculate_stocks_after_baseline_period(\\n baseline_stock_raster_path, yearly_accumulation_raster_path, n_years,\\n target_raster_path):\\n # Both of these values are assumed to be defined from earlier in the\\n # model's execution.\\n baseline_nodata = pygeoprocessing.get_raster_info(\\n baseline_stock_raster_path)['nodata'][0]\\n accum_nodata = pygeoprocessing.get_raster_info(\\n yearly_accumulation_raster_path)['nodata'][0]\\n\\n def _calculate_accumulation_over_years(baseline_matrix, accum_matrix):\\n target_matrix = numpy.empty(baseline_matrix.shape, dtype=numpy.float32)\\n target_matrix[:] = NODATA_FLOAT32_MIN\\n\\n valid_pixels = (\\n ~utils.array_equals_nodata(baseline_matrix, baseline_nodata) &\\n ~utils.array_equals_nodata(accum_matrix, accum_nodata))\\n\\n target_matrix[valid_pixels] = (\\n baseline_matrix[valid_pixels] + (\\n accum_matrix[valid_pixels] * n_years))\\n\\n return target_matrix\\n\\n pygeoprocessing.raster_calculator(\\n [(baseline_stock_raster_path, 1),\\n (yearly_accumulation_raster_path, 1)],\\n _calculate_accumulation_over_years, target_raster_path,\\n gdal.GDT_Float32, NODATA_FLOAT32_MIN)\",\n \"def investment_price(self):\\n invest = self.max_loss / (self.buy_price - self.stop_loss) * self.buy_price\\n if invest > self.capital:\\n return round(self.capital, 2)\\n else:\\n return round(invest, 2)\",\n \"def calc_k(self):\\n\\t\\n\\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\\n\\n\\treturn\",\n \"def gamma(self, predictor):\\n pred = predictor(self.X)\\n pred_mean = pred.mean()\\n\\n self.tags[_PREDICTION] = pred\\n expect_event = self.tags.groupby(_EVENT).mean()\\n expect_group_event = self.tags.groupby(\\n [_EVENT, _GROUP_ID]).mean()\\n\\n neg = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 0.0)].groupby([_EVENT]).mean()\\n pos = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 1.0)].groupby([_EVENT]).mean()\\n # print(pos)\\n expect_group_event.loc[('label=1.0', 1), 'pred'] = (pred_mean + self.delta[1] * (pos.loc['label=1.0', 'pred'] - pos.loc['label=0.0', 'pred'])) / 2\\n expect_group_event.loc[('label=0.0', 1), 'pred'] = (pred_mean + self.delta[1] * (pos.loc['label=0.0', 'pred'] - pos.loc['label=1.0', 'pred'])) / 2\\n\\n expect_group_event.loc[('label=1.0', 0), 'pred'] = (pred_mean + self.delta[0] * (neg.loc['label=1.0', 'pred'] - neg.loc['label=0.0', 'pred'])) / 2\\n expect_group_event.loc[('label=0.0', 0), 'pred'] = (pred_mean + self.delta[0] * (neg.loc['label=0.0', 'pred'] - neg.loc['label=1.0', 'pred'])) / 2\\n\\n expect_event = expect_group_event.groupby(_EVENT).mean()\\n expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\\n\\n # expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\\n g_unsigned = expect_group_event[_DIFF]\\n g_signed = pd.concat([g_unsigned, -g_unsigned],\\n keys=[\\\"+\\\", \\\"-\\\"],\\n names=[_SIGN, _EVENT, _GROUP_ID])\\n self._gamma_descr = str(expect_group_event[[_PREDICTION, _DIFF]])\\n return g_signed\",\n \"def mean_payoffs(dist,benefit_function,b,c,*params):\\n dist['A_pay'] = (b*benefit_function(dist.j+1,dist.k+1,*params)-c)*dist.A\\n dist['B_pay'] = (b*benefit_function(dist.j,dist.k+1,*params))*dist.B\\n return dist.groupby('n')[['A_pay','B_pay']].sum()\",\n \"def calc_savings_needed():\\r\\n annual_salary_real = float(input(\\\"Starting Salary: \\\"))\\r\\n #portion_saved = float(input(\\\"Enter the percent of your salary to save, as a decimal: \\\"))\\r\\n total_cost = 1000000#float(input(\\\"Enter the cost of your dream home: \\\"))\\r\\n semi_annual_raise = .07#float(input(\\\"Enter the semi annual raise as decimal: \\\"))\\r\\n portion_down_payment = .25\\r\\n current_savings = 0\\r\\n r = .04;\\r\\n monthly_salary = annual_salary_real / 12 \\r\\n \\r\\n months = 36\\r\\n epsilon = 100\\r\\n low = 0.0\\r\\n high = 1.0\\r\\n guess = (low + high) / 2.0\\r\\n num_guesses = 0\\r\\n breaked = False\\r\\n \\r\\n while(abs(current_savings - total_cost*portion_down_payment) > epsilon):\\r\\n if(guess == 1.0):\\r\\n breaked = True\\r\\n break\\r\\n #print(\\\"new guess: \\\",guess)\\r\\n annual_salary = annual_salary_real\\r\\n monthly_salary = annual_salary/12\\r\\n num_guesses += 1 \\r\\n \\r\\n month = 0\\r\\n current_savings = 0\\r\\n while( month < months):\\r\\n \\r\\n current_savings += (current_savings * r /12) + (guess * monthly_salary)\\r\\n month += 1\\r\\n if ((month % 6) == 0):\\r\\n annual_salary += annual_salary * semi_annual_raise\\r\\n monthly_salary = annual_salary / 12\\r\\n \\r\\n if(abs(current_savings - (total_cost*portion_down_payment)) > epsilon):\\r\\n #print(\\\"current_savings: \\\",current_savings)\\r\\n if(current_savings < (total_cost*portion_down_payment)):\\r\\n low = guess\\r\\n else:\\r\\n high = guess\\r\\n guess = (low + high) / 2.0\\r\\n \\r\\n if(breaked):\\r\\n print(\\\"It is not possible to pay down payment in 3 years.\\\")\\r\\n else: \\r\\n print(\\\"Best savings rate: \\\", guess)\\r\\n print(\\\"Steps in bisection search: \\\", num_guesses)\",\n \"def sum_merch_stock(self):\\n # Load data #\\n df = self.parent.database['tblPoolIndicators']\\n clifr = self.parent.classifiers.set_index(\\\"user_defd_class_set_id\\\")\\n # Our index #\\n index = ['time_step', 'forest_type', 'conifers_broadleaves']\\n # Join #\\n df = (df\\n .set_index('user_defd_class_set_id')\\n .join(clifr)\\n .groupby(index)\\n .agg({'hw_merch': 'sum',\\n 'sw_merch': 'sum'})\\n .reset_index())\\n # Add year and remove TimeStep #\\n df['year'] = self.country.timestep_to_year(df['time_step'])\\n df = df.drop('time_step', axis=1)\\n # Check for mixed species that would produce both hard and soft #\\n import warnings\\n for i, row in df.iterrows():\\n if row['hw_merch'] > 0.0 and row['sw_merch'] > 0.0:\\n warnings.warn(\\\"There is a mixed species at row %i.\\\\n%s\\\" % (i,row))\\n df['mass'] = df['hw_merch'] + df['sw_merch']\\n # calculate the volume in cubic meters over bark #\\n # join density\\n df = df.left_join(self.country.coefficients, 'forest_type')\\n df['volume'] = df['mass'] / df['density']\\n # Only if we are in the calibration scenario #\\n if self.parent.parent.scenario.short_name == 'calibration':\\n # Patch the harvest data frame to stop at the simulation year #\\n selector = df['year'] <= self.country.base_year\\n df = df.loc[selector].copy()\\n # Return #\\n return df\",\n \"def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\\n\\n # number of periods in samples\\n T = df_train.shape[0]\\n T_test = df_test.shape[0]\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # outcomes\\n outcomes = df_train.iloc[:, 0].values\\n\\n # initialize matrices containing all predictions and bets\\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n\\n # budget initialization\\n budgets = np.full(K, 1, dtype=float)\\n\\n # training the market\\n for i in range(T):\\n\\n # first round betting\\n pred_mat[0, :] = F[i, :]\\n bet_mat[0, :] = budgets * MaxRPT_r1\\n budgets = budgets * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F[i, :]\\n bet_mat[j, :] = budgets * MaxRPT\\n budgets = budgets * (1-MaxRPT)\\n\\n # use IQR to determine outlier error threshold\\n abs_errors = np.abs(outcomes[i] - pred_mat)\\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\\n IQR = Q3 - Q1\\n oet = Q3 + (IQR*1.5)\\n\\n # reward the agents based on accuracy of their predictions\\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\\n score = np.log(accuracy)\\n revenue = np.multiply(score, bet_mat)\\n budgets = budgets + np.sum(revenue, axis=0)\\n\\n # rescaling the budget (only for computational reasons)\\n budgets = budgets/np.sum(budgets)\\n\\n # using the market for the out-of-sample predictions\\n pred = np.full(T_test, np.nan, dtype=float)\\n for i in range(T_test):\\n\\n # reset test budget\\n budgets_test = np.copy(budgets)\\n\\n # first round betting\\n pred_mat[0, :] = F_test[i, :]\\n bet_mat[0, :] = budgets_test * MaxRPT_r1\\n budgets_test = budgets_test * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F_test[i, :]\\n bet_mat[j, :] = budgets_test * MaxRPT\\n budgets_test = budgets_test * (1-MaxRPT)\\n\\n # final round market prediction is the c-APM prediction\\n pred[i] = np.dot(\\n pred_mat[no_rounds-1, :],\\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"c-APM (Constant)\\\": pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def apk(actual, predicted, k):\\n\\n if len(predicted)>k:\\n predicted = predicted[:k]\\n \\n score = 0.0\\n num_hits = 0.0\\n\\n for i,p in enumerate(predicted):\\n if p in actual and p not in predicted[:i]:\\n num_hits += 1.0\\n score += num_hits / (i+1.0)\\n\\n if not actual:\\n return 0.0\\n\\n return round(score / min(len(actual), k), 5)\",\n \"def americanprice(self):\\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\\n discount = math.exp( self.r*self.deltatime )\\n for i in range(self.steps,0,-1):\\n for j in range(i):\\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\\n return self.americanpay[0][0]\",\n \"def portfolio_allocation(self, data, total_risk):\\n total_rating = data[\\\"rating\\\"].sum()\\n shares = {}\\n risk_amt = total_risk\\n for _, row in data.iterrows():\\n numshares = int(float(row[\\\"rating\\\"]) / float(total_rating) * float(risk_amt) / float(row[\\\"price\\\"]))\\n if numshares > 10:\\n multiplier = int(numshares / 10)\\n numshares = multiplier * 10\\n shares[row[\\\"symbol\\\"]] = numshares\\n\\n risk_amt -= numshares * row[\\\"price\\\"]\\n # debug\\n # for k, v in shares.items():\\n # print(\\\"[*] Ticker: {}, Shares: {}\\\".format(k, v))\\n return shares\",\n \"def recalculate_emission(self, i, k, corpus):\\n num = sum(sum(self.gamma(i, t, O) for t in xrange(len(O)) if O[t] == k) for O in corpus)\\n denom = sum(sum(self.gamma(i,t, O) for t in xrange(len(O))) for O in corpus)\\n\\n return num / denom\",\n \"def entry_condition(self, wage):\\n \\n #a. solve incumbant firm problem\\n pol_k, pol_n, pi, W = self.incumbant_firm(wage) \\n \\n # b. enter/stay in the market policy function\\n pol_enter=np.zeros((self.Ns,self.ntau)) #1 to enter/stay\\n \\n for i_s in range(self.Ns):\\n for j_t in range(self.ntau):\\n if W[i_s,j_t]>=0:\\n pol_enter[i_s,j_t]=1\\n \\n # c. present discounted value of a potential entrant\\n W_e = np.sum(np.sum( W * self.joint_pdf * pol_enter, axis=0) ) - self.ce\\n \\n return W_e, pol_k, pol_n, pi, W, pol_enter\",\n \"def _K_computations(self, X, X2):\\r\\n if self.ARD:\\r\\n pass\\r\\n else:\\r\\n if X2 is None:\\r\\n self._K_inner_prod = np.dot(X,X.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance+self.bias_variance\\r\\n vec = np.diag(self._K_numer) + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec,vec))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\\r\\n else:\\r\\n self._K_inner_prod = np.dot(X,X2.T)\\r\\n self._K_numer = self._K_inner_prod*self.weight_variance + self.bias_variance\\r\\n vec1 = (X*X).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n vec2 = (X2*X2).sum(1)*self.weight_variance + self.bias_variance + 1.\\r\\n self._K_denom = np.sqrt(np.outer(vec1,vec2))\\r\\n self._K_asin_arg = self._K_numer/self._K_denom\\r\\n self._K_dvar = four_over_tau*np.arcsin(self._K_asin_arg)\",\n \"def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\\n phi = 0.0\\n\\n ## Approach A - NREL Approach\\n if approach_call == \\\"A\\\":\\n\\n phi = float(Q_load_W) / float(Q_design_W)\\n eta_max = 0.425 # from energy.gov\\n\\n if phi >= phi_threshold: # from NREL-Shape\\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\\n\\n if phi < phi_threshold:\\n if phi <= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\\n\\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3.0 + \\\\\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\\n\\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\\\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\\n\\n eta_therm_max = 0.45 # constant, after energy.gov\\n\\n if phi < phi_threshold:\\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\\n\\n else:\\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\\n\\n ## Approach B - Empiric Approach\\n if approach_call == \\\"B\\\":\\n\\n if Q_design_W > 0:\\n phi = float(Q_load_W) / float(Q_design_W)\\n\\n else:\\n phi = 0\\n\\n eta_el_max = 0.39\\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\\n\\n eta_el = eta_el_max * eta_el_score\\n eta_therm = eta_therm_max * eta_therm_score\\n\\n if phi < 0.2:\\n eta_el = 0\\n\\n return eta_el, eta_therm\",\n \"def sector_metrics_fx():\\r\\n global df_sector_metrics\\r\\n \\r\\n df_sector_metrics = df_co_metrics\\r\\n drop_company = ['company_ref']\\r\\n df_sector_metrics.drop(labels = drop_company, axis = 1, inplace = True)\\r\\n df_sector_metrics = df_sector_metrics.groupby(['date_list', 'sector']).agg({'co_inv_overall': 'sum', 'co_inv_50k': 'sum', 'co_inv_100k': 'sum', 'co_inv_manager': 'sum', 'co_inv_sales': 'sum', 'co_inv_key_roles': 'sum', 'co_inv_it': 'sum', 'co_inv_hourly': 'sum','co_fut_cost_overall': 'sum', 'co_fut_cost_50k': 'sum', 'co_fut_cost_100k': 'sum', 'co_fut_cost_manager': 'sum', 'co_fut_cost_sales': 'sum', 'co_fut_cost_key_roles': 'sum', 'co_fut_cost_it': 'sum', 'co_fut_cost_hourly': 'sum','co_inv_overall_28d': 'sum', 'co_inv_50k_28d': 'sum', 'co_inv_100k_28d': 'sum', 'co_inv_manager_28d': 'sum', 'co_inv_sales_28d': 'sum', 'co_inv_key_roles_28d': 'sum', 'co_inv_it_28d': 'sum', 'co_inv_hourly_28d': 'sum','co_fut_cost_overall_28d': 'sum', 'co_fut_cost_50k_28d': 'sum', 'co_fut_cost_100k_28d': 'sum', 'co_fut_cost_manager_28d': 'sum', 'co_fut_cost_sales_28d': 'sum', 'co_fut_cost_key_roles_28d': 'sum', 'co_fut_cost_it_28d': 'sum', 'co_fut_cost_hourly_28d': 'sum'})\",\n \"def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\\n\\n \\\"\\\"\\\"\\n This function calculates American Opportunity Credit\\n for up to four eligible students\\n\\n \\\"\\\"\\\"\\n\\n # Expense should not exceed the cap of $4000.\\n if _cmp == 1:\\n\\n c87482 = max(0., min(e87482, 4000.))\\n c87487 = max(0., min(e87487, 4000.))\\n c87492 = max(0., min(e87492, 4000.))\\n c87497 = max(0., min(e87497, 4000.))\\n else:\\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\\n\\n # Credit calculated as 100% of the first $2000 expense plus\\n # 25% of amount exceeding $2000.\\n if max(0, c87482 - 2000) == 0:\\n c87483 = c87482\\n else:\\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\\n\\n if max(0, c87487 - 2000) == 0:\\n c87488 = c87487\\n else:\\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\\n\\n if max(0, c87492 - 2000) == 0:\\n c87493 = c87492\\n else:\\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\\n\\n if max(0, c87497 - 2000) == 0:\\n c87498 = c87497\\n else:\\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\\n\\n # Sum of credits of all four students.\\n c87521 = c87483 + c87488 + c87493 + c87498\\n\\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\\n c87521)\",\n \"def calc_capital_costs (self):\\n powerhouse_control_cost = 0\\n if not self.cd['switchgear suitable for renewables']:\\n powerhouse_control_cost = self.cd['switchgear cost']\\n\\n #~ road_needed = self.comp_specs['road needed for transmission line']\\n\\n\\n if str(self.comp_specs['transmission capital cost'])\\\\\\n != 'UNKNOWN':\\n transmission_line_cost = \\\\\\n int(self.comp_specs['transmission capital cost'])\\n else:\\n if str(self.comp_specs['distance to resource']) \\\\\\n != 'UNKNOWN':\\n distance = \\\\\\n float(self.comp_specs\\\\\\n ['distance to resource'])\\n transmission_line_cost = \\\\\\n distance*self.comp_specs['est. transmission line cost']\\n\\n secondary_load_cost = 0\\n if self.comp_specs['secondary load']:\\n secondary_load_cost = self.comp_specs['secondary load cost']\\n\\n if str(self.comp_specs['generation capital cost']) \\\\\\n != 'UNKNOWN':\\n wind_cost = \\\\\\n int(self.comp_specs['generation capital cost'])\\n self.cost_per_kw = np.nan\\n else:\\n for i in range(len(self.comp_specs['estimated costs'])):\\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\\\\n self.load_offset_proposed:\\n if i == len(self.comp_specs['estimated costs']) - 1:\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n continue\\n\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n\\n wind_cost = self.load_offset_proposed * cost\\n self.cost_per_kw = cost\\n\\n #~ print powerhouse_control_cost\\n #~ print transmission_line_cost\\n #~ print secondary_load_cost\\n #~ print wind_cost\\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\\\\n secondary_load_cost + wind_cost\\n\\n #~ print 'self.capital_costs',self.capital_costs\",\n \"def dblcal(self, lowstrike, highstrike, expiry1, expiry2):\\n assert lowstrike < highstrike\\n assert pd.Timestamp(expiry1) < pd.Timestamp(expiry2)\\n _rows1 = {}\\n _rows2 = {}\\n _prices1 = {}\\n _prices2 = {}\\n _index = ['Near Call', 'Far Call', 'Call Ratio', 'Near Put', 'Far Put', \\n 'Put Ratio', 'Near to Far Ratio', 'Debit', 'Underlying_Price', 'Quote_Time']\\n _metrics = pd.DataFrame(index=_index, columns=['Value'])\\n _errmsg = \\\"No key for {} strike {} {}\\\"\\n _opttype = 'call'\\n _rows1[_opttype] = _relevant_rows(self.data, (highstrike, expiry1, _opttype),\\n _errmsg.format(expiry1, highstrike, _opttype))\\n _prices1[_opttype] = _getprice(_rows1[_opttype])\\n _rows2[_opttype] = _relevant_rows(self.data, (highstrike, expiry2, _opttype),\\n _errmsg.format(expiry2, highstrike, _opttype))\\n _prices2[_opttype] = _getprice(_rows2[_opttype])\\n _metrics.loc['Near Call', 'Value'] = _prices1[_opttype]\\n _metrics.loc['Far Call', 'Value'] = _prices2[_opttype]\\n _metrics.loc['Call Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\\n _metrics.loc['Underlying_Price', 'Value'], _metrics.loc['Quote_Time', 'Value'] =\\\\\\n _getkeys(_rows1[_opttype], ['Underlying_Price', 'Quote_Time'])\\n _opttype = 'put'\\n _rows1[_opttype] = _relevant_rows(self.data, (lowstrike, expiry1, _opttype),\\n _errmsg.format(expiry1, lowstrike, _opttype))\\n _prices1[_opttype] = _getprice(_rows1[_opttype])\\n _rows2[_opttype] = _relevant_rows(self.data, (lowstrike, expiry2, _opttype),\\n _errmsg.format(expiry2, lowstrike, _opttype))\\n _prices2[_opttype] = _getprice(_rows2[_opttype])\\n _metrics.loc['Near Put', 'Value'] = _prices1[_opttype]\\n _metrics.loc['Far Put', 'Value'] = _prices2[_opttype]\\n _metrics.loc['Put Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\\n _neartot = sum(_prices1.values())\\n _fartot = sum(_prices2.values())\\n _metrics.loc['Near to Far Ratio', 'Value'] = float(_neartot) / _fartot\\n _metrics.loc['Debit', 'Value'] = _fartot - _neartot\\n return _metrics\",\n \"def book_value():\\r\\n a = float(input(\\\"Please Enter Total Stockholders Equity Value: \\\"))\\r\\n b = float(input(\\\"Please Enter Preferred Equity Value: \\\"))\\r\\n c = float(input(\\\"Please Enter Number of Shares of Common Stock Outstanding: \\\"))\\r\\n d = (float(a)-float(b))/float(c)\\r\\n print \\\">> Your Book Value Per Share of Common Stock is\\\",round(d,2)\",\n \"def sell_function(data_points, n_days):\\n\\n prediction_df = model_arima(data_points, n_days)\\n\\n # Calculates the profit for each day predicted taking into account running\\n # costs and compares it with the highest profit so far.\\n profit_array = [None] * (n_days + 1)\\n\\n for count in range(n_days):\\n price = prediction_df.iloc[count][\\\"Prediction\\\"]\\n profit_array[count + 1] = price\\n\\n return profit_array\",\n \"def co_average_metrics_fx():\\r\\n co_inv_overall_28d_list = []\\r\\n co_inv_50k_28d_list = []\\r\\n co_inv_100k_28d_list = []\\r\\n co_inv_manager_28d_list = []\\r\\n co_inv_sales_28d_list = []\\r\\n co_inv_key_roles_28d_list = []\\r\\n co_inv_it_28d_list = []\\r\\n co_inv_hourly_28d_list = []\\r\\n\\r\\n co_fut_cost_overall_28d_list = []\\r\\n co_fut_cost_50k_28d_list = []\\r\\n co_fut_cost_100k_28d_list = []\\r\\n co_fut_cost_manager_28d_list = []\\r\\n co_fut_cost_sales_28d_list = []\\r\\n co_fut_cost_key_roles_28d_list = []\\r\\n co_fut_cost_it_28d_list = []\\r\\n co_fut_cost_hourly_28d_list = []\\r\\n\\r\\n for x in range(len(start_list)):\\r\\n a = start_list[x]\\r\\n b = end_list[x]\\r\\n\\r\\n co_inv_overall_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_overall')].rolling(window=28).mean()\\r\\n co_inv_50k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_50k')].rolling(window=28).mean()\\r\\n co_inv_100k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_100k')].rolling(window=28).mean()\\r\\n co_inv_manager_28d_values = df_co_metrics.iloc[a:b,df_co_metrics.columns.get_loc('co_inv_manager')].rolling(window=28).mean()\\r\\n co_inv_sales_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_sales')].rolling(window=28).mean()\\r\\n co_inv_key_roles_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_key_roles')].rolling(window=28).mean()\\r\\n co_inv_it_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_it')].rolling(window=28).mean()\\r\\n co_inv_hourly_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_inv_hourly')].rolling(window=28).mean()\\r\\n\\r\\n co_fut_cost_overall_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_overall')].rolling(window=28).mean()\\r\\n co_fut_cost_50k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_50k')].rolling(window=28).mean()\\r\\n co_fut_cost_100k_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_100k')].rolling(window=28).mean()\\r\\n co_fut_cost_manager_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_manager')].rolling(window=28).mean()\\r\\n co_fut_cost_sales_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_sales')].rolling(window=28).mean()\\r\\n co_fut_cost_key_roles_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_key_roles')].rolling(window=28).mean()\\r\\n co_fut_cost_it_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_it')].rolling(window=28).mean()\\r\\n co_fut_cost_hourly_28d_values = df_co_metrics.iloc[a:b, df_co_metrics.columns.get_loc('co_fut_cost_hourly')].rolling(window=28).mean()\\r\\n\\r\\n co_inv_overall_28d_list.append(co_inv_overall_28d_values)\\r\\n co_inv_50k_28d_list.append(co_inv_50k_28d_values)\\r\\n co_inv_100k_28d_list.append(co_inv_100k_28d_values)\\r\\n co_inv_manager_28d_list.append(co_inv_manager_28d_values)\\r\\n co_inv_sales_28d_list.append(co_inv_sales_28d_values)\\r\\n co_inv_key_roles_28d_list.append(co_inv_key_roles_28d_values)\\r\\n co_inv_it_28d_list.append(co_inv_it_28d_values)\\r\\n co_inv_hourly_28d_list.append(co_inv_hourly_28d_values)\\r\\n\\r\\n co_fut_cost_overall_28d_list.append(co_fut_cost_overall_28d_values)\\r\\n co_fut_cost_50k_28d_list.append(co_fut_cost_50k_28d_values)\\r\\n co_fut_cost_100k_28d_list.append(co_fut_cost_100k_28d_values)\\r\\n co_fut_cost_manager_28d_list.append(co_fut_cost_manager_28d_values)\\r\\n co_fut_cost_sales_28d_list.append(co_fut_cost_sales_28d_values)\\r\\n co_fut_cost_key_roles_28d_list.append(co_fut_cost_key_roles_28d_values)\\r\\n co_fut_cost_it_28d_list.append(co_fut_cost_it_28d_values)\\r\\n co_fut_cost_hourly_28d_list.append(co_fut_cost_hourly_28d_values)\\r\\n\\r\\n print('avaerages calculated...') \\r\\n df_co_metrics['co_inv_overall_28d'] = pd.concat(co_inv_overall_28d_list)\\r\\n df_co_metrics['co_inv_50k_28d'] = pd.concat(co_inv_50k_28d_list)\\r\\n df_co_metrics['co_inv_100k_28d'] = pd.concat(co_inv_100k_28d_list)\\r\\n df_co_metrics['co_inv_manager_28d'] = pd.concat(co_inv_manager_28d_list)\\r\\n df_co_metrics['co_inv_sales_28d'] = pd.concat(co_inv_sales_28d_list)\\r\\n df_co_metrics['co_inv_key_roles_28d'] = pd.concat(co_inv_key_roles_28d_list)\\r\\n df_co_metrics['co_inv_it_28d'] = pd.concat(co_inv_it_28d_list)\\r\\n df_co_metrics['co_inv_hourly_28d'] = pd.concat(co_inv_hourly_28d_list)\\r\\n\\r\\n df_co_metrics['co_fut_cost_overall_28d'] = pd.concat(co_fut_cost_overall_28d_list)\\r\\n df_co_metrics['co_fut_cost_50k_28d'] = pd.concat(co_fut_cost_50k_28d_list)\\r\\n df_co_metrics['co_fut_cost_100k_28d'] = pd.concat(co_fut_cost_100k_28d_list)\\r\\n df_co_metrics['co_fut_cost_manager_28d'] = pd.concat(co_fut_cost_manager_28d_list)\\r\\n df_co_metrics['co_fut_cost_sales_28d'] = pd.concat(co_fut_cost_sales_28d_list)\\r\\n df_co_metrics['co_fut_cost_key_roles_28d'] = pd.concat(co_fut_cost_key_roles_28d_list)\\r\\n df_co_metrics['co_fut_cost_it_28d'] = pd.concat(co_fut_cost_it_28d_list)\\r\\n df_co_metrics['co_fut_cost_hourly_28d'] = pd.concat(co_fut_cost_hourly_28d_list)\\r\\n print(columns added...)\",\n \"def get_greatest_stock_price():\\n greatest_stock_price = 0\\n // your code here\",\n \"def doSummary(self):\\n for name in self.stockList:\\n tempVolume=0.\\n for dateStr in self.listOfDates:\\n rawTradeDataPath = FileNames.BinRTTradesDir + '/' + dateStr + '/' + name + '_trades.binRT'\\n tradeReader = TAQTradesReader(rawTradeDataPath)\\n tempVolume=tempVolume+np.nansum(tradeReader._s)/10000.0 # divide 10000 because otherwise the sum could exceed the range of int32\\n self.dict[name]=tempVolume\",\n \"def compute_derbeko_2007_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05): \\n m_over_N = float(m)/N \\n log_complexity_term = 7 * log( m*(N+1) )\\n return empirical_gibbs_risk + sqrt( ((1.-m_over_N)/(2*m-2)) * (KLQP + log_complexity_term - log(delta) ) )\",\n \"def __cacula_agio(table):\\n from m2py.misc.vectorize import column\\n\\n PV = table[0][-1]\\n total = sum(column(table, 1))\\n premium = total/PV - 1\\n return round(premium, 2)\",\n \"def getAvgMarketCosts(self):\\n try:\\n avgAL = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldAL']\\n avgEC = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldEC']\\n avgIA = self.frame.mode.game.marketStats[str(self.frame.mode.game.currentRound-1)]['avgSoldIA']\\n except:\\n avgAL = 0.0\\n avgEC = 0.0\\n avgIA = 0.0\\n \\n return (avgAL, avgEC, avgIA)\",\n \"def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n\\n for i in range(total_days):\\n if i==0:\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n elif i==total_days-1: # last day\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n invt_daily_list.append(today_invt_dict)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Baseline Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Baseline (1st day buy->hold->last day sell) Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\\n return\",\n \"def invest(self, new_positions):\\n\\n # Add three columns to df and initialize\\n new_positions.loc[:, Consts.FULLY_INVESTED] = False\\n new_positions.loc[:, Consts.CAPITAL_TO_INVEST] = 0\\n new_positions.loc[:, Consts.LEVERAGED_CAPITAL] = 0\\n\\n # Available capital for current round\\n available_capital = self.liquid_capital * self.max_percent_cap_investment_in_a_round\\n\\n if available_capital < self.min_investment:\\n logger.debug(\\n \\\"The available capital for this round is smaller then the min investment. There are no new positions for time:{}\\\".format(\\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\\n return\\n\\n # Adds 'capital_to_invest' column and 'fully_invested' column to each row\\n new_positions = self.capital_allocation_strategy(new_positions,\\n available_capital)\\n\\n if len(new_positions) == 0:\\n logger.debug(\\n \\\"There are no new positions for time:{}\\\".format(\\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\\n return\\n\\n # If simulation has leverage, fills Consts.LEVERAGE_CAPITAL with relevant leverage\\n if self.leverage > 1:\\n new_positions = self.add_leverage_by_conditions(new_positions)\\n\\n # Create new positions\\n for index, position in new_positions.iterrows():\\n order_type = position['order_type']\\n\\n # Create a new position\\n pos = Position.Position(position['coin_symbol'], order_type, self.time_ticker,\\n position['high_boundary'], position['low_boundary'],\\n position['capital_to_invest'] + position[Consts.LEVERAGED_CAPITAL],\\n self.trailing_strategy, self.fees, position[Consts.LEVERAGED_CAPITAL],\\n self.apply_leverage_fees_on_all_capital, self.leverage, self.long_trailing_strategy,\\n self.short_trailing_strategy, position['time_predict'],\\n self.active_long_investment_strategy, self.active_short_investment_strategy)\\n\\n # Allocates each order to its relevant statistics\\n if order_type == Consts.SHORT:\\n self.active_short_positions.append(pos)\\n self.short_capital += pos.get_current_liquid_capital()\\n else:\\n self.active_long_positions.append(pos)\\n self.long_capital += pos.get_current_liquid_capital()\\n\\n # Update portfolio liquid capital and leverage capital\\n self.liquid_capital -= pos.get_current_liquid_capital()\\n self.leverage_capital += pos.leverage_capital\\n\\n logger.debug(\\\"Finished investment cycle for time {}\\\".format(\\n TimeHelper.epoch_to_date_time(self.time_ticker.current_time)))\\n logger.debug(\\n \\\"liquid capital: {}, leverage capital: {}, long capital: {}, short capital: {}\\\".format(self.liquid_capital,\\n self.leverage_capital,\\n self.long_capital,\\n self.short_capital))\",\n \"def ALRA(X, k=None, n_iter=10):\\n if k is None:\\n k = choose_k(X)\\n log.info(f\\\"No `k` given. Automatically determined `k={k}`.\\\")\\n\\n # Compute the SVD and compute the rank-k reconstruction\\n U, s, Va = pca(X, k=k, n_iter=n_iter, raw=True)\\n X_rank_k = U * s @ Va\\n\\n X_rank_k = np.ma.masked_array(X_rank_k)\\n\\n # Find the absolute values of the minimum expression levels for each gene\\n minimum_expressions = np.abs(np.min(X_rank_k, axis=0))\\n # Zero out all expressions with values below the gene minimum value\\n X_rank_k[X_rank_k <= minimum_expressions] = np.ma.masked\\n\\n # Rescale the expressions so the first two moments match the original matrix\\n X_mean, X_std = nonzero_mean(X, axis=0), nonzero_std(X, axis=0, ddof=1)\\n X_rk_mean, X_rk_std = X_rank_k.mean(axis=0), X_rank_k.std(axis=0, ddof=1)\\n\\n scale = X_std / X_rk_std\\n translate = -X_rk_mean * scale + X_mean\\n\\n scale_columns = ~np.isnan(X_std) & ~np.isnan(X_rk_std)\\n X_rank_k[:, scale_columns] *= scale[scale_columns]\\n X_rank_k[:, scale_columns] += translate[scale_columns]\\n\\n # Values can become negative during rescaling, so we zero those out\\n X_rank_k[X_rank_k < 0] = np.ma.masked\\n\\n # Restore potentially zeroed out expression values which appeared in the\\n # original expression matrix. Where both values are non-zero, prefer the\\n # rank-k approximation\\n zeroed_out_indices = find_zeroed_indices(X_rank_k, X)\\n X_rank_k[zeroed_out_indices] = X[zeroed_out_indices]\\n\\n log.info(\\n f\\\"{len(zeroed_out_indices[0])} original expression values were \\\"\\n f\\\"zeroed out during imputation and restored to original values.\\\"\\n )\\n\\n X_rank_k = X_rank_k.filled(0)\\n\\n return X_rank_k\",\n \"def overall_reduction(self):\\n return 84\",\n \"def BacktestStrategy2(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n recent_max=0 # recent max = 전고점 가격\\n for i in range(total_days):\\n if i==0: # 첫날은 일단 풀매수\\n recent_max=stock_exchange.GetDayHighestPrice(i)\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n else: # 다른날은 전부 전략대로 수행\\n recent_max=max(recent_max, stock_exchange.GetDayHighestPrice(i-1)) # 전고점 갱신 확인\\n # 만약 어제 종가가 전고점*threshold 미만이라면: 풀매도 \\n if (stock_exchange.GetDayClosePrice(i-1) < \\n (start_cond_dict['sell_threshold_percent']/100)*recent_max):\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n # 매도조건을 만족 안 시킨 상황에서 n개월 모멘텀이 (+)면: 풀매수 -- n개월이 안지났으면 스킵\\n elif (i > start_cond_dict['buy_momentum_days'] and \\n stock_exchange.GetDayHighestPrice(i-start_cond_dict['buy_momentum_days']) <\\n stock_exchange.GetDayOpenPrice(i)):\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n # 나머지 상황에선 포지션 홀드\\n else:\\n pass\\n invt_daily_list.append(today_invt_dict)\\n #print(today_invt_dict) # for debug :)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Experimental Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Experimental Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\",\n \"def _ei_halluc_acq(x):\\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\\n Z = (mu - curr_best) / sigma\\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)\",\n \"def summary(self, risk_free=None, market_return=None, top_holdings=None, round_digit=4):\\n\\n moment_dict = defaultdict(lambda: \\\"Moment\\\")\\n moment_dict[3] = \\\"Skewness\\\"\\n moment_dict[4] = \\\"Kurtosis\\\"\\n\\n weight_dict = dict(zip(self.assets, self.weight_sols))\\n metric_dict = {'Expected Return': self.metric_creator.expected_return(self.weight_sols),\\n \\\"Leverage\\\": self.metric_creator.leverage(self.weight_sols),\\n \\\"Number of Holdings\\\": self.metric_creator.num_assets(self.weight_sols)}\\n\\n # Portfolio Composition\\n if top_holdings:\\n metric_dict[f\\\"Top {top_holdings} Holdings Concentrations\\\"] = self.metric_creator.concentration(\\n self.weight_sols, top_holdings)\\n\\n # Risk Only\\n if self.moment == 2:\\n metric_dict[\\\"Volatility\\\"] = self.metric_creator.volatility(self.weight_sols)\\n # metric_dict[\\\"Correlation\\\"] = self.metric_creator.correlation(self.weight_sols)\\n else:\\n metric_dict[f'{moment_dict[int(self.moment)]}'] = self.metric_creator.higher_moment(self.weight_sols)\\n\\n # Risk-Reward\\n if self.beta_vec is not None:\\n metric_dict[\\\"Portfolio Beta\\\"] = self.metric_creator.beta(self.weight_sols)\\n\\n if risk_free is not None:\\n metric_dict[\\\"Sharpe Ratio\\\"] = self.metric_creator.sharpe(self.weight_sols, risk_free)\\n\\n if self.beta_vec is not None and risk_free is not None:\\n metric_dict[\\\"Treynor Ratio\\\"] = self.metric_creator.treynor(self.weight_sols, risk_free)\\n if market_return is not None:\\n metric_dict[\\\"Jenson's Alpha\\\"] = self.metric_creator.jenson_alpha(self.weight_sols, risk_free, market_return)\\n\\n for item in metric_dict:\\n metric_dict[item] = np.round(metric_dict[item], round_digit)\\n\\n weight_dict = {k: v for k, v in weight_dict.items() if v}\\n return weight_dict, metric_dict\",\n \"def gamma(self, predictor):\\n pred = predictor(self.X)\\n self.tags[_PREDICTION] = pred\\n expect_event = self.tags.groupby(_EVENT).mean()\\n expect_group_event = self.tags.groupby(\\n [_EVENT, _GROUP_ID]).mean()\\n\\n num_grp = len(self.error_rate)\\n tprs = [0 for _ in range(num_grp)]\\n # print(expect_group_event)\\n for i in range(num_grp):\\n tprs[i] = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == i)].groupby([_EVENT]).mean()\\n expect_group_event.loc[('label=1', i), 'pred'] = (1 - self.error_rate[i][0]) * tprs[i].loc['label=1', 'pred'] + self.error_rate[i][0] * tprs[i].loc['label=0', 'pred']\\n expect_group_event.loc[('label=0', i), 'pred'] = (1 - self.error_rate[i][1]) * tprs[i].loc['label=0', 'pred'] + self.error_rate[i][1] * tprs[i].loc['label=1', 'pred']\\n\\n # neg = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 0.0)].groupby([_EVENT]).mean()\\n # pos = expect_group_event.loc[(expect_group_event.index.get_level_values(_GROUP_ID) == 1.0)].groupby([_EVENT]).mean()\\n\\n # expect_group_event.loc[('label=1.0', 1), 'pred'] = (1 - self.error_rate[1][0]) * pos.loc['label=1.0', 'pred'] + self.error_rate[1][1] * pos.loc['label=0.0', 'pred']\\n # expect_group_event.loc[('label=0.0', 1), 'pred'] = (1 - self.error_rate[1][1]) * pos.loc['label=0.0', 'pred'] + self.error_rate[1][0] * pos.loc['label=1.0', 'pred']\\n\\n # expect_group_event.loc[('label=1.0', 0), 'pred'] = (1 - self.error_rate[0][0]) * neg.loc['label=1.0', 'pred'] + self.error_rate[0][1] * neg.loc['label=0.0', 'pred']\\n # expect_group_event.loc[('label=0.0', 0), 'pred'] = (1 - self.error_rate[0][1]) * neg.loc['label=0.0', 'pred'] + self.error_rate[0][0] * neg.loc['label=1.0', 'pred']\\n\\n expect_event = expect_group_event.groupby(_EVENT).mean()\\n expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\\n\\n # expect_group_event[_DIFF] = expect_group_event[_PREDICTION] - expect_event[_PREDICTION]\\n g_unsigned = expect_group_event[_DIFF]\\n g_signed = pd.concat([g_unsigned, -g_unsigned],\\n keys=[\\\"+\\\", \\\"-\\\"],\\n names=[_SIGN, _EVENT, _GROUP_ID])\\n self._gamma_descr = str(expect_group_event[[_PREDICTION, _DIFF]])\\n return g_signed\",\n \"def calc_annual_heating_savings (self):\\n price = self.diesel_prices + self.cd['heating fuel premium']\\n maintenance = self.comp_specs['heat recovery o&m']\\n self.annual_heating_savings = -1 * \\\\\\n (maintenance + (self.lost_heat_recovery * price))\",\n \"def compute_portvals(start_date, end_date, orders_file, start_val):\\n \\n #Read order file\\n orders = pd.read_csv( orders_file, parse_dates = [0])\\n \\n #Get symbols making up the portfolio\\n stock_symbols = list( set( orders[\\\"Symbol\\\"] ) )\\n dates = pd.date_range(start_date, end_date)\\n \\n #Read stock prices\\n stock_prices = get_data(stock_symbols, dates)\\n \\n #Create a portfolio keeping track of positions, \\n #_CASH column indicates cash position, _VALUE total portfolio value\\n #_LEVERAGE the leverage of portfolio when we allow for short selling\\n symbols = stock_symbols[:] #Shallow copy of the list\\n symbols.append(\\\"_CASH\\\")\\n symbols.append(\\\"_VALUE\\\")\\n symbols.append(\\\"_LEVERAGE\\\")\\n \\n #Index contains only business days, same dates as stock prices\\n portfolio = pd.DataFrame(index=stock_prices.index, columns = symbols )\\n portfolio.fillna(0) \\n portfolio[\\\"_CASH\\\"][0] = start_val\\n portfolio[\\\"_VALUE\\\"][0] = start_val\\n \\n #Snapshot of a portfolio at any time. To avoid using numerical indexes\\n portfolio_snapshot = dict.fromkeys ( symbols, 0 )\\n portfolio_snapshot[\\\"_CASH\\\"] = start_val\\n portfolio[\\\"_VALUE\\\"] = start_val\\n \\n #Now calcualte portfolio day by day\\n for date in portfolio.index:\\n #Check transactions for the day\\n day_orders = orders[ orders[\\\"Date\\\"] == date ] \\n \\n for ord in day_orders.iterrows():\\n symbol = ord[1][ \\\"Symbol\\\"] \\n stock_price = stock_prices[ symbol ][ date ]\\n shares = ord[1][\\\"Shares\\\" ]\\n side = ord[1][\\\"Order\\\"]\\n \\n if side == \\\"BUY\\\":\\n portfolio_snapshot[ \\\"_CASH\\\" ] -= stock_price * shares\\n portfolio_snapshot[ symbol ] += shares \\n elif side == \\\"SELL\\\":\\n portfolio_snapshot[ \\\"_CASH\\\" ] += stock_price * shares\\n portfolio_snapshot[ symbol ] -= shares\\n else:\\n raise \\\"Order not recognized.\\\"\\n \\n #Compute portfolio value\\n portfolio_snapshot[ \\\"_VALUE\\\" ] = portfolio_snapshot[ \\\"_CASH\\\" ]\\n shorts = longs = 0\\n for symbol in stock_symbols: \\n stock_price = stock_prices[ symbol ][ date ]\\n shares = portfolio_snapshot[ symbol ]\\n notional = stock_price*shares\\n if shares > 0:\\n longs += notional\\n else:\\n shorts += notional\\n \\n portfolio_snapshot[ \\\"_VALUE\\\" ] += notional\\n \\n #Compute leverage\\n leverage = (longs+shorts)/(longs-shorts + portfolio_snapshot[ \\\"_CASH\\\" ] )\\n portfolio_snapshot[ \\\"_LEVERAGE\\\" ] = leverage\\n \\n #Assert we never achieve a leverage > 2.0\\n if leverage > 2:\\n raise \\\"Leverage > 2.0 achieved\\\"\\n \\n #Update portfolio from the daily snapshot\\n #TODO: Is this causing performance issues?\\n for symbol in portfolio.keys():\\n portfolio[ symbol ][ date ] = portfolio_snapshot[ symbol ]\\n \\n return portfolio\",\n \"def getIdealSec(context, data): #This replaced before_trading_start(context, data)\\n record(Leverage = \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t context.account.leverage,pos=len(context.portfolio.positions))\\n context.output = pipeline_output('my_pipeline')\\n #print('Pipeout: ')\\n #print(context.output)\\n \\n # These are the securities that we are interested in trading each day.\\n # Note: As it stands, the securities in this list are from two different industries (defense and\\n # consumer electronics). Although more computationally expensive then dividing them out into their \\n # two respective industries prior to cross correlating, leaving them in the same matrix/data set and \\n # cross correlating them gives us a way to 'check' that the crosscorrelation is valid, since securities within the same industry should typically cross correlate to a higher degree than across industries. ***\\n context.security_list = context.output.index \\n context.defenseList = context.output[context.output['defenseFilt']].index.tolist()\\n #print(context.defenseList)\\n context.autoList = context.output[context.output['autoFilt']].index.tolist()\\n #print(context.autoList)\\n context.chemList = context.output[context.output['chemFilt']].index.tolist()\\n #print(context.chemList)\\n context.techList = context.output[context.output['techFilt']].index.tolist()\\n #print(context.techList)\\n context.depList = context.output[context.output['depFilt']].index.tolist()\\n # Within each sector, calculate the mean (and max, since we may choose only to trade the maximally correlated securities regardless of industry) crosscorrelation between all combinations of stocks. \\n #This will only run every trading day to prevent computational expense. In that \\n #respect, performs identically to a pipeline add-on (but allows the use of \\\"history\\\") \\n #Try block here incase pipe returns no valid securities. \\n try:\\n \\tprice_history = np.transpose(data.history(context.security_list, fields=\\\"price\\\", bar_count=context.lookback,frequency=\\\"1m\\\"))\\n \\tprice_history=price_history.as_matrix()\\n except:\\n price_history=[[0],[0],[0]]\\n #This returns three arrays, containing a filtered set of maximally cross correlated securities within the last time range (given by context.lookback), their associated (and filtered) time delays corresponding to their maximum correlation, and the degree of their correlation in the given time frame. Essentially, since tau has already been filtered for, the degree of their correlation should be used as a confidence feature to make predictions off of, and tau should be used to determine when to make purchases/sales. \\n #hCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context)\\n #The best securities to trade using this algorithm (each day) are listed in the below lists ***\\n try:\\n \\thCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context) \\n except: \\n print('Crosscorr Failed')\\n maxSecs,hCorrVals,timeDelays,short_timeDelays=[],[],[],[]\\n #\\\"Globalize\\\" the returned information so that we can handle these commodities every minute. \\n context.Securities=maxSecs\\n context.CorrVals=hCorrVals\\n context.timeDelays=short_timeDelays #************Used to be timeDelays, now however, we calculate a more recent tau\\n context.actionList,context.timerList,context.tradeList,context.tradingNow=[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities) #list of zeros indicating that no stocks should currently be trading\\n #(Note that all stocks should be sold at end of every tradinng day.) \"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5929503","0.581313","0.5744221","0.5742783","0.55948293","0.5589375","0.5517828","0.54931015","0.5415928","0.5380793","0.53703797","0.53422695","0.53379637","0.53265834","0.5309885","0.5304519","0.53018254","0.5298242","0.52609056","0.5260335","0.5260074","0.5247564","0.52303785","0.5216973","0.52114296","0.5208262","0.5188705","0.51801175","0.51705885","0.51684153","0.5154608","0.5151247","0.5149958","0.51490104","0.5139096","0.5115209","0.51049596","0.51001984","0.5097385","0.50899","0.5088356","0.508365","0.5067079","0.5062401","0.50599235","0.50551456","0.50442386","0.50263333","0.5022974","0.5011413","0.5009068","0.5007333","0.4993671","0.49887344","0.4986815","0.4979072","0.49751598","0.49747586","0.4971607","0.4969276","0.4964714","0.495998","0.49520066","0.49519432","0.4950877","0.49441433","0.49424863","0.4934985","0.49246442","0.49180228","0.49132955","0.49102417","0.4899552","0.4898098","0.4895839","0.4892974","0.48916423","0.48907828","0.48895937","0.48813304","0.4872044","0.4869437","0.48691088","0.4862324","0.48584294","0.4855043","0.48517385","0.48511556","0.48507187","0.48496872","0.48378775","0.48369837","0.48364016","0.48338515","0.48321745","0.4830939","0.48289427","0.48236698","0.48131242","0.48083356","0.4808255"],"string":"[\n \"0.5929503\",\n \"0.581313\",\n \"0.5744221\",\n \"0.5742783\",\n \"0.55948293\",\n \"0.5589375\",\n \"0.5517828\",\n \"0.54931015\",\n \"0.5415928\",\n \"0.5380793\",\n \"0.53703797\",\n \"0.53422695\",\n \"0.53379637\",\n \"0.53265834\",\n \"0.5309885\",\n \"0.5304519\",\n \"0.53018254\",\n \"0.5298242\",\n \"0.52609056\",\n \"0.5260335\",\n \"0.5260074\",\n \"0.5247564\",\n \"0.52303785\",\n \"0.5216973\",\n \"0.52114296\",\n \"0.5208262\",\n \"0.5188705\",\n \"0.51801175\",\n \"0.51705885\",\n \"0.51684153\",\n \"0.5154608\",\n \"0.5151247\",\n \"0.5149958\",\n \"0.51490104\",\n \"0.5139096\",\n \"0.5115209\",\n \"0.51049596\",\n \"0.51001984\",\n \"0.5097385\",\n \"0.50899\",\n \"0.5088356\",\n \"0.508365\",\n \"0.5067079\",\n \"0.5062401\",\n \"0.50599235\",\n \"0.50551456\",\n \"0.50442386\",\n \"0.50263333\",\n \"0.5022974\",\n \"0.5011413\",\n \"0.5009068\",\n \"0.5007333\",\n \"0.4993671\",\n \"0.49887344\",\n \"0.4986815\",\n \"0.4979072\",\n \"0.49751598\",\n \"0.49747586\",\n \"0.4971607\",\n \"0.4969276\",\n \"0.4964714\",\n \"0.495998\",\n \"0.49520066\",\n \"0.49519432\",\n \"0.4950877\",\n \"0.49441433\",\n \"0.49424863\",\n \"0.4934985\",\n \"0.49246442\",\n \"0.49180228\",\n \"0.49132955\",\n \"0.49102417\",\n \"0.4899552\",\n \"0.4898098\",\n \"0.4895839\",\n \"0.4892974\",\n \"0.48916423\",\n \"0.48907828\",\n \"0.48895937\",\n \"0.48813304\",\n \"0.4872044\",\n \"0.4869437\",\n \"0.48691088\",\n \"0.4862324\",\n \"0.48584294\",\n \"0.4855043\",\n \"0.48517385\",\n \"0.48511556\",\n \"0.48507187\",\n \"0.48496872\",\n \"0.48378775\",\n \"0.48369837\",\n \"0.48364016\",\n \"0.48338515\",\n \"0.48321745\",\n \"0.4830939\",\n \"0.48289427\",\n \"0.48236698\",\n \"0.48131242\",\n \"0.48083356\",\n \"0.4808255\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84677,"cells":{"query":{"kind":"string","value":"Directly solve each generation's optimal a', c and n In this case, apath, cpath and npath store agents' policy functions In the other case of value interation, the above three paths are calculated from each generation's value functions."},"document":{"kind":"string","value":"def IteratePaths(self):\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n a1, aT = [-1,], []\n\n for q in range(self.Nq):\n if q == 0:\n self.apath[-1] = 0.2\n elif q == 1:\n self.apath[-1] = 0.3\n else:\n self.apath[-1] = max(0,aT[-1]-(aT[-1]-aT[-2])*a1[-1]/(a1[-1]-a1[-2]))\n \n self.npath[-1] = 0\n self.cpath[-1] = self.apath[-1]*(1+self.r) + self.b\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n self.apath[y], self.npath[y], self.cpath[y] = self.DirectSolve(y)\n\n aT.append(self.apath[-1])\n a1.append(self.apath[-self.T])\n if (fabs(self.apath[-self.T])<self.tol):\n break\n for y in range(-1,-(self.T+1),-1):\n self.upath[y] = self.util(self.cpath[y],self.npath[y])"},"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 solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def solve_csp(nodes, arcs, max_steps):\n\n nodes = list(nodes)\n print 'nodes:', nodes\n\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\n print 'initial random assignment', node_values_dict\n indexes = np.arange(len(nodes))\n\n graph = {}\n for arc in arcs:\n if not arc[0] in graph:\n graph[arc[0]] = []\n if not arc[1] in graph:\n graph[arc[1]] = []\n graph[arc[0]].append(arc[1])\n graph[arc[1]].append(arc[0])\n for i in indexes:\n if i in graph:\n continue\n else:\n graph[i] = []\n graph = dict(sorted(graph.items()))\n print 'graph:', graph\n\n domain = [i for i in np.arange(1, 10, 1)]\n print 'initial domain for each node:', domain\n\n superAdjacency ={}\n for i in np.arange(len(nodes)):\n superAdjacency[i] = []\n superAdjacency[i].append(nodes[i])\n superAdjacency[i].append(node_values_dict[nodes[i]])\n superAdjacency[i].append(graph[i])\n superAdjacency[i].append(domain)\n\n print 'superAdjacency', superAdjacency\n\n def getNodeType(superAdjacency, index):\n return list(superAdjacency[index])[0]\n\n def getCurrentAssignment(superAdjacency, index):\n return list(superAdjacency[index])[1]\n\n def getCurrentAssignmentForList(superAdjacency, indexList):\n return [int(list(superAdjacency[index])[1]) for index in indexList]\n\n def getSolution(superAdjacency):\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\n\n def getNeighbours(superAdjacency, index):\n return list(superAdjacency[index])[2]\n\n def getDomain(superAdjacency, index):\n return list(superAdjacency[index])[3]\n\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\n updateList =[]\n for i in superAdjacency:\n if str(getNodeType(superAdjacency, i)) == nodeType:\n updateList.append(i)\n for i in updateList:\n superAdjacency[i][1] = newValue\n\n def isSolution():\n return graphConstraints(superAdjacency)\n\n def graphConstraints(superAdjacency):\n graphEval = []\n\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n\n if nodeType == 'T':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\n elif nodeType == 'C':\n return 'NA'\n elif nodeType == 'S':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\n elif nodeType == 'H':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\n if nodeType == 'P':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\n\n currentAssignment = [item[1] for item in superAdjacency.values()]\n difference = map(sub, currentAssignment, graphEval)\n\n if sum(difference) == 0:\n return True\n else:\n return difference\n\n def findConflictVariable(superAdjacency, lastUpdateNode):\n node_conflict_count = {}\n for node in node_values_dict:\n node_conflict_count[node] = 0\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n if nodeType == 'T':\n try:\n if getCurrentAssignment(superAdjacency, index) != \\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'S':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'H':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n if nodeType == 'P':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n choices = [k for k, v in node_conflict_count.items() if v > 0]\n if len(choices) > 0:\n updateNode = random.choice(choices)\n\n if updateNode == lastUpdateNode:\n choices.pop(choices.index(updateNode))\n try:\n lastUpdateNode = random.choice(choices)\n return lastUpdateNode, lastUpdateNode\n except:\n return lastUpdateNode, lastUpdateNode\n else:\n lastUpdateNode = updateNode\n return updateNode, lastUpdateNode\n else:\n return 'NA', 'NA'\n\n\n\n def valueForConflictedVariable(superAdjacency, var):\n for index in superAdjacency:\n nodeType = getNodeType(superAdjacency, index)\n neighbours = getNeighbours(superAdjacency, index)\n if not neighbours:\n continue\n elif str(nodeType) == str(var):\n domain = getDomain(superAdjacency, index)\n\n choice = random.choice(domain)\n if nodeType == 'T':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\n elif nodeType == 'S':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\n elif nodeType == 'H':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\n if nodeType == 'P':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\n\n choice = int(choice)\n if choice % 2 == 0:\n return choice\n else:\n return choice\n\n def min_conflicts(nodes, arcs, max_steps):\n lastUpdateNode = ''\n for i in range(max_steps):\n if isSolution() == True:\n return\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\n if var != 'NA':\n value = valueForConflictedVariable(superAdjacency, var)\n updateSuperAdjacency(superAdjacency, var, value)\n node_values_dict[var] = value\n else:\n pass\n\n return\n\n min_conflicts(nodes, arcs, max_steps)\n node_values = getSolution(superAdjacency)\n return node_values","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def solve(self):\n # Use a trivial tour (1-2-3-...-N-1) to set the global upper bound.\n tour = list(range(self._N))\n upper_bound = sum([self._G[i][(i + 1) % self._N] for i in range(self._N)])\n trace = []\n\n # Start from a configuration with a single vertex.\n frontier = [BranchAndBoundConfiguration(self._G, self._N, [0], LOWER_BOUND_METHOD)]\n\n # Set the start time.\n start_time = time.time()\n\n # Branch and bound until the frontier set is empty or the time has expired.\n while frontier and (time.time() - start_time) < self._cutoff_time:\n # Fetch the most promising configuration.\n config = heappop(frontier)\n\n # Expand configuration by appending a vertex to the path.\n for v in range(self._N):\n try:\n expanded_config = config.expand(v)\n except ValueError:\n # Expanded configuration is not valid.\n continue\n if expanded_config.is_solution():\n # Update the global upper bound, if needed.\n this_solution = expanded_config.get_cycle_cost()\n if this_solution < upper_bound:\n # Log it.\n trace.append((time.time() - start_time, this_solution))\n # Update the best solution.\n upper_bound = this_solution\n tour = list(expanded_config.get_path())\n elif expanded_config.get_lower_bound() < upper_bound:\n # Add to the frontier set.\n heappush(frontier, expanded_config)\n return (upper_bound, [self._index_to_id[v] for v in tour], trace)","def solve(self):\n \n # Check if cost is available for both estimators\n if not self.est0.cost_avail or not self.est1.cost_avail:\n self.comp_cost = False\n \n # Initial estimate from the input node\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\n else:\n z0, zvar0 = self.est0.est_init(return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0\n \n # Initialize other variables\n self.var_cost0 = 0\n self.var_cost1 = 0\n self.cost = 0\n self.s = np.zeros(self.shape1)\n \n for it in range(self.nit):\n \n # Forward transform to est1\n t0 = time.time()\n rvar1_new = self.A.var_dot(self.zvar0)\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\n self.var_axes1,rep=False)\n z1_mult = self.A.dot(self.z0)\n r1_new = z1_mult - rvar1_rep*self.s\n \n # Damping\n if it > 0: \n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\n else:\n self.r1 = r1_new\n self.rvar1 = rvar1_new\n\n # Estimator 1 \n if self.comp_cost: \n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \n if not self.map_est:\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\n self.shape1,self.var_axes1)\n else:\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \n cost1 = 0\n self.z1 = z1\n self.zvar1 = zvar1\n self.cost1 = cost1 \n con_new = np.mean(np.abs(z1-z1_mult)**2) \n \n # Reverse nonlinear transform to est 0\n self.s = (self.z1-self.r1)/rvar1_rep\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\n t1 = time.time()\n self.time_est1 = t1-t0\n \n # Reverse linear transform to est 0 \n rvar0_new = 1/self.A.var_dotH(self.sprec)\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\n self.var_axes0,rep=False)\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\n \n # Damping\n if it > 0:\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\n else:\n self.r0 = r0_new\n self.rvar0 = rvar0_new\n \n \n # Estimator 0\n if self.comp_cost:\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\n if not self.map_est:\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\n self.shape0,self.var_axes0)\n \n else:\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\n cost0 = 0\n self.z0 = z0\n self.zvar0 = zvar0\n self.cost0 = cost0 \n\n \n # Compute total cost and constraint \n cost_new = self.cost0 + self.cost1 \n if not self.map_est:\n cost_new += self.cost_gauss()\n \n # Step size adaptation\n if (self.step_adapt) and (it > 0):\n if (con_new < self.con):\n self.step = np.minimum(1,self.step_inc*self.step)\n else:\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\n self.cost=cost_new\n self.con=con_new\n \n t2 = time.time()\n self.time_est0 = t2-t1\n self.time_iter = t2-t0\n \n # Print progress\n if self.prt_period > 0:\n if (it % self.prt_period == 0):\n if self.comp_cost:\n print(\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\".format(\\\n it, self.cost, self.con, self.step))\n else:\n print(\"it={0:4d} con={1:12.4e}\".format(\\\n it, self.con))\n \n # Save history\n self.save_hist()","def optimize(self):\n\n self.logger.info(\"Solving with Dynamic Slope Scaling Procedure in Julia :\")\n optimization_start = time.time()\n\n # 1. Preprocess for old network graph\n if self.old_network_graph is not None:\n\n # DSSP on old network\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\n try:\n self.check_infeasibility(self.old_network_graph, old_network_obj)\n except DHCOptimizerException as e:\n e.data = \"Invalid existing network: \" + e.data\n raise e\n\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\n\n if self.modify_old_network:\n\n # Add max capacity on old edges\n self.old_capacity = deepcopy(flows)\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\n for key in flows:\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\n\n # Add Imaginary edges\n for edge in self.old_capacity:\n if self.optimization_graph.has_edge(*edge):\n\n # add nodes\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\n # add edges\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\n\n # put cost\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n\n else:\n # if we don't modify the old network, we have to change the capacity of the supplies\n already_consummed = {}\n for edge in solution_old_graph.edges():\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\n for source in already_consummed:\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\n self.network_objective -= already_consummed[source]\n else:\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\n\n # Remove edges from old network\n edges_to_remove = set()\n for e in self.optimization_graph.edges():\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\n edges_to_remove.add(e)\n self.optimization_graph.remove_edges_from(edges_to_remove)\n\n # Remove isolated buildings of optimization graph\n isolated_to_remove = set()\n for e in self.old_network_graph.edges():\n if e[0] in self.old_network_graph.nodes() and \\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n isolated_to_remove.add(e)\n self.optimization_graph.remove_edges_from(isolated_to_remove)\n\n # Remove buildings from old network\n for n, data in self.old_network_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n self.optimization_graph.remove_node(n)\n\n # Re-link sources\n sources = set()\n for n, data in self.optimization_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n sources.add(n)\n source_graph = self.optimization_graph.subgraph(sources).copy()\n self.optimization_graph.remove_nodes_from(sources)\n gnx.remove_isolates(self.optimization_graph)\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\n\n # fill missing information\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\n for e in self.optimization_graph.edges(keys=True):\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\n\n\n\n # 2. Process the DSSP on optimization graph\n self.check_is_ready()\n self.check_infeasibility(self.optimization_graph, self.network_objective)\n\n if self.old_network_graph is not None and self.modify_old_network:\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\n else:\n old_buildings = set()\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\n\n # 3. Postprocess for old network graph\n if self.old_network_graph is not None:\n \n if self.modify_old_network:\n # Put the right supply capacity and cost\n for edge in self.old_capacity:\n if self.solution_graph.has_edge(edge[0],edge[1]):\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\n \n # Remove imaginary edges\n imaginary_nodes_to_remove = set()\n nodes_to_relabel = {}\n for edge in self.solution_graph.edges():\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\n if not self.solution_graph.has_edge(*real_edge):\n for i in range(2):\n nodes_to_relabel[edge[i]] = real_edge[i]\n else:\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\n imaginary_nodes_to_remove.add(edge[0])\n imaginary_nodes_to_remove.add(edge[1])\n elif str(edge[0]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[0])\n elif str(edge[1]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[1])\n\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\n for node in nodes_to_relabel.values():\n if self.solution_graph.has_edge(node, node):\n self.solution_graph.remove_edge(node, node)\n\n else:\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n\n return flows, obj_val","def solve(num_wizards, num_constraints, wizards, constraints): \n global wiz_const\n wiz_const = mapConstraints(wizards, constraints)\n partial_soltns = []\n\n # counter for priority queue since it doesn't allow \n # identical priorities\n k = 0\n\n # list of wizards sorted by lowest to highest degree\n sorted_wiz = sortWizByConsts(wiz_const)\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\n\n const_set = set(map(tuple, constraints))\n for i in range(4) : \n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\n k += 1\n\n print(\"setup done, commencing solving\")\n\n while len(partial_soltns) : \n\n # for partial_soltn, const_set in partial_soltns : \n# partial_soltns.remove(partial_soltn)\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\n print(\"seen \" + str(len(partial_soltn)) + \"\\t num partial_solutions\\t\" + str(len(partial_soltns)))\n try : \n const_set.remove(const)\n except KeyError : \n print(\"BAD SHIT\")\n pass\n possible_arrangements = [(const[0], const[1], const[2]),\n (const[2], const[0], const[1]), \n (const[2], const[1], const[0]),\n (const[1], const[0], const[2])]\n for arr in possible_arrangements:\n soltn = partial_soltn.copy()\n a, b, c = arr\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \n soltn.add_edge(a, b)\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \n soltn.add_edge(b, c)\n # see if we violated any other constraints (seen or not seen)\n is_valid, num_wiz = validNumWiz(soltn, const_set)\n\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\n k += 1\n # are we done?\n if num_wiz == num_wizards :\n print(\"FINAL SOLUTION (found without processing all constraints but validating against them)\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \n print(\"FINAL SOLUTION\")\n ordering = list(nx.topological_sort(soltn))\n finishEverything(ordering, constraints)\n return ordering\n print(\"NO SOLUTION FOUND\")\n return \"\"","def CalculatePaths(self):\n agrid = self.agrid \n self.apath = array([0 for y in range(self.T)], dtype=float)\n self.cpath = array([0 for y in range(self.T)], dtype=float)\n self.npath = array([0 for y in range(self.T)], dtype=float)\n # generate each generation's asset, consumption and labor supply forward\n for y in range(self.T-1): # y = 0, 1,..., 58\n self.apath[y+1] = max(0,interp1d(agrid, self.a[y], kind='cubic')(self.apath[y]))\n if y >= self.W:\n self.cpath[y], self.npath[y] = (1+self.r)*self.apath[y] + self.b - self.apath[y+1], 0\n else:\n self.cpath[y], self.npath[y] = self.solve(self.apath[y], self.apath[y+1])\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\n # the oldest generation's consumption and labor supply\n self.cpath[self.T-1], self.npath[self.T-1] = (1+self.r)*self.apath[self.T-1]+self.b, 0\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])","def solve():\n\n s, g, e = make_lattice(21)\n stack = deque([[e]])\n vals = {s: 1}\n max_n = 0\n\n while stack:\n max_n = max(max_n, len(stack))\n n, *p = stack.pop()\n for c in g.get_connected(n):\n if c > n:\n continue\n if c in vals:\n propagate(c, [n] + p, vals)\n else:\n stack.append([c, n] + p)\n return vals[e]","def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\n auto_param_obj_history = []\n auto_param_relaxed_obj_history = []\n \n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\n eta = np.array([eta_0/len(H)]*len(H))*0.9\n eta_lin = np.ones(L_lhs.shape[0])*0.01\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Feasibility')\n count = 0\n num_violated = -1\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n count += 1\n num_violated_prev = np.copy(num_violated)\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\n \n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\n eta[cnstr['Relaxed'] == False] *= eta_step\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n # eta_lin *= eta_step\n \n if num_violated == num_violated_prev:\n print('Increase enforcement')\n if num_violated_lin > 0:\n eta_lin[cnstr_linear == False] *= eta_step\n # eta_0 *= eta_step*2\n #eta_lin *= eta_step\n if num_violated_oar > 0:\n eta[cnstr['Relaxed'] == False] *= eta_step\n # eta_0 *= eta_step*2\n \n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n \n print('Enforcing Optimality')\n count = 0\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\n count += 1\n print('Opt Iter', count)\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\n u_prev = np.copy(u)\n eta_0 *= eta_step_tumor\n print('Current eta_0:', eta_0)\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\n auto_param_obj_history.append(obj_history)\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\n \n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\n print('No improvement, increase enforcement')\n eta_step_tumor *= 0.1\n eta_0 *= eta_step_tumor\n if (2*eta_0)**2 <= 1e-80:\n print('zero reached')\n break\n # break\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\n \n print('Finding the correct solution:')\n u = u_prev\n eta_0 = eta_0/eta_step_tumor\n \n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\n print(\"OBJJJJJ:\", obj_u_opt_N_fixed(u, T, alpha, B))\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history","def solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths):\n\n car_path = [get_car_path(graph,home_clusters,source,all_pairs_distances,all_pairs_shortest_paths, \n source_in_clusters = B1, christofides = B2) for B1 in [False,True] for B2 in [False,True]]\n\n dropoffs = [cluster_solver_utils.nearest_dropoff_efficient(graph,path,homes,all_pairs_distances) for path in car_path]\n cost = [cluster_solver_utils.eval_cost_efficient(graph,car_path[i],dropoffs[i],all_pairs_distances) for i in range(len(car_path))]\n\n minimum_cost = min(cost)\n idx = cost.index(minimum_cost)\n\n return minimum_cost, dropoffs[idx], car_path[idx]","def objective(trial):\n # The parameters that we will calibrate the model for are shown here.\n # Optuna trial i\n BOD = trial.suggest_uniform(\"BOD\", 0, 1) #Review ranges here\n k_r = trial.suggest_uniform(\"k_r\", 0, 1) #Review Ranges here \n \n def ChLa(t):\n return 1 # Need to link to data\n\n def I(x):\n return 1 # Need to link to data\n\n K_z = 2 * 10**(-5) # p.51\n a = K_z\n k_b = 0.1 # Table 5\n th_b = 1.047 # Table 5\n k_r = 0.1 # Table 5\n YCHO2 = 0.0083 # Table 5\n th_p = 1.036 # Table 5\n th_s = 1.065 # Table 5\n th_r = 1.047 # Table 5\n\n def Temp(t):\n \"\"\"\n Function that maps time to temperature\n \"\"\"\n return 20 # Need to link to data\n\n def P_max(t):\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\n\n def L_min(t):\n I = 1 # Need to link to PAR data\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\n K_2 = 15\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\n \n # f deals with sink and source terms \n def f(x, t):\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \n\n L = 200 # Length of domain\n dt = 1 / 48 # Mesh spacing in t\n F = a * dt # a * dt / dx**2\n T = 100 # Simulation time stop\n\n # Solving the PDE\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\n \n # Creating some bogus targets while database errors are happening\n DO_data = DO + np.random.random(len(DO))\n\n # Using mean squared error as the measure of fit, where we want\n # to minimize this number\n return ((DO - DO_data)**2).mean()","def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\n # process and activate input settings\n sigint_callback = kwds.pop('sigint_callback', None)\n settings = self._process_inputs(kwds)\n disp = settings['disp'] if 'disp' in settings else False\n echo = settings['callback'] if 'callback' in settings else None\n# for key in settings:\n# exec \"%s = settings['%s']\" % (key,key)\n if disp in ['verbose', 'all']: verbose = True\n else: verbose = False\n #-------------------------------------------------------------\n\n from python_map import python_map\n if self._map != python_map:\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\n from mystic.monitors import Null\n evalmon = Null()\n else: evalmon = self._evalmon\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\n\n # set up signal handler\n #self._EARLYEXIT = False\n self._generateHandler(sigint_callback) \n\n # activate signal_handler\n #import threading as thread\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\n import signal\n if self._handle_sigint:\n signal.signal(signal.SIGINT,self.signal_handler)\n\n # register termination function\n if termination is not None: self.SetTermination(termination)\n\n # get the nested solver instance\n solver = self._AbstractEnsembleSolver__get_solver_instance()\n #-------------------------------------------------------------\n\n # generate starting points\n initial_values = self._InitialPoints()\n\n # run optimizer for each grid point\n from copy import deepcopy as _copy\n op = [_copy(solver) for i in range(len(initial_values))]\n #cf = [cost for i in range(len(initial_values))]\n vb = [verbose for i in range(len(initial_values))]\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\n at = self.id if self.id else 0 # start at self.id\n id = range(at,at+len(initial_values))\n\n # generate the local_optimize function\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\n from copy import deepcopy as _copy\n from mystic.tools import isNull\n solver.id = rank\n solver.SetInitialPoints(x0)\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\n solver.SetStrictRanges(min=solver._strictMin, \\\n max=solver._strictMax) # or lower,upper ?\n solver.Solve(cost, disp=disp, callback=callback)\n sm = solver._stepmon\n em = solver._evalmon\n if isNull(sm): sm = ([],[],[],[])\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\n if isNull(em): em = ([],[],[],[])\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\n return solver, sm, em\n\n # map:: solver = local_optimize(solver, x0, id, verbose)\n results = self._map(local_optimize, op, initial_values, id, \\\n vb, cb, **self._mapconfig)\n\n # save initial state\n self._AbstractSolver__save_state()\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\n # reconnect monitors; save all solvers\n from mystic.monitors import Monitor\n while results: #XXX: option to not save allSolvers? skip this and _copy\n _solver, _stepmon, _evalmon = results.pop()\n sm = Monitor()\n sm._x,sm._y,sm._id,sm._info = _stepmon\n _solver._stepmon.extend(sm)\n del sm\n em = Monitor()\n em._x,em._y,em._id,em._info = _evalmon\n _solver._evalmon.extend(em)\n del em\n self._allSolvers[len(results)] = _solver\n del results, _solver, _stepmon, _evalmon\n #XXX: END HACK\n\n # get the results with the lowest energy\n self._bestSolver = self._allSolvers[0]\n bestpath = self._bestSolver._stepmon\n besteval = self._bestSolver._evalmon\n self._total_evals = self._bestSolver.evaluations\n for solver in self._allSolvers[1:]:\n self._total_evals += solver.evaluations # add func evals\n if solver.bestEnergy < self._bestSolver.bestEnergy:\n self._bestSolver = solver\n bestpath = solver._stepmon\n besteval = solver._evalmon\n\n # return results to internals\n self.population = self._bestSolver.population #XXX: pointer? copy?\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\n self.bestEnergy = self._bestSolver.bestEnergy\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\n self._maxiter = self._bestSolver._maxiter\n self._maxfun = self._bestSolver._maxfun\n\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\n self._stepmon = bestpath #XXX: pointer? copy?\n self._evalmon = besteval #XXX: pointer? copy?\n self.energy_history = None\n self.solution_history = None\n #from mystic.tools import isNull\n #if isNull(bestpath):\n # self._stepmon = bestpath\n #else:\n # for i in range(len(bestpath.y)):\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\n # #XXX: could apply callback here, or in exec'd code\n #if isNull(besteval):\n # self._evalmon = besteval\n #else:\n # for i in range(len(besteval.y)):\n # self._evalmon(besteval.x[i], besteval.y[i])\n #-------------------------------------------------------------\n\n # restore default handler for signal interrupts\n if self._handle_sigint:\n signal.signal(signal.SIGINT,signal.default_int_handler)\n\n # log any termination messages\n msg = self.Terminated(disp=disp, info=True)\n if msg: self._stepmon.info('STOP(\"%s\")' % msg)\n # save final state\n self._AbstractSolver__save_state(force=True)\n return","def solve_environment(self):\n \n #The first problem formulation\n #K kinds of towers\n #See more details about problem formulation in the writeup \n \n #Get a full matrix of the concatenated coverage matrices for \n #each tower type. THis new matrix has dimensions:\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\n coverage = np.hstack(i for i in self.coverage_matrices)\n print coverage\n print coverage.shape \n \n #Diagonal matrix of the values of each target\n #(for the scenarios where we don't care about maximizing covered value,\n #target_values is just all ones, so this is just the identity matrix)\n V = np.diag(self.target_values)\n \n #If doing scenario where we want to fortify weakest link, only makes\n #sense if all targets are equal value:\n if self.objective_type == 'min_entries':\n V = np.eye(len(self.target_values))\n\n #Get the matrix of coverage values / expected value saved:\n C = np.dot(V,coverage)\n print 'V', V\n print 'coverage', coverage\n print 'C', C\n \n \n #Since not gauranteed to reach global optimum on any particular initialization,\n #run a few times and take the best result.\n #Just define \"best result\" as the result which had the most overall \n #\"converged\" x, combined over all tower kinds. \n# for j in xrange(self.N_random_starts_max):\n \n \n a = 2. #1.\n tau = 1e-4\n N = sum(i for i in self.N_tower_sites)\n w = np.zeros(N)\n ones = np.ones(N)\n p = 1. #the exponents power when doing he exponent method:\n \n for i in xrange(self.N_reweighting_iterations_max):\n #The concatenated vector of occupancies: Concatenated over all\n #of the kinds of towers.\n x = cvx.Variable(N)\n \n #Different objective functions depending on which optimization problem.\n #These are defined in the scenarios in the main function.\n if self.objective_type == 'min_entries':\n operation = cvx.min_entries\n elif self.objective_type == 'sum_entries':\n operation = cvx.sum_entries\n else:\n raise Exception('must specify valid objective_type')\n \n #Objective function includes penalty term for non-binary x values\n if self.penalty_type == 'reweighted_L1':\n #objective = cvx.Maximize(t - x.T*w)\n objective = cvx.Maximize(operation(C*x - x.T*w))\n\n\n #Main constraints on 0<=x<=1\n constraints = [0<=x, x<=1]\n \n \n #And then for each kind of tower, append the constraint that there\n #be exactly N_i towers, or <= quota (depending on constraint type)\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n print before_sum\n print before_sum + self.N_tower_sites[tk]\n if self.constraints__type == 'fixed_N_towers':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )==self.N_towers[tk])\n elif self.constraints__type == 'tower_quotas':\n constraints.append(cvx.sum_entries(\n x[before_sum : before_sum + self.N_tower_sites[tk]]\n )<=self.budget__tower_quotas[tk])\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\n \n elif self.constraints__type == 'total_cost':\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \n \n \n \n\n\n \n \n print 'penalty_type', self.penalty_type\n print 'objective_type', self.objective_type\n print 'constraints__type', self.constraints__type\n print 'budget__tower_quotas', self.budget__tower_quotas\n print 'operation', operation\n print 'objective', objective\n print 'constraints', constraints\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\n x = np.array(x.value).flatten()\n print 'x', x\n w = a/(tau+np.abs(x))\n p += 1.\n plt.figure(figsize=(5,5))\n plt.plot(x,marker='o')\n plt.savefig('histrograms_{}.png'.format(i))\n print \n \n \n \n \n #From the solution x, get the coordinates of those tower sites where we\n #really do want to place a tower\n #use = np.isclose(x,1.)\n for tk in xrange(self.N_tower_kinds):\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\n inds = np.argsort(y)\n s = y[inds]\n use = np.where(s>.5)[0]\n print inds\n print s\n print use \n if self.constraints__type == 'fixed_N_towers':\n if len(use) != self.N_towers[tk]:\n print 'Solution did not converge properly. Choosing the K best towers.'\n print self.N_towers[tk], len(use)\n # use = use[-self.N_towers[tk]:]\n use = inds[-self.N_towers[tk]:]\n elif self.constraints__type == 'tower_quotas':\n pass #Just use the towers thresholded at > .5\n print use\n \n \n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])","def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\n\n # Raise('NotImplementedError: only adjusted the arguments.')\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\n #precompute the expensive operation:\n lin_penalties = 1/np.sqrt(2*eta_lin)\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\n #!!!!\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\n #!!!!\n u_prev = u_init + 1\n u = u_init\n count = 0\n obj_history = []\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\n start = time.time()\n \n u_prev = np.copy(u)\n w_0 = w_0_update(eta_0, u, T, alpha, B) \n w = w_update(u, H, gamma, D, C) \n w_lin = w_lin_update(u, L_lhs, L_rhs)\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\n #!!!!\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\n #!!!!\n count += 1 \n if count == 10:\n u_inf = np.copy(u)\n w_0_inf = w_0[:]\n w_inf = w[:]\n w_lin_inf = w_lin[:]\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\n \n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\n obj_history.append(cur_obj)\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\n relaxed_obj_history.append(cur_relaxed_obj) \n \n stop = time.time()\n duration = stop-start\n \n if count%1 == 0 and verbose: \n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\n print(' This iteration took: {}'.format(duration))\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history","def solve(self):\n initial_fes = eades(self.graph, self.force_forward_edges)\n initial_fes_vec = self.edge_vector(initial_fes)\n\n # bounds for the objective\n lower_bound = 0\n upper_bound = np.sum(initial_fes_vec @ self.weights)\n\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\n\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\n\n for iteration in itertools.count(1):\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\n upper_bound, len(simple_cycles))\n\n # Formulate and solve the problem for this iteration:\n y = cp.Variable(self.m, boolean=True, name=\"y\")\n objective = cp.Minimize(cp.sum(y @ self.weights))\n\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\n problem = cp.Problem(objective, constraints)\n resolution = problem.solve(**self.solver_args)\n if problem.status != 'optimal':\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\n problem.solver_stats.solver_name)\n self.logger.debug(\n \"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\",\n len(constraints), resolution, problem.solution.status,\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\n current_fes = self.edges_for_vector(current_solution)\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\n len(current_fes))\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\n # from the heuristic\n lower_bound = max(lower_bound, objective.value)\n if lower_bound == upper_bound:\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\n break # y.value is the optimal solution\n\n if resolution > upper_bound:\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\n break\n\n Gi = self.graph.copy()\n Gi.remove_edges_from(current_fes)\n if nx.is_directed_acyclic_graph(Gi):\n self.logger.info('Graph is acyclic, optimal solution found')\n break # y.value is the optimal solution\n\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\n # determine additional simple cycles (= constraints)\n Fi = eades(Gi, self.force_forward_edges)\n yi = self.edge_vector(Fi) | current_solution\n zi = np.sum(yi @ self.weights)\n if zi < upper_bound:\n upper_bound = zi\n current_solution = yi\n simple_cycles |= set(induced_cycles(Gi, Fi))\n\n self.solution_vector = current_solution\n self.solution = self.edges_for_vector(current_solution)\n self.objective = objective.value\n self.iterations = iteration\n self.simple_cycles = simple_cycles\n return self.solution","def solver(feats,\n asgn,\n cstrs,\n cstrs_solver,\n gts=None,\n eval_function=None,\n rounding_function=None,\n alpha=1e-4,\n memory_mode='RAM',\n bias_value=-1.0,\n n_iterations=10000,\n block_sampling='uniform',\n verbose='silent',\n gap_frequency=2000,\n eval_frequency=500,\n verbose_frequency=250,\n objective_frequency=250,\n path_save_asgn=None,\n validation_info=None):\n\n compute_objective = False\n objective_value = None\n if objective_frequency > 0:\n compute_objective = True\n\n save_asgn = False\n save_ids = []\n if path_save_asgn is not None:\n if not os.path.exists(path_save_asgn):\n os.makedirs(path_save_asgn)\n # Monitor evolution of asgn during optim on a subset of samples.\n save_asgn = True\n n_save_asgn = min(20, len(asgn))\n save_ids = np.random.choice(len(asgn), n_save_asgn, replace=False)\n\n # Pre-compute the P matrix.\n p_matrix, n_feats = compute_p_matrix(\n feats, alpha, memory_mode, bias_value=bias_value)\n\n # Compute W.\n weights = compute_weights(p_matrix, asgn, memory_mode=memory_mode)\n\n # Init the gaps.\n gaps = np.zeros(len(feats))\n print('Computing init gaps...')\n for block_idx in tqdm(range(len(feats))):\n x = get_feat_block(\n feats, block_idx, memory_mode, bias_value=bias_value)\n gaps[block_idx] = compute_gap(x, asgn[block_idx], weights, n_feats,\n cstrs[block_idx], cstrs_solver)\n\n if save_asgn and block_idx in save_ids:\n save_asgn_block(path_save_asgn, block_idx, asgn, 0)\n save_xw_block(path_save_asgn, block_idx, x, weights, 0)\n save_gt_block(path_save_asgn, block_idx, gts)\n\n print('Init gap: {0:4E}, starting the optimization...'.format(gaps.sum()))\n\n eval_metric = -1.0\n prev_time = time.time() # init time of iterations\n prev_global_time = prev_time\n for t in range(n_iterations):\n if eval_frequency > 0 and t % eval_frequency == 0:\n # Evaluation.\n if eval_function is not None and gts is not None:\n print('Performing evaluation...')\n eval_metric = eval_function.evaluate(asgn, gts, weights, feats,\n rounding_function, cstrs)\n if validation_info is not None:\n gts_val = validation_info['gts']\n feats_val = validation_info['feats']\n eval_function.evaluate(None, gts_val, weights, feats_val,\n rounding_function, None)\n else:\n eval_metric = -1.0\n\n if compute_objective and t % objective_frequency == 0:\n print('Computing objective...')\n objective_value = {}\n # Compute the diffrac objective.\n dfrac_obj = 0.0\n # Data dependent term: 1.0 / N * ||X * W - Y||_2^2\n for block_idx in range(len(feats)):\n x = get_feat_block(\n feats, block_idx, memory_mode, bias_value=bias_value)\n dfrac_obj += compute_obj(x, asgn[block_idx], weights, n_feats)\n\n # Regularization term: \\alpha * || W ||_2^2\n dfrac_obj += alpha * matrix_norm(weights, ord='fro')**2\n objective_value['dfrac'] = dfrac_obj\n\n # Print information.\n if t % verbose_frequency == 0:\n display_information(t, n_iterations, gaps, eval_metric,\n objective_value, verbose, prev_time, prev_global_time)\n prev_time = time.time()\n\n # Sample a block.\n block_idx = sample_block(gaps, block_sampling)\n # Compute gradient.\n x = get_feat_block(\n feats, block_idx, memory_mode, bias_value=bias_value)\n y = asgn[block_idx]\n\n grad_y = compute_grad(x, y, weights, n_feats)\n\n opt_y = cstrs_solver.solve(cstrs[block_idx], grad_y)\n gaps[block_idx] = compute_gap(x, y, weights, n_feats,\n cstrs[block_idx], cstrs_solver,\n opt_y, grad_y)\n\n # Step size computation.\n p = get_p_block(p_matrix, block_idx, memory_mode)\n dir_y = opt_y - y\n gamma_n = gaps[block_idx]\n\n gamma_d = 1.0 / n_feats * np.multiply(\n dir_y, dir_y - np.linalg.multi_dot([x, p, dir_y])).sum()\n\n gamma = min(1.0, gamma_n / gamma_d)\n # gamma should always be positive.\n if gamma < 0:\n print 'Warning: gamma = {}, gap_i = {}'.format(\n gamma, gaps[block_idx])\n gamma = 0.0\n\n # Update variables.\n asgn[block_idx] += gamma * dir_y\n weights += gamma * np.dot(p, dir_y)\n\n if save_asgn and block_idx in save_ids:\n save_asgn_block(path_save_asgn, block_idx, asgn, t)\n save_xw_block(path_save_asgn, block_idx, x, weights, t)\n\n # Update gaps if needed.\n if (t + 1) % gap_frequency == 0:\n print('Recomputing gaps...')\n for block_idx in tqdm(range(len(feats))):\n x = get_feat_block(\n feats, block_idx, memory_mode, bias_value=bias_value)\n gaps[block_idx] = compute_gap(x, asgn[block_idx], weights,\n n_feats, cstrs[block_idx],\n cstrs_solver)\n display_information(t, n_iterations, gaps, eval_metric,\n objective_value, verbose)\n\n return asgn, weights","def g_solving_subproblem_of_ALR(self,vehicle_id):\r\n global_LB = -10000\r\n global_UB = 10000\r\n iteration_for_RSP = 20\r\n optimal_solution_for_RSP = None\r\n self.multiplier_v = 0.5\r\n\r\n # solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\r\n\r\n # obtain the variance\r\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB = 0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\r\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\r\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\r\n\r\n # step 3: update multipliers\r\n if variance- y != 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB - global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, global_LB","def prob1():\n # Set up the initial guess, jacobian, and hessian.\n x0 = np.array([4.0,-2.5])\n jacobian = opt.rosen_der\n hessian = opt.rosen_hess\n\n # Test each method.\n info = {}\n info[\"Nelder-Mead\"] = opt.minimize(opt.rosen, x0, method='Nelder-Mead',\n options={'xtol':1e-8})\n info[\"Powell\"] = opt.minimize(opt.rosen, x0, method='Powell',\n options={'xtol':1e-8})\n info[\"CG\"] = opt.minimize(opt.rosen, x0, method='CG')\n info[\"BFGS\"] = opt.minimize(opt.rosen, x0, method='BFGS')\n info[\"Newton-CG w/out Hessian\"] = opt.minimize(opt.rosen, x0, jac=jacobian,\n method='Newton-CG', options={'xtol':1e-8})\n info[\"Newton-CG, w/ Hessian\"] = opt.minimize(opt.rosen, x0, jac=jacobian,\n hess=hessian, method='Newton-CG',options={'xtol':1e-8})\n info[\"L-BFGS-B\"] = opt.minimize(opt.rosen, x0, method='L-BFGS-B',\n options={'xtol':1e-8})\n info[\"TNC\"] = opt.minimize(opt.rosen, x0, method='TNC', \n options={'xtol':1e-8})\n info[\"COBYLA\"] = opt.minimize(opt.rosen, x0, method='COBYLA')\n info[\"SLSQP\"] = opt.minimize(opt.rosen, x0, method='SLSQP')\n\n # Report the info.\n print(\"\\n\\t\\tOptimization Tests\")\n for method in info:\n print(\"Method: {}\\n{}\\n\\n\".format(method, info[method]))\n \n # Answer the problem questions.\n print(\"The Powell algorithm takes the least number of iterations (19).\")\n print(\"COBYLA fails to find the correct minimum.\")","def CalculateChebyPaths(self):\n Kmin, Kmax = self.Kmin, self.Kmax\n self.apath = array([0 for y in range(self.T)], dtype=float)\n self.cpath = array([0 for y in range(self.T)], dtype=float)\n self.npath = array([0 for y in range(self.T)], dtype=float)\n # generate each generation's asset, consumption and labor supply forward\n for y in range(self.T-1): # y = 0, 1,..., 58\n self.cpath[y] = self.chebeval(array([self.apath[y]]),self.ac[y],Kmin,Kmax)\n # if self.cpath[y] < 0:\n # self.cpath[y] = 0\n if y >= self.W:\n income = self.b\n else:\n self.npath[y] = self.chebeval(array([self.apath[y]]),self.an[y],Kmin,Kmax)\n income = (1-self.tau)*self.w*self.npath[y]\n self.apath[y+1] = (1+self.r)*self.apath[y] + income - self.cpath[y]\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\n # the oldest generation's consumption and labor supply\n self.cpath[self.T-1] = (1+self.r)*self.apath[self.T-1] + self.b\n # self.cpath[self.T-1] = self.chebeval(array([self.apath[self.T-1]]),self.ac[self.T-1],Kmin,Kmax)\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])\n # print self.cpath, self.apath, self.npath","def calculate_path(self):\n #Se repite el ciclo para el número especificado de veces\n for i in range(self.iterations):\n for ant in self.ants:\n ant.setup_ant()\n while not ant.final_node_reached:\n #Seleccion aleatoria del nodo a visitar\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\n #Mover la hormiga al siguiente nodo seleccionado al azar\n ant.move_ant(node_to_visit)\n #Compruebe si se ha alcanzado la solución\n ant.is_final_node_reached()\n #Agregar la ruta resultante a la lista de rutas\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\n # Habilitar a la hormiga para otra busqueda\n ant.enable_start_new_path()\n \n # Actualizar el nivel global de feromonas\n self.pheromone_update()\n self.best_result = self.paths[0]\n\n #Vaciar la lista de rutas\n self.empty_paths()\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\n return self.best_result","def astar_implicit(successors,s,g,cost=(lambda v,w:1),heuristic=(lambda v:0),verbose=1):\n if not callable(g):\n gtest = lambda x,goal=g: x==g\n else:\n gtest = g\n inf = float('inf')\n d = dict()\n p = dict()\n d[s] = 0\n Q = [(0,0,s)] #each element is a tuple (f,-c,v) with f=c + heuristic(v), c=cost from start, v=vertex\n nnodes = 0\n while len(Q) > 0:\n f,minus_c,v = heapq.heappop(Q) #get the element in the queue with the least value of c\n nnodes += 1\n if gtest(v):\n #found a path\n if verbose: print(\"A* succeeded in\",nnodes,\"iterations\")\n return predecessor_traverse(p,s,v),d,p\n for w in successors(v):\n dcand = d[v] + cost(v,w) #this is the cost of going through v to w\n if dcand < d.get(w,float('inf')):\n #going through v is optimal\n #if the predecessor of w is not None, then we'll have to adjust the heap\n if w in p:\n Q = [(f,c,x) for (f,c,x) in Q if x is not w]\n heapq.heapify(Q)\n d[w] = dcand\n p[w] = v\n #put w back on the queue, with the heuristic value as its priority\n heapq.heappush(Q,(dcand+heuristic(w),-dcand,w))\n #no path found\n if verbose: print(\"A* failed in\",nnodes,\"iterations\")\n return None,d,p","def solve_assignments(self):\n # build valuations vector \n c = -1 * self.valuations.flatten()\n\n # empty G and h, no inequality constraints\n G = np.zeros((1, self.n**2))\n h = np.zeros((1))\n\n # build A and b, enforces unique room-agent matching\n A = np.zeros((2 * self.n, self.n**2))\n b = np.ones((2 * self.n))\n for i in range(self.n):\n # exactly one room per agent\n A[i, i * self.n + np.arange(self.n)] = 1.0 \n # exactyly one agent per room\n A[self.n + i, (self.n) * np.arange(self.n) + i] = 1.0\n\n B = set(range(self.n**2))\n status, x = ilp(c=matrix(c, tc='d'), G=matrix(G, tc='d'), \n h=matrix(h, tc='d'), A=matrix(A, tc='d'), \n b=matrix(b, tc='d'), B=B)\n\n # get assignments\n x = np.argmax(np.array(x).reshape(self.n, self.n), axis=1)\n self.assignments = x \n\n return self.assignments","def solve(self) -> Optional[Tuple[list, int]]:\n agents = copy(self.agents)\n groups = []\n\n # Solve for every group\n for agent in agents:\n self.agents = [agent]\n solver = EPEAStar(self.problem, self.agents, self.cats, self.stat_tracker,\n max_cost=self.path_set.get_remaining_cost([agent.identifier], self.max_value))\n solution = solver.solve()\n if solution is None:\n return None\n agent_paths, cost = solution\n self.path_set.update(agent_paths)\n\n groups.append(([agent], cost))\n\n # Find and resolve conflicts until solution is conflict-free\n conflict = self.path_set.find_conflict()\n while conflict is not None:\n a, b = conflict\n groups = self.merge_groups(groups, a, b, self.cats)\n if groups is None:\n return None\n conflict = self.path_set.find_conflict()\n return self.path_set.paths, sum(self.path_set.costs)","def evaluate(G, path, home_idxs, verbose=False):\n dropoffs = assign_dropoffs(G, path, home_idxs)\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\n if verbose:\n print(msg)\n\n return cost","def g_solving_subproblem_of_LR(self,vehicle_id):\r\n global_LB=-10000\r\n global_UB=10000\r\n iteration_for_RSP=20\r\n optimal_solution_for_RSP=None\r\n optimal_value_y=0\r\n self.multiplier_v=0.5\r\n\r\n #solve the expected shortest path problem\r\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\r\n #obtain the variance\r\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n\r\n for k in range(iteration_for_RSP):\r\n # print(k)\r\n LB=0\r\n # step 2: solve decomposed dual problems\r\n # Part I: subproblem of x\r\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\r\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\r\n\r\n # Part II: subproblem of y\r\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\r\n if obj_of_y_ > 0:\r\n y = 0\r\n LB += 0\r\n else:\r\n y = y_\r\n LB += obj_of_y_\r\n # generate an upper bound\r\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\r\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\r\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\r\n\r\n # print(\"UB:{}\".format(UB))\r\n # print(\"LB:{}\".format(LB))\r\n\r\n # UB and LB update\r\n if LB > global_LB:\r\n global_LB = LB\r\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\r\n optimal_value_y = y\r\n\r\n if UB < global_UB:\r\n global_UB = UB\r\n\r\n\r\n # step 3: update multipliers\r\n if variance-y!= 0:\r\n self.multiplier_v+= (global_UB - LB) / (variance-y)\r\n # if self.multiplier_v<0:\r\n # self.multiplier_v=1\r\n # print(self.multiplier_v)\r\n\r\n # step 4: termination condition test\r\n if global_UB != 0:\r\n gap = abs((global_UB-global_LB) / global_UB)\r\n # print(gap)\r\n if gap < 0.02:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\r\n else:\r\n if global_UB - global_LB == 0:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\r\n\r\n if k == iteration_for_RSP - 1:\r\n print(\"iteration{}\".format(k + 1))\r\n print(self.multiplier_v)\r\n print(global_LB, global_UB)\r\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB","def _optimize(self) -> None:\n\n for i, agent in enumerate(self.agents):\n states, actions, rewards, next_states, dones = self.memory.sample()\n\n actor_next_state = self._agent_states(i, next_states)\n next_actions = torch.cat(\n [a.actor_target(actor_next_state) for a in self.agents], 1\n )\n next_q = agent.critic_target(next_states, next_actions).detach()\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\n 1 - dones[:, i].view(-1, 1)\n )\n local_q = agent.critic_local(states, actions)\n\n value_loss = agent.loss_fn(local_q, target_q)\n agent.value_optimizer.zero_grad()\n value_loss.backward()\n agent.value_optimizer.step()\n\n local_actions = []\n for i, a in enumerate(self.agents):\n local_states = self._agent_states(i, states)\n local_actions.append(\n a.actor_local(local_states)\n if a == agent\n else a.actor_local(local_states).detach()\n )\n local_actions = torch.cat(local_actions, 1)\n policy_loss = -agent.critic_local(states, local_actions).mean()\n\n agent.policy_optimizer.zero_grad()\n policy_loss.backward()\n agent.policy_optimizer.step()\n\n self._update_target_model(agent.critic_local, agent.critic_target)\n self._update_target_model(agent.actor_local, agent.actor_target)","def optimal_route(graph,homes,source):\n number_of_homes = len(homes)\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\n \n cluster_list = range(1,number_of_homes+1)\n optimal_cost = np.Inf\n optimal_dropoffs = dict()\n optimal_route = []\n optimal_num_clusters = 0\n\n\n for num_clusters in cluster_list:\n home_clusters = num_clusters_to_clustering[num_clusters]\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\n if cost < optimal_cost:\n optimal_cost = cost\n optimal_route = route \n optimal_dropoffs = dropoffs\n optimal_num_clusters = num_clusters\n\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters","def get_sol(self):","def solve():\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\n return binomial_coefficient(20 + 20, 20)","def solve(self):\n\n # Assign variables to each quantity being solved.\n r_lookup, lookup, num = {}, {}, 0\n for element in self.elements:\n if is_wire(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n elif not is_cs(element) and element is not self.ground:\n lookup[num] = element\n r_lookup[element] = num\n num += 1\n\n # Set up the linear algebraic equation Ax=b\n A = np.zeros((num, num))\n b = np.zeros(num)\n for row, element in lookup.items():\n if is_wire(element) and element is not self.ground:\n for two_sided in element.attached:\n if is_cs(two_sided):\n if two_sided.pos is element:\n b[row] += -1 * two_sided.current\n else:\n b[row] += two_sided.current\n else:\n if two_sided.pos is element:\n flow = 1\n else:\n flow = -1\n A[row, r_lookup[two_sided]] = flow\n elif is_vs(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n b[row] = element.voltage\n elif is_resistor(element):\n check_connected(element)\n if element.pos is not self.ground:\n A[row, r_lookup[element.pos]] = 1\n if element.neg is not self.ground:\n A[row, r_lookup[element.neg]] = -1\n A[row, r_lookup[element]] = -1 * element.resistance\n\n b = b.reshape((num, 1))\n try:\n x = np.linalg.solve(A, b)\n except np.linalg.LinAlgError:\n raise CircuitError('Insufficient information to solve circuit')\n\n # Assign values to all circuit components\n for i in range(num):\n item = lookup[i]\n if is_wire(item):\n item.potential = x[i, 0]\n elif isinstance(item, DualSided):\n item.current = x[i, 0]\n\n # Mark circuit as solved\n self.been_solved = True","def solver_GP(self, eta, mu, lambda_, S, D, A_Init=None):\n\n epsOut = 1e-3\n maxIter = 200\n maxTrial = 20\n\n N, M = self.X.shape\n if mu == -1:\n nLabeled = np.sum(S + D) / 2\n nUnlabeled = N * (N - 1) / 2 - nLabeled\n mu = nLabeled / nUnlabeled\n\n if not A_Init:\n A_Init = M / (M + 1) * np.diag(np.ones(M))\n\n iterGP = 0\n A_pre = (A_Init + A_Init.T) / 2\n objL_pre = self.computeObj_GP(eta, mu, lambda_, S, D, A_pre)\n A_best = A_pre\n objL_best = objL_pre\n normOut = 1e10\n\n while (normOut > epsOut) and (iterGP < maxIter):\n iterGP += 1\n\n # compute gradient\n grad = self.computeGrad_GP(eta, mu, lambda_, S, D, A_pre)\n\n # choose step size\n deltak = 0.1 * M / (np.linalg.norm(grad, ord='fro') * np.sqrt(iterGP))\n deltakk = deltak\n\n trial = 0\n while trial < maxTrial:\n trial += 1\n\n # gradient ascent\n A = A_pre + np.dot(deltak, grad)\n\n # projection\n A = (A + A.T) / 2\n b, V = np.linalg.eig(A)\n\n b = b * (b > 0)\n A = np.dot(V @ np.diag(b), V.T)\n\n # print(A)\n objL = self.computeObj_GP(eta, mu, lambda_, S, D, A)\n\n if objL >= objL_pre: # success\n objL_pre = objL\n break\n else: # fail\n deltak = deltak / 2\n\n if trial == maxTrial: # fail\n print('GP update fails...\\n')\n A = A_pre + 2 * deltakk * grad\n A = (A + A.T) / 2\n b, V = np.linalg.eig(A)\n # b = np.diag(b)\n b = b * (b > 0)\n A = np.dot(V @ np.diag(b), V.T)\n\n objL = self.computeObj_GP(eta, mu, lambda_, S, D, A)\n\n elif objL >= objL_best: # beat best\n A_best = A\n objL_best = objL\n\n normOut = np.linalg.norm(A_pre - A, ord='fro')\n A_pre = A\n objL_pre = objL\n\n A_Final = A_best\n\n return A_Final, iterGP","def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\n best = route.copy()\n cost_list, T_list = [], []\n accept_list = [[],[]]\n\n chains, iterations = 0, 0\n T_0 = T\n iterations = 0\n\n while T > 0:\n for i in range(1, len(route) - 2):\n # test\n # Adjust temperature\n if scheme == \"exp\":\n T = T*c\n if scheme == \"log\":\n alpha = 50\n T = T_0/(1+alpha*np.log(1+iterations))\n # if scheme == \"std\":\n # delta = .01\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\n if scheme == \"quad\":\n alpha = 1\n T = T_0/(1+alpha*iterations**2)\n\n iterations += 1\n \n for j in range(i + 1, len(route)):\n chains += 1\n\n if j - i == 1: continue\n\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\n T_list.append(T)\n\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\n best[j - 1], best[j]) < 0:\n best[i:j] = best[j - 1:i - 1:-1]\n else:\n temp = best.copy()\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\n temp[i:j] = temp[j - 1:i - 1:-1]\n _, cost1 = calculate_cost(temp,adjacency_matrix)\n\n U = rs.uniform()\n Z = np.exp((cost0-cost1)/T)\n\n if U < Z:\n accept_list[1].append(Z)\n accept_list[0].insert(0,T)\n\n best[i:j] = best[j - 1:i - 1:-1]\n\n if chains > max_chain_length:\n print(\"End by chainlength: \",chains,\"T =\",T,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list\n\n route = best.copy()\n print(\"End by T: \",T,\"Chains: \",chains,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list","def solve_cg_eps(self, params, r, sz, energy, aux):\n\n dp0_i, g2_i, itr, nsamples = aux\n\n jac = self.vmap_getder(params, r, sz, nsamples)\n #jac_T = conj_transpose(jac)\n\n f_i = jnp.real(-2 * psum(jnp.matmul(energy, jnp.conjugate(jac)), axis_name='p') / nsamples)\n g2_i = self.beta * g2_i + (1. - self.beta) * f_i**2\n g2h_i = jnp.sqrt(g2_i / (1. - self.beta**itr))\n\n# cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(v_i, jac_T), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\n cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(jnp.conjugate(jac), v_i), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\n\n dp_i, info = jax.scipy.sparse.linalg.cg(cg_mult, f_i, x0=dp0_i, tol=1e-5, atol=0.0, maxiter=200)\n return dp_i, g2_i","def solve(\n self,\n initial_routes=None,\n solver=\"cbc\",\n cspy=False,\n exact=True,\n pricing_strategy=\"PrunePaths\",\n ):\n if cspy:\n self.G.graph[\"subproblem\"] = \"cspy\"\n else:\n self.G.graph[\"subproblem\"] = \"lp\"\n print(self.G.graph[\"name\"], self.G.graph[\"subproblem\"])\n print(\"===========\")\n prob = VehicleRoutingProblem(\n self.G,\n duration=self.max_duration,\n load_capacity=self.max_load,\n drop_penalty=self.penalty,\n pickup_delivery=self.activate_pickup_delivery,\n distribution_collection=self.activate_distribution_collection,\n time_windows=self.activate_time_windows,\n )\n prob.solve(\n initial_routes=initial_routes,\n cspy=cspy,\n exact=exact,\n pricing_strategy=pricing_strategy,\n solver=solver,\n )\n self.best_value, self.best_routes = prob.best_value, prob._best_routes_as_graphs\n self.best_routes_nodes = prob.best_routes","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def tryEverything(g, verbose, graphname):\r\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\r\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\r\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\r\n desc = ['DLS/DC', None, 'DCP']\r\n useOfBIM = [False, True]\r\n insertion = [False, True]\r\n BSA = [False, True]\r\n res: Dict[str, List[float]] = {}\r\n cnt = 0\r\n\r\n for ip, p in enumerate(prio):\r\n for ipl, pl in enumerate(placement):\r\n for ic, c in enumerate(costFunction):\r\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\r\n for idd, d in enumerate(desc):\r\n for iu, u in enumerate(useOfBIM):\r\n for ii, i in enumerate(insertion):\r\n for ib, b in enumerate(BSA):\r\n cnt += 1\r\n name = \";\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\r\n\r\n # dispName = \"-\".join(map(str, [p, pl, c, d, u, i, b]))\r\n # print(\"Heuristic n°\", cnt, \"-\", dispName)\r\n # print(\"Heuristic n°\", cnt, \"-\", name)\r\n\r\n startScheduling = timeit.default_timer()\r\n try:\r\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\r\n strategyPlacement=pl,\r\n useOfBIM=u, desc=d,\r\n insertion=i, bsa=b, verbose=verbose)\r\n verifPrec(g, schedule, verbose)\r\n endScheduling = timeit.default_timer()\r\n # print(\"Ended in :\", 1000*(endScheduling - startScheduling), \"ms\")\r\n # print(\"Ended in :\", round(1000 * (endScheduling - startScheduling),2), \"ms\")\r\n timeS = round(1000 * (endScheduling - startScheduling), 2)\r\n # print(f\"timeS : {timeS}\")\r\n if verbose:\r\n print(f\"Time : {timeS}ms\")\r\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\r\n except Exception as _:\r\n\r\n print(\"Error for : \" + name + \" on file \" + graphname)\r\n file = open(\"error.log\", 'a')\r\n file.write(f\"Error for {name} on file {graphname}\\n\")\r\n file.close()\r\n raise _\r\n return res\r\n return res","def solve(self):\n smallest_f = self.get_smallest_f_cost_unvisited_node()\n smallest_f_node = smallest_f[0]\n\n if smallest_f[1] > 1:\n current_node = self.get_smallest_h_cost_unvisited_node()\n else:\n current_node = smallest_f_node\n if current_node.f_cost == self.inf:\n return\n\n self.set_h_cost(current_node)\n self.unvisited_pos.remove(current_node.pos)\n self.visited_pos.append(current_node.pos)\n neighbours = algo_utils.get_neighbours(current_node, self.grid, self.wall_pos)\n\n for neigh in neighbours:\n neighbour_dist = neigh.g_cost\n current_dist = current_node.g_cost\n new_dist = current_dist + 1\n if neighbour_dist < new_dist:\n continue\n neigh.g_cost = new_dist\n self.set_h_cost(neigh)\n mix_neigh = {neigh.pos: neigh.g_cost}\n self.mix.update(mix_neigh)\n mix_current = {current_node.pos: current_node.g_cost}\n self.mix.update(mix_current)\n\n smallest_f = self.get_smallest_f_cost_unvisited_node()\n smallest_f_node = smallest_f[0]\n smallest_h_node = self.get_smallest_h_cost_unvisited_node()\n\n if (\n self.end_pos not in self.unvisited_pos\n or algo_utils.get_smallest_g_cost_unvisited_node(\n self.grid, self.unvisited_pos\n ).g_cost\n == self.inf\n ):\n for key, value in self.mix.items():\n self.mix[key] = round((value * 1.0) / self.end_node.g_cost, 3)\n self.backtrack_path(self.end_node)\n else:\n if smallest_f[1] > 1:\n current_node = smallest_h_node\n else:\n current_node = smallest_f_node\n self.solve()","def solve(args):\n\n global a\n global b\n global c\n\n a, b, c = args\n mem = {}\n\n # a tree of 30 levels should be enough (all values are < 2^30)\n sol = count_pairs(30, 1, 1, 1, mem)\n\n return sol","def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\n # computes the coefficient used by the greedy oracle to choose routes\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\n\n # randomly selects the player for which the non optimal choice will be made\n wrong_pl = randint(1, n_pl)\n\n # generate the non optimal route randomly\n n_covered_targets = randint(n_pl,n_target-1)\n non_opt_action = np.zeros(n_target)\n for i in range(0, n_covered_targets):\n random_covered_target = randint(0, n_target-1)\n non_opt_action[random_covered_target] = 1\n\n # compute the value of the non optimal route\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\n\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\n # The returned list should have n_pl - 1 routes\n opt_routes = get_opt_routes(n_pl, non_opt_action)\n\n I={}\n for pl in range(1, n_pl+1):\n\n n_r = randint(0, MAX_ROUTES)\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\n\n if pl == wrong_pl:\n # put the non opt route in the bucket\n for t in non_opt_action.nonzero():\n temp[0,t] = 1\n else:\n for t in opt_routes.pop().nonzero():\n temp[0,t] = 1\n\n # generate other random routes with single value less than the non_opt_value\n for r in range(1, n_r):\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\n\n for t in new_route.nonzero():\n temp[r,t] = 1\n\n I[pl] = temp.tocsr()\n\n return I","def alg(c):\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]","def solve(self):","def gen_sol(self, start, n_candidats):\n sol = np.zeros(self.n_objets)\n poidrestant = self.W\n visited = set() # liste des objets visité\n # ajouter le premier objet\n r = rn.randint(1, poidrestant // self.poids[start])\n sol[start] = r\n poidrestant -= self.poids[start] * r\n gain = r * self.benifices[start]\n visited.add(start) # ajouter le debut a la liste civité\n\n # la liste candidates avec les pheromones mis a jours localement (0 sur les visited)\n candidats, pheromones = self.listeCandidate(\n self.pheromone, visited, n_candidats\n )\n\n for i in candidats:\n # Choisir le prochain objets parmi les candidats ainsi que le nombre\n move, nb = self.pick_move(\n pheromones, candidats, n_candidats, self.utilites, visited\n )\n toPop = candidats.index(move)\n candidats.pop(toPop)\n n_candidats -= 1\n np.delete(\n pheromones, toPop\n ) # rendre le pheromone à 0 pour indiquer qu'il a été visité\n\n # Mise a jour poidRestant et gain de la solution\n poidrestant -= self.poids[move] * nb\n while poidrestant < 0:\n nb -= 1\n poidrestant += self.poids[move]\n\n sol[move] = nb\n gain += nb * self.benifices[move]\n\n # ajouter l'objet a visited\n visited.add(move)\n # print(\"s\",i,sol,gain)\n return sol, gain, self.W - poidrestant","def solve_lp(facilities, clients):\n facility_costs = [facility['cost'] for facility in facilities]\n client_costs = [client['costs'] for client in clients]\n\n flat_ccosts = reduce(lambda acc, curr: acc + curr, client_costs)\n sol = lp.solve(facility_costs, flat_ccosts)\n primal = sol['x']\n dual = sol['y']\n\n return primal, dual","def aStar(sx = 1.55, sy = 2.05, gx = 1.55, gy = 4.05, d_diagnoal = 14, d_straight = 10, grid_reso = 0.1, grid_width = 6, grid_height = 3):\n width = int(grid_width/grid_reso)\n height = int(grid_height/grid_reso)\n #TODO\n A_sx, A_sy = realPosTogridPos(sx, sy, grid_reso = grid_reso)\n A_gx, A_gy = realPosTogridPos(gx, gy, grid_reso = grid_reso)\n startNode = Node(A_sx,A_sy,None,0,0,0)\n goalNode = Node(A_gx,A_gy,None,0,0,0)\n # The set of nodes already evaluated\n closedSet = set()\n # The set of currently discovered nodes that are not evaluated yet.\n openSet = set()\n # Initially, only the start node is known.\n openSet.add(startNode)\n # For each node, which node it can most efficiently be reached from.If a node can be reached from many nodes, cameFrom will eventually contain the most efficient previous step.\n cameFrom = []\n # For each node, the cost of getting from the start node to that node.\n gScore = create_gScore(width, height)\n start_x = startNode.x\n start_y = startNode.y\n # The cost of going from start to start is zero.\n startNode.g_value = 0\n gScore[start_x][start_y] = 0\n # For each node, the total cost of getting from the start node to the goal by passing by that node. That value is partly known, partly heuristic.\n fScore = create_fScore(width, height)\n # For the first node, that value is completely heuristic.\n startNode.f_value = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\n fScore[start_x][start_y] = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\n while len(openSet) != 0:\n # current := the node in openSet having the lowest fScore[] value\n current = node_lowest_fScore(openSet)\n # If it is the item we want, retrace the path and return it\n if current.equal(goalNode):\n path = reconstruct_path(cameFrom, current) # path in real\n # print \"path\",path\n pathInReal = convertGridPathToReal(path, sx, sy, gx, gy, grid_reso = grid_reso) # path in grid\n return pathInReal\n\n openSet.remove(current)\n closedSet.add(current)\n current_neighbors = getNeighbors(current, width, height)\n current_neighbors_num = current_neighbors.shape[1]\n # for neighbor in current_neighbors:\n for index in range(current_neighbors_num):\n [neighbor_x,neighbor_y] = current_neighbors[:,index]\n neighbor = Node(neighbor_x,neighbor_y,None,np.inf,np.inf,np.inf)\n if neighbor_in_closedSet(neighbor,closedSet):\n continue\n if neighbor_not_in_openSet(neighbor,openSet):\t# Discover a new node\n openSet.add(neighbor)\n\n # The distance from start to a neighbor the \"dist_between\" function may vary as per the solution requirements.\n current_x = current.x\n current_y = current.y\n tentative_gScore = gScore[current_x][current_y] + dist_between(current, neighbor,d_diagnoal,d_straight)\n neighbor_x = neighbor.x\n neighbor_y = neighbor.y\n if tentative_gScore >= gScore[neighbor_x][neighbor_y]:\n continue\t\t# This is not a better path.\n\n neighbor.father = current\n cameFrom.append(neighbor)\n gScore[neighbor_x][neighbor_y] = tentative_gScore\n neighbor.g_value = tentative_gScore\n neighbor_f_value = gScore[neighbor_x][neighbor_y] + heuristic_cost_estimate(neighbor, goalNode,d_diagnoal,d_straight)\n fScore[neighbor_x][neighbor_y] = neighbor_f_value\n neighbor.f_value = neighbor_f_value\n return False","def solve(self):\n start = datetime.now()\n f = self.function\n while not self.converged():\n self.history.append(self.vertices)\n\n #step 1: sort\n self.order_vertices()\n\n #step 3: reflect\n reflected = self.get_reflected_point()\n if f(*self.vertices[0]) < f(*reflected) < f(*self.vertices[-1]):\n self.reflect()\n continue\n\n #step 4: expand\n if self.reflected_is_best():\n expanded = self.get_expanded_point()\n if f(*expanded) < f(*reflected):\n self.expand()\n else:\n self.reflect()\n continue\n\n #step 5: contract\n contracted = self.get_contracted_point()\n if f(*contracted) < f(*self.vertices[-1]):\n self.contract()\n continue\n\n #step 6: shrink\n self.shrink()\n print(\"optimization took {0}\".format(datetime.now()-start))\n return self.history, self.cache.history","def refugia_adj_5(params, ns):\n #17 parameters \n nu1_1, nu1_2, nuA, nu2, nu3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nu_T1 = [nu1_1, nuA]\n fs.integrate(nu_T1, T1a)\n ## Population function and migration matrix for T1b\n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\n fs.integrate(nu_T1, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1_2, nu2, nu3]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1_2, nu2, nu3]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def refugia_adj_5_full(params, ns):\n #22 parameters \n nu1_1a, nu1_1b, nu1_2, nu1_3, nuA_a, nuA_b, nu2_2, nu2_3, nu3_2, nu3_3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nu_T1a = [nu1_1a, nuA_a]\n fs.integrate(nu_T1a, T1a)\n ## Population function and migration matrix for T1b\n nu_T1b = [nu1_1b, nuA_b] \n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\n fs.integrate(nu_T1b, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1_2, nu2_2, nu3_2]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1_3, nu2_3, nu3_3]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def solution(n, s, a, b, fares):\n\n table = [[float(\"inf\")]*n for _ in range(n)]\n for (c, d, f) in fares:\n table[c-1][d-1] = f\n table[d-1][c-1] = f\n\n for idx in range(n):\n table[idx][idx] = 0\n\n # do floyd to find all shortest paths\n for kdx in range(n):\n for idx in range(n):\n for jdx in range(n):\n table[idx][jdx] = min(table[idx][jdx], table[idx][kdx] + table[kdx][jdx])\n \n# for row in table:\n# print(row)\n \n answer = table[s-1][a-1] + table[s-1][b-1]\n # print(\"seperate:\", answer)\n for idx in range(n):\n # print(\"idx 경유:\", idx, table[s-1][idx] + table[idx][a-1] + table[idx][b-1])\n answer = min(answer, table[s-1][idx] + table[idx][a-1] + table[idx][b-1])\n\n # print(\"answer:\", answer)\n return answer","def Problem3(n):\n A = Problem2(n)\n b = np.vstack(np.random.random(n))\n return A,sl.spsolve(A,b),b","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n\n\n\n\n path = [starting_car_location]\n dict = {}\n index = 0\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == starting_car_location:\n index = i\n\n path = [index]\n\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\n\n home_indexes = []\n\n for home in list_of_homes:\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == home:\n home_indexes.append(i)\n break\n\n new_adjacency = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n # for sake of figuring out where to walk\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, index, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2:\n di_path = nx.dijkstra_path(G, home1, home2)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n\n all_driving_path = list(nx.dfs_edges(G2))\n\n\n\n\n walking_to = []\n walking_from = {}\n\n for i in range(len(new_adjacency)):\n if i in home_indexes:\n count = 0\n edge_to = 0\n for j in range(len(new_adjacency)):\n if new_adjacency[i][j] != \"x\":\n count += 1\n edge_to = j\n\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\n if count == 1 and i != index and i not in walking_from.keys():\n new_adjacency[i][edge_to] = \"x\"\n new_adjacency[edge_to][i] = \"x\"\n walking_to.append(i)\n if edge_to in walking_from:\n walking_from[edge_to] = walking_from[edge_to] + [i]\n else:\n walking_from[edge_to] = [i]\n\n #\n # for i in range(len(all_driving_path) - 1):\n # #if first vertex in edge is the same, we should walk\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\n # print(all_driving_path[i][0])\n # print(all_driving_path[i][1])\n # #get rid of only edge connected to this home\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \"x\"\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \"x\"\n # walking_to.append(all_driving_path[i][1])\n # if all_driving_path[i][0] in walking_from:\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\n # else:\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\n\n\n\n dropoff_locations = list(walking_from.keys())\n for loc in dropoff_locations:\n if loc in home_indexes:\n dropoff_locations.remove(loc)\n\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n # G = G2\n # pos=nx.spring_layout(G2)\n # nx.draw_networkx_nodes(G2,pos)\n # nx.draw_networkx_labels(G2, pos)\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\n #\n # plt.draw()\n # plt.show()\n\n # condensed shortest paths to edges - use G3 for real\n\n new_adjacency2 = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n for home in home_indexes:\n if home not in walking_to:\n di_path = nx.dijkstra_path(G2, index, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\n di_path = nx.dijkstra_path(G2, home1, home2)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G2, index, loc)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G2, loc, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n\n\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\n drive_path = list(nx.dfs_edges(final_G, source=index))\n drive_path.append(index)\n\n mst = nx.minimum_spanning_tree(final_G)\n\n\n\n new_mst = nx.MultiGraph(mst)\n for edge in mst.edges():\n new_mst.add_edge(edge[0], edge[1])\n\n\n if new_mst.degree[index] != 0:\n to_remove = []\n for node in new_mst:\n if (new_mst.degree[node] == 0):\n to_remove.append(node)\n new_mst.remove_nodes_from(to_remove)\n\n eulerian = list(nx.eulerian_circuit(new_mst, index))\n\n path = []\n for edge in eulerian:\n path.append(edge[0])\n\n path.append(eulerian[len(eulerian) - 1][1])\n\n already_seen = []\n to_remove = []\n for i in range(len(path) - 1):\n if path[i] in already_seen:\n to_remove.append(i)\n else:\n already_seen.append(path[i])\n\n new_path = []\n for i in range(len(path) - 1):\n if i not in to_remove:\n new_path.append(path[i])\n path = new_path\n print(eulerian)\n else:\n path = [index]\n print(path)\n\n\n\n\n\n\n\n # print(path)\n final_path = []\n for node in path:\n if node == index:\n final_path.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path.append(node)\n # print(\"Dropoff loc: \", node)\n final_path.append(index)\n #print(walking_from)\n # print(final_path)\n # nx.draw(mst)\n # plt.draw()\n # plt.show()\n for node in final_path:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path = []\n for i in range(len(final_path) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path.append(condensed_path[j])\n\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\n very_final_path.append(index)\n\n if len(very_final_path) == 0:\n very_final_path = [index]\n\n print(very_final_path)\n print(dict)\n\n\n path2 = list(nx.dfs_preorder_nodes(mst, index))\n\n final_path2 = []\n for node in path2:\n if node == index:\n final_path2.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path2.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path2.append(node)\n # print(\"Dropoff loc: \", node)\n final_path2.append(index)\n\n\n for node in final_path2:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path2 = []\n for i in range(len(final_path2) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path2.append(condensed_path[j])\n\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\n very_final_path2.append(index)\n\n if len(very_final_path2) == 0:\n very_final_path2 = [index]\n\n opt1 = cost_of_solution(G, very_final_path, dict)\n opt2 = cost_of_solution(G, very_final_path2, dict)\n\n ultra_final_path = []\n if (opt1 <= opt2):\n ultra_final_path = very_final_path\n else:\n ultra_final_path = very_final_path2\n\n return ultra_final_path, dict\n\n pass","def value_iteration(P, nS, nA, gamma=0.9, tol=1e-3):\n\n\tvalue_function = np.zeros(nS)\n\tpolicy = np.zeros(nS, dtype=int)\n\tmax_num_iterations = 2000\n\n\t############################\n\t# YOUR IMPLEMENTATION HERE #\n\n\tfor i in range(max_num_iterations):\n\t\tprevious_value_function = np.copy(value_function)\n\t\tfor s in range(nS):\t# for each state\n\t\t\tq_values = np.zeros(nA)\n\t\t\tfor action in range(nA):\t# for each action\n\t\t\t\tq_value = 0\n\t\t\t\tfor transition in P[s][action]:\t# for every possible transition\n\t\t\t\t\tprobability = transition[0]\n\t\t\t\t\treward = transition[2]\n\t\t\t\t\tnext_state = transition[1]\n\t\t\t\t\tvalue_next_state = previous_value_function[next_state]\n\n\t\t\t\t\t# print(\"probability: \" + str(probability) + \"reward: \" + str(reward) + \"value next state: \" + str(value_next_state))\n\n\t\t\t\t\tq_value += probability * (reward + gamma * value_next_state)\n\t\t\t\t\n\t\t\t\tq_values[action] = q_value\n\n\t\t\tvalue_function[s] = np.amax(q_values)\t# the value is the max of these q values\n\t\t\t# extract policy\n\t\t\tpolicy[s] = np.argmax(q_values)\n\n\t\t# find the maximum difference between the previous value function and the current value function\n\t\tdifArray = np.subtract(value_function, previous_value_function)\n\t\tfor x in range(nS):\n\t\t\tdifArray[x] = abs(difArray[x])\n\t\tmaxDif = np.amax(difArray)\n\n\t\tif (maxDif < tol):\n\t\t\tprint(\"optimal policy found at iteration \" + str(i + 1))\n\t\t\tbreak\n\n\t############################\n\treturn value_function, policy","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def _solve_explicit(self, initial_conditions):\n coeff = self.a ** 2 * self.tau / self.h ** 2\n current_solution = initial_conditions\n next_solution = np.empty_like(current_solution)\n solutions = []\n\n for t in self.t_grid:\n next_solution[1:-1] = (\n current_solution[1:-1]\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\n\n # left bc\n if self.left_bc_type == \"DIRICHLET\":\n next_solution[0] = self.left_bc(t)\n elif self.left_bc_type == \"NEUMANN\":\n next_solution[0] = (\n 4 * next_solution[1]\n - next_solution[2]\n - 2 * self.h * self.left_bc(t)\n ) / 3.0\n\n # right bc\n if self.right_bc_type == \"DIRICHLET\":\n next_solution[-1] = self.right_bc(t)\n elif self.right_bc_type == \"NEUMANN\":\n next_solution[-1] = (\n 4 * next_solution[-2]\n - next_solution[-3]\n + 2 * self.h * self.right_bc(t)\n ) / 3.0\n if self.mode == \"VISUALIZATION\":\n solutions.append((t, next_solution.copy()))\n current_solution = next_solution\n if self.mode == \"TEST\":\n # print(\"Result: \", current_solution.tolist())\n # print(\"Right answer: \", self.anl_solution.tolist())\n self._norma(current_solution)\n elif self.mode == \"VISUALIZATION\":\n return solutions","def generate(self):\n \n ##Dictionary of put values\n self.put = {}\n ##Dictionary of call values\n self.call = {}\n \n bottom = self.range[0]\n top = self.range[2]\n iter = self.range[1]\n \n if self.meth == 'bi':\n for E in range(bottom,top+iter,iter):\n solver = bi.binomial_euro(S=self.S,E=E,r=self.r,M=400,sigma=self.sigma,method='higham',T=self.T,opt='put')\n self.put[E] = solver.solve()\n del solver\n for E in range(bottom,top+iter,iter):\n solver = bi.binomial_euro(S=self.S,E=E,r=self.r,M=400,sigma=self.sigma,method='higham',T=self.T,opt='call')\n self.call[E] = solver.solve()\n del solver\n elif self.meth == 'mc':\n for E in range(bottom,top+iter,iter):\n solver = mc.mcfast_euro(S=self.S,E=E,r=self.r,M=20000,sigma=self.sigma,T=self.T,opt='put')\n self.put[E] = solver.solve()\n del solver\n for E in range(bottom,top+iter,iter):\n solver = mc.mcfast_euro(S=self.S,E=E,r=self.r,M=20000,sigma=self.sigma,T=self.T,opt='call')\n self.call[E] = solver.solve()\n del solver\n elif self.meth == 'all':\n pass","def compute_complexity(folder: str,\n neat: bool = False,\n neat_gru: bool = False,\n neat_lstm: bool = False,\n neat_sru: bool = False,\n neat_sru_s: bool = False,\n gen: int = 500,\n max_v: int = 50,\n ):\n # Collect all the populations\n populations = []\n if neat: populations.append(D_NEAT)\n if neat_gru: populations.append(D_NEAT_GRU)\n if neat_lstm: populations.append(D_NEAT_LSTM)\n if neat_sru: populations.append(D_NEAT_SRU)\n if neat_sru_s: populations.append(D_NEAT_SRU_S)\n if len(populations) == 0: return\n \n # Go over all possibilities\n print(f\"\\n===> COMPUTING POPULATION'S ELITE COMPLEXITY <===\")\n path = f\"population_backup/storage/{folder}/\"\n genes_dict = dict()\n for pop in populations:\n path_eval = get_subfolder(f\"{path}{pop}/\", 'evaluation')\n complexity = Counter()\n genes = Counter()\n genes_detailed = dict()\n for v in range(1, max_v + 1):\n population = Population(\n name=f'{pop}/v{v}',\n folder_name=folder,\n use_backup=True,\n )\n if population.generation == 0: raise Exception(f\"Population {pop}/v{v} loaded incorrectly\")\n if population.generation != gen: population.load(gen=gen)\n s = population.best_genome.size()\n complexity[str(s)] += 1\n c = str(s[0] + s[1])\n genes[c] += 1\n if c in genes_detailed:\n genes_detailed[c].append(v)\n else:\n genes_detailed[c] = [v]\n \n # Store results at populations themselves\n update_dict(f'{path_eval}complexity_topology', complexity, overwrite=True)\n update_dict(f'{path_eval}complexity_genes', genes, overwrite=True)\n update_dict(f'{path_eval}complexity_genes_detailed', genes_detailed, overwrite=True)\n \n # Update global dictionary\n keys = list(genes.keys())\n for k in keys:\n genes[int(k)] = genes[k]\n del genes[k]\n genes_dict[pop] = list(sorted(genes.items()))\n \n plt.figure(figsize=(10, 2.5))\n max_x = max([max([a for a, _ in genes_dict[pop]]) for pop in populations])\n min_x = min([min([a for a, _ in genes_dict[pop]]) for pop in populations])\n for idx, pop in enumerate(populations):\n keys = [a for a, _ in genes_dict[pop]]\n for x in range(max_x):\n if x not in keys: genes_dict[pop].append((x, 0))\n x, y = zip(*genes_dict[pop])\n width = 0.8 / len(populations)\n plt.bar(x=np.asarray(x) - 0.4 + width / 2 + idx * width,\n height=y,\n width=width,\n linewidth=2,\n label=pop,\n color=COLORS[pop])\n \n # Beautify the plot\n plt.xlim(min_x - .5, max_x + .5)\n plt.xticks([i for i in range(min_x, max_x + 1)])\n leg = plt.legend(loc='upper center',\n bbox_to_anchor=(0.5, 1.18),\n fancybox=True,\n fontsize=10,\n ncol=len(populations))\n for line in leg.get_lines():\n line.set_linewidth(4.0)\n plt.grid(axis='y')\n plt.tight_layout()\n plt.xlabel(\"complexity expressed in #genes\")\n plt.ylabel(\"#elites\")\n plt.savefig(f\"population_backup/storage/{folder}/images/complexity.png\", bbox_inches='tight', pad_inches=0.02)\n plt.savefig(f\"population_backup/storage/{folder}/images/complexity.eps\",\n format='eps',\n bbox_inches='tight',\n pad_inches=0.02)\n # plt.show()\n plt.close()\n \n # Also create a violin plot of the distribution if only two populations\n if len(populations) == 2:\n max_x = 0\n min_x = float('inf')\n df = pd.DataFrame()\n palette = []\n for idx, pop in enumerate(populations):\n values = []\n for a, b in genes_dict[pop]:\n for _ in range(b):\n values.append(a)\n \n # Remove outliers\n values = sorted(values)\n q1 = min(values[int(round(1 / 4 * len(values)))], values[int(round(3 / 4 * len(values)))])\n q3 = max(values[int(round(1 / 4 * len(values)))], values[int(round(3 / 4 * len(values)))])\n iqr = q3 - q1\n \n for i in range(len(values) - 1, -1, -1):\n if (values[i] < (q1 - 1.5 * iqr)) or (values[i] > (q3 + 1.5 * iqr)): del values[i]\n if min(values) < min_x: min_x = min(values)\n if max(values) > max_x: max_x = max(values)\n df = df.append(pd.DataFrame({'complexity': values, 'y': 'ignore', 'pop': pop}))\n palette.append(COLORS[pop])\n \n # Create the plot\n plt.figure(figsize=(10, 2.5))\n sns.violinplot(data=df,\n x=\"complexity\", y=\"y\", hue=\"pop\",\n palette=palette, split=True,\n inner=\"quartile\")\n plt.xlim(min_x - .5, max_x + .5)\n plt.xticks([i for i in range(min_x, max_x + 1)])\n plt.xlabel(\"complexity expressed in #genes\")\n plt.yticks([])\n plt.ylabel('elite genome density')\n leg = plt.legend(loc='upper center',\n bbox_to_anchor=(0.5, 1.25),\n fancybox=True,\n fontsize=10,\n ncol=len(populations))\n for line in leg.get_lines():\n line.set_linewidth(4.0)\n plt.tight_layout()\n plt.savefig(f\"population_backup/storage/{folder}/images/complexity_violin.png\",\n bbox_inches='tight',\n pad_inches=0.02)\n plt.savefig(f\"population_backup/storage/{folder}/images/complexity_violin.eps\",\n format='eps',\n bbox_inches='tight',\n pad_inches=0.02)\n plt.show()\n plt.close()","def cost_function(H, n_qubits, p, params):\n ini_state=plus_state(n_qubits)\n for i in range(p):\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state","def prob3():\n #set up the matrices\n solvers.options['show_progress'] = False\n c = np.array([4., 7., 6., 8., 8., 9.])\n\n G = np.array([[1.,1.,0.,0.,0.,0.],\n [-1.,-1.,0.,0.,0.,0.],\n [0.,0.,1.,1.,0.,0.],\n [0.,0.,-1.,-1.,0.,0.],\n [0.,0.,0.,0.,1.,1.],\n [0.,0.,0.,0.,-1.,-1.],\n [1.,0.,1.,0.,1.,0.],\n [-1.,0.,-1.,0.,-1.,0.],\n [0.,1.,0.,1.,0.,1.],\n [0.,-1.,0.,-1.,0.,-1.]])\n G = np.vstack((G, -1*np.eye(6)))\n h = np.array([7,-7,2,-2,4,-4,5,-5,8,-8,0,0,0,0,0,0],dtype=\"float\")\n\n #convert the matrices\n c = matrix(c)\n G = matrix(G)\n h = matrix(h)\n #solve the matrices\n sol = solvers.lp(c, G, h)\n return np.ravel(sol['x']), sol['primal objective']","def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n result_list = []\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n \"\"\"Embedded function version\n \"\"\"\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\n fidelities = []\n for training_state in training_states:\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\n exact=exact, noisy=noisy)\n fidelities.append(fid)\n avg_fid = np.mean(fidelities)\n result_list.append(1-avg_fid)\n print(1-avg_fid)\n return 1. - avg_fid\n\n \n # Initialize parameters\n half_turn_min = 0\n half_turn_max = 2\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\n size=num_param)\n\n # Optimization using Nelder-Mead.\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\n \n if noisy:\n maxiter = 60\n else:\n maxiter = None\n \n res = minimize(h2_qae_wrap, init_params, args=(),\n method='Nelder-Mead', tol=None, \n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\n 'return_all': False, 'fatol': 0.001})\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\n return res.x","def optimize(self, iterations=1000):\r\n prev = None\r\n finalx = None\r\n finaly = None\r\n while iterations:\r\n maxei, eis = self.acquisition()\r\n new_y = self.f(maxei)\r\n if maxei == prev:\r\n break\r\n self.gp.update(maxei, new_y)\r\n pycodehack = finaly is None or self.minimize and finaly > new_y\r\n if ((pycodehack or not self.minimize and finaly < new_y)):\r\n finaly = new_y\r\n finalx = maxei\r\n prev = maxei\r\n iterations -= 1\r\n return finalx, finaly","def refugia_adj_1_growthall(params, ns):\n #14 parameters \n nu10, nu1, nuA0, nuA, nu20, nu2, nu30, nu3, m3_1, m3_2, m3_3, T1, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1\n nuA_func = lambda t: nuA0 * (nuA/nuA0)**(t/T1) \n ## Population function for T1\n nu_T1_func = lambda t: [nu1, nuA_func(t)]\n fs.integrate(nu_T1_func, T1)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1, nu2, nu3]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu1_func = lambda t: nu10 * (nu1/nu10)**(t/T3) \n nu2_func = lambda t: nu20 * (nu2/nu20)**(t/T3) \n nu3_func = lambda t: nu30 * (nu3/nu30)**(t/T3) \n nu_T3_func = lambda t: [nu1_func(t), nu2_func(t), nu3_func(t)] \n mig3 = numpy.array([[0, m3_1, m3_3],[m3_1, 0, m3_2], [m3_3, m3_2, 0]]) \n fs.integrate(nu_T3_func, T3, m=mig3) \n return fs","def solve(self, niter):\n E = self.list_PDE[0]\n I = self.list_PDE[1]\n\n # ...\n un = E.unknown\n unew = I.unknown\n\n# un.set(E.rhs)\n # ...\n\n # ...\n for i in range(0,niter):\n\n rhs = E.dot(un)\n I.solve(rhs)\n\n un.set(unew)\n # ...","def get_problem():\n\n # Rename this and/or move to optim package?\n problem = beluga.optim.Problem('Hannibal_HPAdemo')\n problem.mode='analytical' #Other options: 'numerical', 'dae'\n\n #Define independent variables\n problem.independent('t', 's')\n\n #~~~~~!!!\n #problem.quantity('terrain3','(-0.3*exp(-0.5*((x-2.7)^2+1.5*(y-2.1)^2))+2.6*exp(-0.55*(0.87*(x-6.7)^2+(y-2.2)^2))+2.1*exp(-0.27*(0.2*(x-5.5)^2+(y-7.2)^2))+1.6*(cos(0.8*y))^2*(sin(0.796*x))^2)')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','m') \\\n .state('y','V*sin(hdg)','m') \\\n\n # Define controls\n problem.control('hdg','rad')\n\n # Define Cost Functional\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\n\n #Define constraints\n problem.constraints().initial('x-x_0','m') \\\n .initial('y-y_0','m') \\\n .terminal('x-x_f','m') \\\n .terminal('y-y_f','m')\n\n #Define constants\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\n problem.constant('conv',1,'s/m^2') #Integral conversion factor\n problem.constant('V',1,'m/s') #Vehicle speed\n problem.constant('elev',1,'m') #Initial Elevation\n\n #Unit scaling\n problem.scale.unit('m',1) \\\n .unit('s',1) \\\n .unit('rad',1)\n\n #Configure solver\n #problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=8)\n problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=15, verbose = True, cached = False)\n\n #Initial Guess (Classic test example [4.9,0.4])\n problem.guess.setup('auto',start=[9.0,0.5], costate_guess=[0.0,-0.1]) #City A\n #problem.guess.setup('auto',start=[4.9,0.4], costate_guess=[0.1,-0.1]) #City A\n\n #Add Continuation Steps (Classic test example [7.2,8.5]) [8, 4.5]\n problem.steps.add_step(strategy='HPA',hweight=0.9) \\\n .terminal('x', 3.0, 10) \\\n .terminal('y', 9.5, 10) \\\n # .const('w', 0.9, 2, confined=True)\n\n #problem.steps.add_step(strategy='manual').num_cases(10) \\\n # .terminal('x', 3.0) \\\n # .terminal('y', 9.5) \\\n\n #problem.steps.add_step().num_cases(30) \\\n # .const('w',0.99) #Final Terrain weighting factor\n\n\n return problem","def compute_costs(self, node, observation=None, area=None):\n if (node.RRT.hierarchy_number == 0) and (\n node in node.RRT.starts.values()): # in case an observation is made immediately (root node has no parent)\n return node.path_costs, node.terminal_costs, node.node_costs\n\n C = self.get_C(observation, area)\n node.vs = self.get_vs(node, C)\n\n # Compute node, and terminal costs\n h = []\n hN = []\n for i in range(self.N_goal_states):\n h.append(self.cost_h(node, self.goal_states[i]))\n hN.append(self.cost_hN(node, self.goal_states[i]))\n\n path_costs = node.parent.path_costs.copy() + node.parent.node_costs.copy()\n\n N_vs = len(node.vs)\n node_costs = []\n terminal_costs = []\n for i in range(N_vs):\n node_costs.append(np.dot(h, node.vs[i]))\n terminal_costs.append(np.dot(hN, node.vs[i]))\n node_costs = np.array(node_costs).reshape((1, N_vs))\n terminal_costs = np.array(terminal_costs).reshape((1, N_vs))\n\n if path_costs.shape[1] == node_costs.shape[1] / self.N_goal_states:\n path_costs_temp = np.zeros(node_costs.shape)\n for i in range(int(node_costs.shape[1] / self.N_goal_states)):\n for j in range(self.N_goal_states):\n path_costs_temp[0, self.N_goal_states * i + j] = path_costs[0, i].copy() + node_costs[\n 0, self.N_goal_states * i + j].copy()\n path_costs = path_costs_temp.copy()\n\n return path_costs, terminal_costs, node_costs","def optimal_nc(f, xl: float, xr: float, n: int, tol: float, *params):\n # required local variables to return\n # S : computed value of the integral with required tolerance\n # N : number of steps for S\n # err : estimated error of S\n # iter : number of iterations (steps doubling)\n iter = 1\n N = 200\n h_old = (xr - xl) / (4*N)\n\n s1 = composite_quad(f, xl, xr, N, n, *params)\n N *= 2\n s2 = composite_quad(f, xl, xr, N, n, *params)\n N *= 2\n s3 = composite_quad(f, xl, xr, N, n, *params)\n\n L = 2\n m = aitken(s1, s2, s3, L)\n\n\n # если m далеко от теоретического значения, значит мы находимся в области,\n # где отброшенные величины не малы и нам нужно продолжать делить шаг\n while m > 4.5 or m < 2.5:\n s1 = s2\n s2 = s3\n N *= 2\n s3 = composite_quad(f, xl, xr, N, n, *params)\n m = aitken(s1, s2, s3, L)\n\n # далее предлагаем идти по оптимальному шагу\n coef = 0.95\n h_new = coef * h_old * (tol / np.abs(runge(s2, s3, L, m))) ** (1 / m)\n\n N = int((xr - xl) / h_new) + 1\n\n while iter != MAXITER + 1:\n s1 = s2\n s2 = s3\n\n s3 = composite_quad(f, xl, xr, N, n, *params)\n\n m = aitken(s1, s2, s3, L)\n\n # берём погрешность из метода рунге\n estimate = np.abs(runge(s2, s3, L, m))\n\n if estimate < tol:\n return N, s3, estimate\n\n N *= 2\n iter += 1\n\n print(\"Convergence not reached!\")\n return 0, 0, 10 * tol, -100","def optimize_parameters(self):\n # forward\n for i in range(min(self.big_iter+1,len(self.orders_rev))):\n if(self.orders_rev):\n # compute fake images and reconstruction images.\n self.forward(i,False)\n # G_A and G_B\n # Ds require no gradients when optimizing Gs\n self.set_requires_grad(self.netD, False)\n # set G_A and G_B's gradients to zero\n self.optimizers_G[self.orders_rev[i]].zero_grad()\n # calculate gradients for G_A and G_B\n self.backward_G(i,False)\n # update G_A and G_B's weights\n self.optimizers_G[self.orders_rev[i]].step()\n # D_A and D_B\n self.set_requires_grad(self.netD, True)\n self.optimizer_D.zero_grad() \n self.backward_D(i,False) \n self.optimizer_D.step() \n else:\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\n self.backward_DY() # calculate gradients for D_A\n self.optimizer_D.step()\n for i in range(min(self.big_iter+1, len(self.orders))):\n if(self.orders):\n if(i>0):\n self.real_A = self.fake_B.detach()\n self.forward(i,True) # compute fake images and reconstruction images.\n # G_A and G_B\n # Ds require no gradients when optimizing Gs\n self.set_requires_grad(self.netD, False)\n # set G_A and G_B's gradients to zero\n self.optimizers_G[self.orders[i]].zero_grad()\n self.backward_G(i,True) # calculate gradients for G_A and G_B\n # update G_A and G_B's weights\n self.optimizers_G[self.orders[i]].step()\n # D_A and D_B\n self.set_requires_grad(self.netD, True)\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\n self.backward_D(i,True) # calculate gradients for D_A\n self.optimizer_D.step() \n else:\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\n self.backward_DX() # calculate gradients for D_A\n self.optimizer_D.step() \n self.current_label=self.labels[0]\n self.current_order=self.orders\n self.current_pred = np.concatenate((self.pred_real.detach().cpu().numpy().mean(\n axis=2).mean(axis=2), self.pred_fake.detach().cpu().numpy().mean(axis=2).mean(axis=2)))","def linearize_and_solve(g):\n\n # initialize the sparse H and the vector b\n H = np.zeros((len(g.x), len(g.x)), dtype='float')\n b = np.zeros(len(g.x), dtype='float')\n\n # set flag to fix gauge\n needToAddPrior = True\n Fx = 0\n\n # compute the addend term to H and b for each of our constraints\n print('linearize and build system')\n\n for edge in g.edges:\n\n # pose-pose constraint\n if edge.Type == 'P':\n\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node state for the current edge\n x_i = g.x[fromIdx:fromIdx + 3]\n x_j = g.x[toIdx:toIdx + 3]\n\n # (TODO) compute the error and the Jacobians\n e, A, B = linearize_pose_pose_constraint(\n x_i, x_j, edge.measurement)\n\n # # (TODO) compute the terms\n b_i = e.transpose() @ edge.information @ A\n b_j = e.transpose() @ edge.information @ B\n H_ii = A.transpose() @ edge.information @ A\n H_ij = A.transpose() @ edge.information @ B\n H_jj = B.transpose() @ edge.information @ B\n\n # (TODO) add the terms to H matrix and b\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\n H[toIdx:toIdx + 3, toIdx:toIdx + 3] += H_jj\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 3] += H_ij\n H[toIdx:toIdx + 3, fromIdx:fromIdx + 3, ] += H_ij.transpose()\n b[fromIdx:fromIdx + 3] += b_i[0, :]\n b[toIdx:toIdx + 3] += b_j[0, :]\n\n # Add the prior for one pose of this edge\n # This fixes one node to remain at its current location\n if needToAddPrior:\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx +\n 3] = H[fromIdx:fromIdx + 3,\n fromIdx:fromIdx + 3] + 1000 * np.eye(3)\n needToAddPrior = False\n\n # pose-pose constraint\n elif edge.Type == 'L':\n print(\"you shouldn't be here...\")\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node states for the current edge\n x = g.x[fromIdx:fromIdx + 3]\n l = g.x[toIdx:toIdx + 2]\n\n # (TODO) compute the error and the Jacobians\n e, A, B = linearize_pose_landmark_constraint(\n x, l, edge.measurement)\n\n # (TODO) compute the terms\n b_i = e.transpose() @ edge.information @ A\n b_j = e.transpose() @ edge.information @ B\n H_ii = A.transpose() @ edge.information @ A\n H_ij = A.transpose() @ edge.information @ B\n H_jj = B.transpose() @ edge.information @ B\n\n # (TODO )add the terms to H matrix and b\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\n H[toIdx:toIdx + 2, toIdx:toIdx + 2] += H_jj\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 2] += H_ij\n H[toIdx:toIdx + 2, fromIdx:fromIdx + 3, ] += H_ij.transpose()\n b[fromIdx:fromIdx + 3] = b_i\n b[toIdx:toIdx + 2] = b_j\n # solve system\n dx = np.linalg.solve(H, b)\n\n return dx","def solve(self):\n self.enforce_node_consistency()\n self.ac3()\n return self.backtrack(dict())","def solve(self):\n self.enforce_node_consistency()\n self.ac3()\n return self.backtrack(dict())","def solve(self):\n self.enforce_node_consistency()\n self.ac3()\n return self.backtrack(dict())","def resolve_internal(g, path):\n n = len(g)\n for step in range(1, n):\n for k in range(n):\n for i in range(n):\n for j in range(n):\n cost = g[i][k][step-1] * g[k][j][0]\n if g[i][j][step] < cost:\n g[i][j][step] = cost\n path[i][j][step] = k\n if i == j and g[i][i][step] > 1.01:\n return recover_path(path, n, step, i, j)\n return None","def solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\n\n print(\"Solving random problems with solver %s\\n\" % solver)\n\n # Define statistics to record\n std_solve_time = np.zeros(len(n_vec))\n avg_solve_time = np.zeros(len(n_vec))\n min_solve_time = np.zeros(len(n_vec))\n max_solve_time = np.zeros(len(n_vec))\n\n n_prob = len(n_vec)\n\n # Store also OSQP time\n if solver == 'miosqp':\n # Add OSQP solve times statistics\n avg_osqp_solve_time = np.zeros(len(n_vec))\n\n # reset random seed\n np.random.seed(seed)\n\n for i in range(n_prob):\n\n # Get dimensions\n n = n_vec[i]\n m = m_vec[i]\n p = p_vec[i]\n\n print(\"problem n = %i, m = %i, p = %i\" % (n, m, p))\n\n # Define vector of cpu times\n solve_time_temp = np.zeros(repeat)\n\n # Store also OSQP time\n if solver == 'miosqp':\n osqp_solve_time_temp = np.zeros(repeat)\n\n for j in tqdm(range(repeat)):\n # for j in range(repeat):\n\n # Generate random vector of indeces\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\n\n # Generate random Matrices\n Pt = spa.random(n, n, density=dns_level)\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\n q = sp.randn(n)\n A = spa.random(m, n, density=dns_level)\n u = 2 + sp.rand(m)\n l = -2 + sp.rand(m)\n\n # Enforce [0, 1] bounds on variables\n i_l = np.zeros(p)\n i_u = np.ones(p)\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\n\n if solver == 'gurobi':\n # Solve with gurobi\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\n verbose=False, Threads=1)\n if res_gurobi.status != 'optimal':\n import ipdb\n ipdb.set_trace()\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\n\n elif solver == 'miosqp':\n # Define problem settings\n miosqp_settings = {\n # integer feasibility tolerance\n 'eps_int_feas': 1e-03,\n # maximum number of iterations\n 'max_iter_bb': 1000,\n # tree exploration rule\n # [0] depth first\n # [1] two-phase: depth first until first incumbent and then best bound\n 'tree_explor_rule': 1,\n # branching rule\n # [0] max fractional part\n 'branching_rule': 0,\n 'verbose': False,\n 'print_interval': 1}\n\n osqp_settings = {'eps_abs': 1e-03,\n 'eps_rel': 1e-03,\n 'eps_prim_inf': 1e-04,\n 'verbose': False}\n\n model = miosqp.MIOSQP()\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\n miosqp_settings,\n osqp_settings)\n res_miosqp = model.solve()\n\n # DEBUG (check if solutions match)\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\n # import ipdb; ipdb.set_trace()\n#\n # import ipdb; ipdb.set_trace()\n\n if res_miosqp.status != miosqp.MI_SOLVED:\n import ipdb\n ipdb.set_trace()\n \n # Solution time \n solve_time_temp[j] = 1e3 * res_miosqp.run_time\n\n # Store OSQP time in percentage\n if solver == 'miosqp':\n osqp_solve_time_temp[j] = \\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\n\n # Get time statistics\n std_solve_time[i] = np.std(solve_time_temp)\n avg_solve_time[i] = np.mean(solve_time_temp)\n max_solve_time[i] = np.max(solve_time_temp)\n min_solve_time[i] = np.min(solve_time_temp)\n\n # Store also OSQP time\n if solver == 'miosqp':\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\n\n # Create pandas dataframe for the results\n df_dict = {'n': n_vec,\n 'm': m_vec,\n 'p': p_vec,\n 't_min': min_solve_time,\n 't_max': max_solve_time,\n 't_avg': avg_solve_time,\n 't_std': std_solve_time}\n\n # Store also OSQP time\n if solver == 'miosqp':\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\n\n timings = pd.DataFrame(df_dict)\n\n return timings","def solve(self, **kwargs):\n\n sorted_compute_nodes = sorted(\n self.physical.compute_nodes,\n key=lambda x: self.physical.cores(x) * 1000 + self.physical.memory(x),\n reverse=True,\n )\n\n for n_partitions_to_try in range(\n self.lower_bound(), len(sorted_compute_nodes) + 1\n ):\n\n # partitioning of virtual nodes in n_partitions_to_try partitions\n k_partition = get_partitions(\n self.virtual.g, n_partitions=n_partitions_to_try\n )\n\n # subset of hosts of size n_partitions_to_try\n chosen_physical = sorted_compute_nodes[:n_partitions_to_try]\n\n #\n # check if the partitioning is a feasible solution\n #\n try:\n # virtual nodes to physical nodes assignment\n res_node_mapping = {}\n\n # iterate over each pair (physical_node i, virtual nodes assigned to i)\n for physical_node, assigned_virtual_nodes in zip(\n chosen_physical, k_partition\n ):\n # keep track of the node physical resources used\n cores_used = memory_used = 0\n # check if node resources are not exceeded:\n for virtual_node in assigned_virtual_nodes:\n # cpu cores\n cores_used += self.virtual.req_cores(virtual_node)\n if self.physical.cores(physical_node) < cores_used:\n raise NodeResourceError(physical_node, \"cpu cores\")\n # memory\n memory_used += self.virtual.req_memory(virtual_node)\n if self.physical.memory(physical_node) < memory_used:\n raise NodeResourceError(physical_node, \"memory\")\n # assign the virtual nodes to a physical node\n res_node_mapping[virtual_node] = physical_node\n\n #\n # virtual links to physical links assignment\n #\n res_link_mapping = {}\n rate_used = defaultdict(int)\n\n # iterate over each virtual link between two virtual nodes not mapped on the same physical machine\n for (u, v) in (\n (u, v)\n for (u, v) in self.virtual.sorted_edges()\n if res_node_mapping[u] != res_node_mapping[v]\n ):\n\n res_link_mapping[(u, v)] = []\n\n # physical nodes on which u and v have been placed\n phy_u, phy_v = res_node_mapping[u], res_node_mapping[v]\n\n # for each link in the physical path\n for (i, j, device_id) in self.physical.find_path(\n phy_u,\n phy_v,\n req_rate=self.virtual.req_rate(u, v),\n used_rate=rate_used,\n ):\n # else update the rate\n rate_used[(i, j, device_id)] += self.virtual.req_rate(u, v)\n\n res_link_mapping[(u, v)].append((i, device_id, j))\n\n # build solution from the output\n self.solution = Solution.build_solution(\n self.virtual, self.physical, res_node_mapping, res_link_mapping\n )\n self.status = Solved\n return Solved\n\n except (NodeResourceError, NoPathFoundError):\n # unfeasible, increase the number of partitions to be used\n pass\n else:\n self.status = Infeasible\n return Infeasible","def computeForces(self, neighbors=[]): #computing forces to drive the agents and avoid collisions \n if not self.atGoal:\n if self.entry_state % 2 == 0 and len(self.entrancex) > 0 and self.id != 4 : #checks if assigned curve is entry and switches to state 1 to follow entry bezier curve\n time2=0.5 # time used to calculate driving force \n self.local_goal = [self.entrancex[0], self.entrancey[0]] #assigning waypoint as goal\n self.rel_posi = self.local_goal - self.pos #calculating relative position between agents\n self.n_bez = (self.rel_posi + (self.prefspeed*time2))/(abs(self.rel_posi + (self.prefspeed*time2))) #calculating direction vector\n self.F = ((max(self.timehor - time2/100, 0)/time2)*self.n_bez) #driving force\n self.entrancex = np.delete(self.entrancex,0) #eliminating the used waypoints from the list \n self.entrancey = np.delete(self.entrancey,0) #eliminating the used waypoints from the list \n \n elif self.force_state == 1 and (abs(self.pos[0] - self.goal[0]) >400 or abs(self.pos[1] - self.goal[1]) >400): #checks if force-based navigation is assigned, switches to state 2\n self.F = (self.gvel-self.vel)/self.ksi #driving force\n for neighbor in neighbors:\n if neighbor.id != self.id: #and not neighbor.atGoal: \n distSq = (neighbor.pos-self.pos).dot(neighbor.pos-self.pos)\n #print(distSq, self.dhorSq)\n if distSq < self.dhorSq: # neighbor is inside the sensing radius\n tau = self.ttc(neighbor)\n #print(tau, self.timehor)\n if tau < self.timehor: # will the two agents collide in less than timehor?\n dir = self.pos + self.vel*tau - neighbor.pos - neighbor.vel*tau \n length = sqrt(dir.dot(dir))\n if length > 0:\n dir = dir/length # the direction of the force\n mag = (self.timehor - tau)/(tau + 1e-6) # the magnitude of the force\n self.F += mag*dir # add the force\n \n else: #state 3 - following the exit bezier curve\n time2=0.5 # time used to calculate driving force\n self.local_goal = [self.exitx[0], self.exity[0]]\n if abs(sqrt((self.local_goal - self.pos).dot((self.local_goal - self.pos)))) >10: #to reach first point of exit curve from agents previous state position\n self.F = ((self.local_goal - self.pos)/(sqrt((self.local_goal - self.pos).dot((self.local_goal - self.pos) )))*self.prefspeed)/self.ksi\n else:\n self.rel_posi = self.local_goal - self.pos #calculating relative position between agents\n self.n_bez = (self.rel_posi + (self.prefspeed*time2))/(abs(self.rel_posi + (self.prefspeed*time2)))\n self.F = ((max(self.timehor - time2/100, 0)/time2)*self.n_bez)\n #print(self.pos, self.local_goal)\n if len(self.exitx) > 1 :\n self.exitx = np.delete(self.exitx,0)\n self.exity = np.delete(self.exity,0)","def refugia_adj_5_full_2_iter3 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def main():\n A = np.array([\n [40, 36],\n [36, 45]\n ])\n b = np.array([-64, -66])\n c = 27\n solve(Task1TargetFunction(A, b, c))","def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\n # assigning cost of changing from one leg to another based on the distance to the desired pose\n cost_ChangeLeg = 1\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\n if dz_final < 1:\n cost_ChangeLeg = 10\n elif dz_final < 2:\n cost_ChangeLeg = 20\n else:\n cost_ChangeLeg = 10\n\n # assigning weight for cost of predicted repositioning and cost of robot motion\n w_cost_reposition = 40\n w_cost_motion = 10\n\n # finding object's leg cordinates\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\n\n # initialization (initializeing cost to infinity)\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\n cost_legchange = [0, 0, 0, 0]\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\n cost_manipulation = [0, 0, 0, 0]\n cost_motion = [0, 0, 0, 0]\n force = [0, 0, 0, 0]\n path = [[[], []], [[], []], [[], []], [[], []]]\n planned_path_w = [[],[],[],[]]\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\n command = [[], [], [], []]\n des = [[], [], [], [], []]\n PAM_goal = state()\n\n # find the nominal trajectory for manipulation\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\n\n # itterate through each leg to find the leg with minimum cost\n for leg in range(4):\n phi_linear = theta\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\n \t# find the cost and required force for manipulation for the leg\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\n \t# adding cost of changing leg\n if leg != current_leg:\n cost_legchange[leg] = cost_ChangeLeg\n # adding cost of PAM motion to PAM goal pose\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\n if cost_PAM[leg][push_pull]!= float(\"inf\"):\n PAM_s_sim = copy.deepcopy(PAM_s)\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n # adding cost of predicted re-positionings\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\n # print(n_transition)\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\n else:\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\n for push_pull in [0,1]:\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\n\n if min(cost) < float(\"inf\"):\n \t[min_index, min_value] = [np.argmin(cost), min(cost)]\n \t# Finding the grasping goal pose based on the selected plan\n \tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\n \tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\n \tPAM_goal = state()\n \tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\n \tobject_path_planned = Path()\n \tobject_path_planned.header.frame_id = 'frame_0'\n \tfor i in range(len(planned_path_w[min_index])):\n \t\tpose = PoseStamped()\n \t\tpose.pose.position.x = planned_path_w[min_index][i][0]\n \t\tpose.pose.position.y = planned_path_w[min_index][i][1]\n \t\tpose.pose.position.z = 0\n \t\tobject_path_planned.poses.append(pose)\n\n \tPAM_path_planned = Path()\n \tPAM_path_planned.header.frame_id = 'frame_0'\n \tif min_index != current_leg:\n \t\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\n \t\t\tpose = PoseStamped()\n \t\t\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\n \t\t\tPAM_path_planned.poses.append(pose)\n else:\n \tmin_index = 5\n \tmin_value = float(\"inf\")\n if 0 < min_index and min_index <= 4:\n force_d = force[min_index][0]\n else:\n force_d = [0,0,0]\n\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n\n #Creamos las estructuras de datos necesarias (priority queue y set)\n openNodes = util.PriorityQueue()\n closedNodes = set([])\n\n #Guardamos el nodo inicial\n node = Node(problem.getStartState(), '', 0, None)\n\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\n fn = problem.getCostOfActions(node.path) + nullHeuristic(node.name, problem);\n\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\n openNodes.push(node, fn)\n\n #Iteramos para cada nodo\n while True:\n if openNodes.isEmpty():\n break #ERROR: throw exception\n else :\n #sacamos el nodo de arriba de la cola\n node = openNodes.pop()\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\n break\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\n if nodeIsClosed(node, closedNodes) is False:\n for successor in problem.getSuccessors(node.name):\n n, p, c = successor\n succNode = Node(n, p, c, node)\n if nodeIsClosed(succNode, closedNodes) is False:\n fn = problem.getCostOfActions(findPath(succNode)) + nullHeuristic(succNode.name, problem);\n openNodes.push(succNode, fn)\n #Metemos el nodo en closed\n closedNodes.add(node)\n\n #Devolvemos el camino al Goal\n return findPath(node)","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n path_to_point = {}\n cost_to_point = {}\n\n # Get the start node\n start_node = problem.getStartState()\n fringe_node = [start_node]\n path_to_point[start_node] = []\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\n\n goal_found = False\n\n while(not goal_found):\n #for i in range(100): \n nodes_to_expand = set()\n # get max value node in the fringe node\n min_val = float(\"inf\")\n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] < min_val:\n min_val = cost_to_point[one_node]\n \n for one_node in fringe_node:\n # Compute the cost to reach a node\n if cost_to_point[one_node] == min_val:\n nodes_to_expand.add(one_node)\n fringe_node.remove(one_node)\n\n # Expand the fringe node \n for one_node in nodes_to_expand:\n path_to_parent = path_to_point[one_node]\n for nxt_node in problem.getSuccessors(one_node):\n pos = nxt_node[0]\n mv = nxt_node[1]\n # check if point already present in path to point\n prev_cost = float(\"inf\")\n if pos in cost_to_point:\n prev_cost = cost_to_point[pos]\n new_path = path_to_parent + [mv]\n if prev_cost > problem.getCostOfActions(new_path):\n path_to_point[pos] = new_path\n cost_to_point[pos] = problem.getCostOfActions(new_path)\n fringe_node.append(pos)\n\n # Check if destination is reached in the fringe node\n for one_node in fringe_node:\n if problem.isGoalState(one_node):\n final_node = one_node\n goal_found = True\n break\n \n #print(len(fringe_node))\n print(final_node)\n print(path_to_point[final_node])\n return path_to_point[final_node] \n\n util.raiseNotDefined()","def astar(G,s,g,cost=(lambda v,w:1),heuristic=(lambda v:0),verbose=1):\n if not callable(g):\n gtest = lambda x,goal=g: x==g\n else:\n gtest = g\n d = dict((v,float('inf')) for v in G.nodes())\n p = dict((v,None) for v in G.nodes())\n d[s] = 0\n Q = [(0,0,s)] #each element is a tuple (f,-c,v) with f=c + heuristic(v), c=cost from start, v=vertex\n nnodes = 0\n while len(Q) > 0:\n f,minus_c,v = heapq.heappop(Q) #get the element in the queue with the least value of c\n nnodes += 1\n if gtest(v):\n #found a path\n if verbose: print(\"A* succeeded in\",nnodes,\"iterations\")\n return predecessor_traverse(p,s,v),d,p\n for w in G.neighbors(v):\n dcand = d[v] + cost(v,w) #this is the cost of going through v to w\n if dcand < d[w]:\n #going through v is optimal\n #if the predecessor of w is not None, then we'll have to adjust the heap\n if p[w] is not None:\n Q = [(f,c,x) for (f,c,x) in Q if x is not w]\n heapq.heapify(Q)\n d[w] = dcand\n p[w] = v\n #put w back on the queue, with the heuristic value as its priority\n heapq.heappush(Q,(dcand+heuristic(w),-dcand,w))\n #no path found\n if verbose: print(\"A* failed in\",nnodes,\"iterations\")\n return None,d,p","def heuristic_main(data):\n arcs, nodes, periods = data.arcs.size, data.nodes, data.periods\n commodities = data.commodities\n arc_origins, arc_destinations = get_2d_index(data.arcs, nodes)\n\n model = make_model(data)\n\n open_arcs = np.zeros((periods, arcs), dtype=np.double)\n\n objective = 0.\n\n for t in xrange(periods):\n fixed_cost, variable_cost = data.fixed_cost[t, :], data.variable_cost\n demand = data.demand[t, :]\n flow, arc_open = model._flow, model._arc_open\n\n for arc in xrange(arcs):\n i, j = arc_origins[arc], arc_destinations[arc]\n con_name = 'cap_{}-{}'.format(i, j)\n con = model.getConstrByName(con_name)\n # We pay for arcs that are not already open\n if arc_open[arc].lb == 0:\n arc_open[arc].obj = fixed_cost[arc]\n for c in xrange(commodities):\n model.chgCoeff(con, flow[c, arc], demand[c])\n flow[c, arc].obj = variable_cost[arc] * demand[c]\n model.optimize()\n if model.status == grb.GRB.status.INFEASIBLE:\n model.computeIIS()\n print 'model is infeasible'\n model.write(str(model.ModelName) + '_{}.ilp'.format(t))\n if model.SolCount > 0:\n objective += model.objVal\n # If we use an arc and it has not been opened before, we should\n # mark it as open now, and keep it open all along\n for count, var in enumerate(arc_open):\n if var.X > 0.1:\n var.lb = 1.\n var.obj = 0.\n if np.sum(open_arcs[:t, count]) < 10e-5:\n open_arcs[t, count] = 1.\n print 'Period : {} Objective value: {}'.format(t, objective)\n\n return objective, open_arcs","def solve(self, Dn, Dm, c, b):\n m =self.m\n n =self.n\n kA =self.kA\n iA =self.iA\n A =self.A\n kAt=self.kAt\n iAt=self.iAt\n At =self.At\n kQ =self.kQ\n iQ =self.iQ\n Q =self.Q\n _max =self.max\n\n _pass=0\n consistent = True\n\n m2 = m+n\n\n # Replaced MALLOC & REALLOC with np.empty\n if self.y_k is None:\n self.y_k = np.empty(m)\n else:\n self.y_k.resize(m)\n if self.x_k is None:\n self.x_k = np.empty(n)\n else:\n self.x_k.resize(n)\n if self.r is None:\n self.r = np.empty(m)\n else:\n self.r.resize(m)\n if self.s is None:\n self.s = np.empty(n)\n else:\n self.s.resize(n)\n if self.z is None:\n self.z = np.empty(m2)\n else:\n self.z.resize(m2)\n if self.Qx is None:\n self.Qx = np.empty(n)\n else:\n self.Qx.resize(n)\n\n y_k = self.y_k\n x_k = self.x_k\n r = self.r\n s = self.s\n z = self.z\n Qx = self.Qx\n iperm = self.iperm\n\n maxbc = max(np.abs(b).max(), np.abs(c).max()) + 1\n maxrs = HUGE_VAL\n\n while True:\n\n if _pass == 0:\n for j in range(n):\n z[iperm[j]] = c[j]\n for i in range(m):\n z[iperm[n+i]] = b[i]\n else:\n for j in range(n):\n z[iperm[j]] = s[j]\n for i in range(m):\n z[iperm[n+i]] = r[i]\n\n consistent = self.rawsolve()\n\n if _pass == 0:\n for j in range(n):\n x_k[j] = z[iperm[j]]\n for i in range(m):\n y_k[i] = z[iperm[n+i]]\n else:\n for j in range(n):\n x_k[j] = x_k[j] + z[iperm[j]]\n for i in range(m):\n y_k[i] = y_k[i] + z[iperm[n+i]]\n\n smx(m, n, A, kA, iA, x_k,r)\n smx(n, m, At,kAt,iAt,y_k,s)\n smx(n, n, Q ,kQ ,iQ ,x_k,Qx)\n\n for j in range(n):\n s[j] = c[j] - (s[j] - Dn[j]*x_k[j] - _max*Qx[j])\n for i in range(m):\n r[i] = b[i] - (r[i] + Dm[i]*y_k[i])\n\n oldmaxrs = maxrs\n maxrs = max(np.abs(r).max(), np.abs(s).max())\n\n # --- for tuning purposes ---\n if (self.verbose>2 and _pass>0):\n print(\"refinement({:3d}): {:8.2e} {:8.2e} {:8.2e}\".format(\n _pass, np.abs(s).max(), np.abs(r).max(), maxrs/maxbc ))\n\n _pass += 1\n if maxrs > (1.0e-10*maxbc) and maxrs < (oldmaxrs/2):\n continue\n else:\n break\n\n if maxrs > oldmaxrs and _pass > 1:\n for j in range(n):\n x_k[j] = x_k[j] - z[iperm[j]]\n for i in range(m):\n y_k[i] = y_k[i] - z[iperm[n+i]]\n\n \t#----------------------------------------------------------\n \t#| overwrite input with output\n\n for j in range(n):\n c[j] = x_k[j]\n for i in range(m):\n b[i] = y_k[i]\n\n return consistent","def refugia_adj_4_growth(params, ns):\n #12 parameters \n nu1, nuA0, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nuA_func = lambda t: nuA0 * (nuA/nuA0)**(t/T1a) \n nu_T1_func = lambda t: [nu1, nuA_func(t)]\n fs.integrate(nu_T1_func, T1a)\n ## Population function and migration matrix for T1b\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\n nu_T1 = [nu1, nuA]\n fs.integrate(nu_T1, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1, nu2, nu3]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1, nu2, nu3]\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def precompute_options_values(adj, skills, g):\n rewards = np.zeros((4604, len(skills)))\n dests = np.zeros((4604, len(skills)), dtype='int')\n discounts = np.zeros((4604, len(skills))) #Containing prefactors g **(avg_len)\n skill_vals = []\n skill_Zs = []\n adj = adjusted_adj_list_4\n for skill in skills:\n out = value_iteration(adj, [], skill[1], g=g, goal=skill[0])\n skill_vals.append(out[0])\n skill_Zs.append(out[1])\n print skill_vals, skill_Zs\n for s_index, skill in enumerate(skills):\n for index in adj.keys():\n dests[index, s_index] = skill[0]\n out = option(index, skill[0], skill[1], g,\n vals=skill_vals[s_index], Z=skill_Zs[s_index], n_repeat=30)\n if out[0] == None: #Skill is disconnected from destination\n dests[index, s_index] = index\n rewards[index, s_index] = -1\n discounts[index, s_index] = g\n else:\n rewards[index, s_index] = out[1]\n discounts[index, s_index] = np.power(g, out[2])\n print 'Done skill {}'.format(dests, rewards, discounts)\n skill_vals_2 = discounts * 0\n skill_Zs_2 = discounts * 0\n for index in adj.keys():\n for s_index in range(len(skills)):\n skill_vals_2[index, s_index] = skill_vals[s_index][index]\n skill_Zs_2[index, s_index] = skill_Zs[s_index][index]\n dests = np.array(dests, dtype='int')\n return rewards, dests, discounts, skill_vals_2, skill_Zs_2","def compute_likelihood_given(O_a, skills, beta, g, theta, vals, Zs, povs):\n O_os, P_os = gen_option_trajectories(O_a, skills, beta, g, theta, vals, Zs, povs) #Generate all option-trajectories\n if povs != []:\n rewards, dests, discounts, _, _ = povs\n probs = []\n for index, O_o in enumerate(O_os): #For option-trajectory in option-trajectories\n state = O_a[0] #Initial state\n prob = 0\n for o_index, o in enumerate(O_o): #For option in option-trajectory (either state to go to or [goal, beta_k] pair\n #Now compute the prob of choosing the option o that was actually chosen\n if type(o) != list and o == theta:\n to_add = np.exp(beta*20) / Zs[state]\n state = o\n elif type(o) != list:\n to_add = np.exp(beta*(-1 + g*vals[o])) / Zs[state]\n state = o\n else: #Compound option\n Q = (rewards[tuple([state, o_dict[o[0]]])] +\n vals[dests[tuple([state, o_dict[o[0]]])]]*discounts[tuple([state, o_dict[o[0]]])])\n # out = option(state, o[0], o[1], g, povs[3][:, o_dict[o[0]]], povs[4][:, o_dict[o[0]]], 10) #Gives samples, discounted rewards, lengths\n # to_add = np.exp(beta*(out[1] + (pow(g,out[2]))*vals[o[0]])) / Zs[state]\n to_add = np.exp(beta*Q) / Zs[state]\n state = o[0]\n if prob == 0:\n prob = to_add\n else:\n prob *= to_add\n if prob == 0:\n print O_a\n print '??'\n probs.append(prob)\n return np.sum(probs)","def refugia_adj_4(params, ns):\n #11 parameters \n nu1, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nu_T1 = [nu1, nuA]\n fs.integrate(nu_T1, T1a)\n ## Population function and migration matrix for T1b\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\n fs.integrate(nu_T1, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1, nu2, nu3]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1, nu2, nu3]\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def random_choose_candidate_solve (x_v, C, A, S, budgets, start_time, verbose=True):\n A = A.copy()\n edges_removed = []\n budget = np.max(budgets)\n results_info = []\n for i in range(budget):\n if (len(C) == 0):\n # Maximum balance achieved -> budget high.\n results_info = update_res(results_info, budgets, time.time() - start_time, len(x_v.nonzero()[0]) - len(S))\n break\n while (True):\n try:\n e_chosen = C[np.random.choice(range(len(C)))]\n except:\n results_info = update_res(results_info, budgets, time.time() - start_time, len(x_v.nonzero()[0]) - len(S))\n return results_info, np.nonzero(x_v)[0], A, edges_removed\n if (is_connected_postdel(delete_edge(A.copy(), e_chosen), e_chosen)):\n break\n else:\n C.remove(e_chosen)\n edges_removed.append(e_chosen)\n try:\n ue = node_out (x_v, e_chosen)\n except:\n print(e_chosen, \" is not on the periphery\")\n return\n A = delete_edge (A, e_chosen)\n x_v[ue] = find_label (A, ue, x_v)\n C.remove(e_chosen)\n if (verbose):\n print(e_chosen, \" is chosen\")\n if (x_v[ue] != 0):\n C, C_i = update_chosen(ue, x_v, A, C)\n # if (verbose):\n # print(\"Edges added to C: \", C_i)\n C = C + C_i\n if (len(edges_removed) in budgets):\n select_time = time.time() - start_time\n results_info.append({\"Budget\": len(edges_removed), \"RT\": select_time, \"Delta\": len(np.nonzero(x_v)[0]) - len(S)})\n if (verbose):\n print(\"\\n\")\n return results_info, np.nonzero(x_v)[0], A, edges_removed","def option(start, destination, beta, g, vals=-1*np.ones((4604)), Z=-1*np.ones((4604)),\n n_repeat=10):\n if vals[0] == -1: #Default value\n vals, Z = value_iteration(adj_list, [], beta, g, 0, destination)\n else:\n vals = vals[:]\n Z = Z[:]\n states_chains = []\n for _ in range(n_repeat):\n states = birl_agent(start, destination, [], beta, g, 0, vals=vals, Z=Z)\n states_chains.append(states)\n if states_chains[0] == None: #States are disconnected\n return None, -1, g\n else:\n # print states_chains\n return states_chains, np.mean([expsum(len(state), g) for state in states_chains]), np.mean([len(state) for state in states_chains])","def solve_tsp(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n drop_off_dict = {}\n car_path = []\n home_map = {}\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\n\n start = list_of_locations.index(starting_car_location)\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\n all_paths = dict(nx.all_pairs_dijkstra(graph))\n\n start_in_home = start in home_indexes\n if start in home_indexes:\n home_indexes.remove(start)\n home_indexes.insert(0, start)\n home_count = 0;\n\n for home in home_indexes:\n #print(home, end = \" \")\n home_map[home_count] = home\n home_count += 1\n # Instantiate the data problem.\n #print(len(home_map))\n data = create_data_model(home_indexes, 0)\n\n # Create the routing index manager.\n manager = pywrapcp.RoutingIndexManager(len(data['locations']),\n data['num_vehicles'], data['depot'])\n\n #print(manager.NodeToIndex(15))\n # Create Routing Model.\n routing = pywrapcp.RoutingModel(manager)\n\n def distance_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n #print(home_map[to_index], end = \" \")\n from_index = manager.IndexToNode(from_index)\n to_index = manager.IndexToNode(to_index)\n dist_to = all_paths.get(home_map[from_index])[0][home_map[to_index]]\n #if from_index >= 25 or to_index >= 25:\n # print(\"from\" if from_index >= 25 else \"to\", end = \" \")\n #dist_to = all_paths[from_index][0][to_index]\n return dist_to\n\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n\n # Define cost of each arc.\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\n\n # Setting first solution heuristic.\n \"\"\"\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.first_solution_strategy = (\n routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\n \"\"\"\n\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.local_search_metaheuristic = (\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\n search_parameters.time_limit.seconds = 3\n #search_parameters.log_search = True\n\n # Solve the problem.\n assignment = routing.SolveWithParameters(search_parameters)\n\n # if assignment:\n # print_solution(manager, routing, assignment)\n # Print solution on console.\n\n if start in home_indexes:\n drop_off_dict[start] = [start]\n\n\n index = routing.Start(0)\n car_path.append(start)\n\n while not routing.IsEnd(index):\n previous_index = manager.IndexToNode(index)\n index = assignment.Value(routing.NextVar(index))\n\n car_path.pop();\n to_index = manager.IndexToNode(index)\n path_to = all_paths.get(home_map[previous_index])[1][home_map[to_index]]\n drop_off_dict[home_map[to_index]] = [home_map[to_index]]\n #print(to_index, end = ' ')\n car_path.extend(path_to)\n #route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\n # for i in car_path:\n # print(i)\n if start in drop_off_dict.keys() and not start_in_home:\n drop_off_dict.pop(start, None)\n\n return car_path, drop_off_dict","def cost_state(s,state_considered,L,Q,gamma):\n if s==s.goal:\n return 0\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 theta_Q_theta=np.dot(theta.T,np.dot(Q,theta))\n v=vertices_cube(s.n)\n J={}\n for index in range(v.shape[0]):\n p=v[index,:].reshape(s.n,1)\n J[index]=0\n for row in range(s.n):\n for k in range(s.n):\n J[index]+=np.asscalar(p[row]*p[k]*GLG[row,k]+p[row]*p[k]*theta_Q_theta[row,k])\n return max(J.values())+np.asscalar(np.dot(state_considered.x.T,np.dot(L,state_considered.x))+np.dot(u.T,np.dot(Q,u))+gamma)","def refugia_adj_5_full_2_iter4 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def run_two_opt_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\n # create empty lists for to be stored values\n best_routes, costs, cost_lists = [], [], []\n\n adjacency_matrix = make_matrix(tsp_file)\n\n for _ in range(N_sim):\n # generate random initial route\n x = list(range(len(adjacency_matrix)))\n init_route = random.sample(x,len(x))\n \n # find best route with SA algorithm\n best_route, cost_list, accept_list = two_opt_annealing(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\n\n # append all values from simulation to lists\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\n best_routes.append(best_route)\n cost_lists.append(cost_list)\n\n return best_routes, costs, cost_lists","def Option3_routing(self, S, D, L):\n if self.has_path(S, D): \n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \n Opt_path = Shortest_path\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\n return path_cost_with_concave_function, Opt_path\n while len(Shortest_path) != 0:\n path_cost = self.additive_path_cost(Shortest_path, 'w') \n #self.logger.info('Path cost - %d', path_cost)\n if path_cost <= L:\n \"\"\"go to path cost with weighted sum\"\"\"\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\n self.G = self.rm_edge_constraint(path_cost_with_concave_function) # remove all links where the concave link is greater than PathConcave_cost \n Opt_path = Shortest_path\n if self.has_path(S, D):\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\n else:\n Shortest_path = [] \n else:\n break \n else:\n self.logger.info('No path from %s to %s', S, D)\n Opt_path = []\n path_cost_with_concave_function = 0\n return path_cost_with_concave_function, Opt_path","def consolidation_heuristics(to_print = False):\n # Instantiate the data problem.\n data = create_data_model()\n # Create the routing index manager.\n manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),\n data['num_vehicles'], data['depot'])\n # Create Routing Model.\n routing = pywrapcp.RoutingModel(manager)\n # Create and register a transit callback.\n def distance_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return data['distance_matrix'][from_node][to_node]\n def pending_callback(from_index, to_index):\n \"\"\"Returns the distance between the two nodes.\"\"\"\n # Convert from routing variable Index to distance matrix NodeIndex.\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return data['post'][to_node]\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\n pending_callback_index = routing.RegisterTransitCallback(pending_callback)\n # Define cost of each arc.\n for i in range(data['num_vehicles']-1):\n routing.SetArcCostEvaluatorOfVehicle(transit_callback_index, i) #Transit cost\n routing.SetFixedCostOfVehicle(data['fixed_cost'], i) #Fixed cost\n routing.SetArcCostEvaluatorOfVehicle(pending_callback_index, data['num_vehicles']-1) #Postponement and/or NonService cost\n # Add Capacity constraint.\n def demand_callback(from_index): #\n \"\"\"Returns the demand of the node.\"\"\"\n # Convert from routing variable Index to demands NodeIndex.\n from_node = manager.IndexToNode(from_index) \n return data['demands'][from_node]\n demand_callback_index = routing.RegisterUnaryTransitCallback(\n demand_callback)\n routing.AddDimensionWithVehicleCapacity(\n demand_callback_index,\n 0, # null capacity slack\n data['vehicle_capacities'], # vehicle maximum capacities\n True, # start cumul to zero\n 'Capacity')\n # Add time constraint.\n def time_callback(from_index,to_index): #\n \"\"\"Returns the demand of the node.\"\"\"\n # Convert from routing variable Index to NodeIndex in time\n from_node = manager.IndexToNode(from_index)\n to_node = manager.IndexToNode(to_index)\n return time_matrix[from_node][to_node] \n time_callback_index = routing.RegisterTransitCallback(time_callback) \n routing.AddDimensionWithVehicleCapacity(\n time_callback_index,\n 0, # null capacity slack\n data['time_capacities'], # vehicle maximum capacities\n True, # start cumul to zero\n 'Time')\n # Setting solution heuristic-procedure.\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\n search_parameters.local_search_metaheuristic = (\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\n search_parameters.time_limit.seconds = 5 #10 # 60 #20 #3000\n search_parameters.log_search = True\n # Solve the problem.\n assignment = routing.SolveWithParameters(search_parameters)\n # Print solution on console.\n if assignment:\n sent, sol_results, routes_results = print_solution(data, manager, routing, assignment) \n return sent, sol_results, routes_results","def getAction(self, gameState):\n \"*** YOUR CODE HERE ***\"\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\n # to serve the purpose of finding the expected value\n actionList = gameState.getLegalActions(0)\n pacmanAgentIndex = 0\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\n count = util.Counter()\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\n def maximizer(curState, agentIndex, depth):\n\n ghostActions = curState.getLegalActions(agentIndex)\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\n weight = -99999999 # Worst case starting value to be changed in the code\n if depth == maxDepth: # If we are at a leaf node\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\n # Otherwise, we progress the tree until the above condition is reached\n if len(ghostActions) != 0:\n for x in ghostActions:\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\n weight = weight\n else:\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n def minimizer(curState, agentIndex, depth):\n ghostActions = curState.getLegalActions(agentIndex)\n weight = 0 # Starting value of zero to be incremented below\n if len(ghostActions) != 0:\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\n weight = weight + temp\n else: # Otherwise, we continue to minimize\n for x in ghostActions: # For each legal action in the current position\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\n weight = weight + temp\n return weight\n else:\n # if there are no legal actions left then evaluate at the last known state\n return self.evaluationFunction(curState)\n\n # Executing the minimizer for all possible actions\n for x in actionList:\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\n count[x] = minimizer(tempState,1,0)\n # print('HELLO THERE')\n # print(count)\n return count.argMax()","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n locations = student_utils.convert_locations_to_indices(list_of_locations, list_of_locations)\n homes = student_utils.convert_locations_to_indices(list_of_homes, list_of_locations)\n start = list_of_locations.index(starting_car_location)\n\n start_time = time.time()\n\n if params[0] == 'naive':\n car_path, drop_off = naive_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy':\n car_path, drop_off = greedy_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'three_opt':\n car_path, drop_off = three_opt_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'ant_colony':\n car_path, drop_off = ant_colony(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy_clustering_three_opt':\n car_path, drop_off = greedy_clustering_three_opt(locations, homes, start, adjacency_matrix, int(params[1]))\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'mst':\n car_path, drop_off = mst_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'two_opt':\n car_path, drop_off = two_opt_solver(locations, homes, start, adjacency_matrix)\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n elif params[0] == 'greedy_clustering_two_opt':\n car_path, drop_off = greedy_clustering_two_opt(locations, homes, start, adjacency_matrix, int(params[1]))\n print(\"--- %s seconds ---\" % (time.time() - start_time))\n return car_path, drop_off\n else:\n pass","def incompatibility_solve_cg(self, useAMS=True):\n \n zero = Expression((\"0.0\", \"0.0\", \"0.0\"), degree=1)\n bc = DirichletBC(self.PN, zero, DirichletBoundary())\n \n T1 = Function(self.PN) # Solution for the curl curl problem\n T2 = Function(self.PN) # Solution for the curl curl problem\n T3 = Function(self.PN) # Solution for the curl curl problem\n\n if useAMS:\n \n # Set operator for the linear solver\n L_X = inner(self.strain_diff_1, curl(self.inc_v0))*dx\n A_X, b_X = assemble_system(self.a_X, L_X, bc)\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T1.vector()).vec())\n\n # Show linear solver details\n self.ksp_X.view()\n\n # Solve 2nd system\n L_X = inner(self.strain_diff_2, curl(self.inc_v0))*dx\n A_X, b_X = assemble_system(self.a_X, L_X, bc)\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T2.vector()).vec())\n\n # Solve 3nd system\n L_X = inner(self.strain_diff_3, curl(self.inc_v0))*dx\n A_X, b_X= assemble_system(self.a_X, L_X, bc)\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T3.vector()).vec())\n \n else:\n\n ### vanilla CG works with potential as RHS\n\n L_X = inner(self.strain_diff_1, curl(self.inc_v0))*dx\n solve(self.a_X == L_X, T1, bc, \n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'}) \n\n L_X = inner(self.strain_diff_2, curl(self.inc_v0))*dx\n solve(self.a_X == L_X, T2, bc, \n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'}) \n\n L_X = inner(self.strain_diff_3, curl(self.inc_v0))*dx\n solve(self.a_X == L_X, T3, bc, \n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'})\n\n return project( self.X_0(curl(T1),curl(T2),curl(T3)), \n self.TFS, solver_type=\"cg\", preconditioner_type=\"ilu\")","def solve(self, topology, algorithm=\"SLSQP\", grad=\"AD\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\n if verbose:\n print(\"----------\")\n print(\"Optimization with {} started!\".format(algorithm))\n print(f\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\")\n\n # test for bad stuff before going any further\n self.check_optimization_sanity()\n\n # compose gradient and objective functions\n if grad not in (\"AD\", \"FD\"):\n raise ValueError(f\"Gradient method {grad} is not supported!\")\n if grad == \"AD\":\n if verbose:\n print(\"Computing gradients using automatic differentiation!\")\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\n\n elif grad == \"FD\":\n if verbose:\n print(f\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\")\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\n\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\n\n # generate optimization variables\n x = self.optimization_parameters(topology)\n\n # extract the lower and upper bounds to optimization variables\n bounds_low, bounds_up = self.optimization_bounds(topology)\n\n # stack keyword arguments\n hyper_parameters = {\"f\": obj_func,\n \"algorithm\": algorithm,\n \"dims\": self.number_of_parameters(),\n \"bounds_low\": bounds_low,\n \"bounds_up\": bounds_up,\n \"iters\": iters,\n \"eps\": eps,\n \"ftol\": kappa}\n\n # assemble optimization solver\n solver = nlopt_solver(**hyper_parameters)\n\n # solve optimization problem\n x_opt = None\n start = time()\n try:\n x_opt = solver.optimize(x)\n if verbose:\n print(\"Optimization ended correctly!\")\n except RoundoffLimited:\n print(\"Optimization was halted because roundoff errors limited progress\")\n print(\"Results may still be useful though!\")\n x_opt = self.optimization_parameters(topology)\n except RuntimeError:\n print(\"Optimization failed due to a runtime error!\")\n print(f\"Optimization total runtime: {round(time() - start, 4)} seconds\")\n return static_equilibrium(topology)\n\n # fetch last optimum value of loss function\n time_opt = time() - start\n loss_opt = solver.last_optimum_value()\n evals = solver.get_numevals()\n status = nlopt_status(solver.last_optimize_result())\n\n # set optimizer attributes\n self.time_opt = time_opt\n self.x_opt = x_opt\n self.penalty = loss_opt\n self.evals = evals\n self.status = status\n\n # set norm of the gradient\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\n self.gradient_norm = np.linalg.norm(self.gradient)\n\n if verbose:\n print(f\"Optimization total runtime: {round(time_opt, 6)} seconds\")\n print(\"Number of evaluations incurred: {}\".format(evals))\n print(f\"Final value of the objective function: {round(loss_opt, 6)}\")\n print(f\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\")\n print(f\"Optimization status: {status}\".format(status))\n print(\"----------\")\n\n # exit like a champion\n return static_equilibrium(topology)","def solve_driv(v, ene, s, n, h):\n\n xs = np.array([(k+1)*h for k in range(n)])\n h2 = h*h\n k = np.sqrt(2.0*ene)\n \n vs = [v(x)-ene for x in xs]\n\n mat = laplacian_mat(n) -2.0 * h2 * scipy.sparse.diags(vs, 0) + bc_outgoing_mat(n, h, k)\n vec = np.array([-2.0*h*h*s(x) for x in xs])\n\n ys = scipy.sparse.linalg.spsolve(mat, vec)\n return (xs, ys)","def opt(self, demands: Demand) -> float:\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('multicommodity_flow_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the splitting ratios for each edge\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(self.num_edges):\n flow_variable_edges.append(\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Capacity constraint\n capacity_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint between 0 and edge capacity\n constraint_i = solver.Constraint(\n 0, self.graph.get_edge_data(*edge)['weight'],\n '(1,{},{})'.format(*edge))\n for j, commodity in enumerate(self.commodities):\n # Coefficient for jth flow over ith edge is scaled by flow width\n constraint_i.SetCoefficient(flow_variables[j][i],\n # cast because or-tools :'(\n float(demands[j]))\n capacity_constraints.append(constraint_i)\n\n # Conservation on transit nodes\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.num_nodes):\n if j != commodity[0] and j != commodity[1]:\n # Constraint must sum to zero\n constraint_j = solver.Constraint(0, 0,\n '(2,{},{})'.format(i, j))\n for k in list(sorted(self.graph.adj[j].keys())):\n # Ingress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\n # Egress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Conservation of flow at source node\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[0], edge_dest)]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[0])]],\n -1)\n conservation_source_constraints.append(constraint_i)\n\n # Conservation of flow at destination node\n conservation_dest_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[1])]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[1], edge_dest)]],\n -1)\n conservation_dest_constraints.append(constraint_i)\n\n ## OBJECTIVES\n # Implementation of the load-balancing example from Wikipedia\n # First we add more constraints so that we are minimising the maximum\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\n 'max_link_utilisation')\n min_of_max_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\n # i.e 'f_0 + f_1 + ... < max'\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\n '(5,{})'.format(i))\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\n for j, flow_variable in enumerate(flow_variables):\n constraint_i.SetCoefficient(flow_variable[i],\n demands[j] /\n self.graph.get_edge_data(*edge)[\n 'weight'])\n min_of_max_constraints.append(constraint_i)\n\n # Objective now is to minimise the maximum link utilisation\n objective = solver.Objective()\n objective.SetCoefficient(max_utilisation_variable, 1)\n objective.SetMinimization()\n solver.Solve()\n\n return objective.Value()"],"string":"[\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def solve_csp(nodes, arcs, max_steps):\\n\\n nodes = list(nodes)\\n print 'nodes:', nodes\\n\\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\\n print 'initial random assignment', node_values_dict\\n indexes = np.arange(len(nodes))\\n\\n graph = {}\\n for arc in arcs:\\n if not arc[0] in graph:\\n graph[arc[0]] = []\\n if not arc[1] in graph:\\n graph[arc[1]] = []\\n graph[arc[0]].append(arc[1])\\n graph[arc[1]].append(arc[0])\\n for i in indexes:\\n if i in graph:\\n continue\\n else:\\n graph[i] = []\\n graph = dict(sorted(graph.items()))\\n print 'graph:', graph\\n\\n domain = [i for i in np.arange(1, 10, 1)]\\n print 'initial domain for each node:', domain\\n\\n superAdjacency ={}\\n for i in np.arange(len(nodes)):\\n superAdjacency[i] = []\\n superAdjacency[i].append(nodes[i])\\n superAdjacency[i].append(node_values_dict[nodes[i]])\\n superAdjacency[i].append(graph[i])\\n superAdjacency[i].append(domain)\\n\\n print 'superAdjacency', superAdjacency\\n\\n def getNodeType(superAdjacency, index):\\n return list(superAdjacency[index])[0]\\n\\n def getCurrentAssignment(superAdjacency, index):\\n return list(superAdjacency[index])[1]\\n\\n def getCurrentAssignmentForList(superAdjacency, indexList):\\n return [int(list(superAdjacency[index])[1]) for index in indexList]\\n\\n def getSolution(superAdjacency):\\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\\n\\n def getNeighbours(superAdjacency, index):\\n return list(superAdjacency[index])[2]\\n\\n def getDomain(superAdjacency, index):\\n return list(superAdjacency[index])[3]\\n\\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\\n updateList =[]\\n for i in superAdjacency:\\n if str(getNodeType(superAdjacency, i)) == nodeType:\\n updateList.append(i)\\n for i in updateList:\\n superAdjacency[i][1] = newValue\\n\\n def isSolution():\\n return graphConstraints(superAdjacency)\\n\\n def graphConstraints(superAdjacency):\\n graphEval = []\\n\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n\\n if nodeType == 'T':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\\n elif nodeType == 'C':\\n return 'NA'\\n elif nodeType == 'S':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\\n elif nodeType == 'H':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\\n if nodeType == 'P':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\\n\\n currentAssignment = [item[1] for item in superAdjacency.values()]\\n difference = map(sub, currentAssignment, graphEval)\\n\\n if sum(difference) == 0:\\n return True\\n else:\\n return difference\\n\\n def findConflictVariable(superAdjacency, lastUpdateNode):\\n node_conflict_count = {}\\n for node in node_values_dict:\\n node_conflict_count[node] = 0\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n if nodeType == 'T':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != \\\\\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'S':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'H':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n if nodeType == 'P':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n choices = [k for k, v in node_conflict_count.items() if v > 0]\\n if len(choices) > 0:\\n updateNode = random.choice(choices)\\n\\n if updateNode == lastUpdateNode:\\n choices.pop(choices.index(updateNode))\\n try:\\n lastUpdateNode = random.choice(choices)\\n return lastUpdateNode, lastUpdateNode\\n except:\\n return lastUpdateNode, lastUpdateNode\\n else:\\n lastUpdateNode = updateNode\\n return updateNode, lastUpdateNode\\n else:\\n return 'NA', 'NA'\\n\\n\\n\\n def valueForConflictedVariable(superAdjacency, var):\\n for index in superAdjacency:\\n nodeType = getNodeType(superAdjacency, index)\\n neighbours = getNeighbours(superAdjacency, index)\\n if not neighbours:\\n continue\\n elif str(nodeType) == str(var):\\n domain = getDomain(superAdjacency, index)\\n\\n choice = random.choice(domain)\\n if nodeType == 'T':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\\n elif nodeType == 'S':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\\n elif nodeType == 'H':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\\n if nodeType == 'P':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\\n\\n choice = int(choice)\\n if choice % 2 == 0:\\n return choice\\n else:\\n return choice\\n\\n def min_conflicts(nodes, arcs, max_steps):\\n lastUpdateNode = ''\\n for i in range(max_steps):\\n if isSolution() == True:\\n return\\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\\n if var != 'NA':\\n value = valueForConflictedVariable(superAdjacency, var)\\n updateSuperAdjacency(superAdjacency, var, value)\\n node_values_dict[var] = value\\n else:\\n pass\\n\\n return\\n\\n min_conflicts(nodes, arcs, max_steps)\\n node_values = getSolution(superAdjacency)\\n return node_values\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def solve(self):\\n # Use a trivial tour (1-2-3-...-N-1) to set the global upper bound.\\n tour = list(range(self._N))\\n upper_bound = sum([self._G[i][(i + 1) % self._N] for i in range(self._N)])\\n trace = []\\n\\n # Start from a configuration with a single vertex.\\n frontier = [BranchAndBoundConfiguration(self._G, self._N, [0], LOWER_BOUND_METHOD)]\\n\\n # Set the start time.\\n start_time = time.time()\\n\\n # Branch and bound until the frontier set is empty or the time has expired.\\n while frontier and (time.time() - start_time) < self._cutoff_time:\\n # Fetch the most promising configuration.\\n config = heappop(frontier)\\n\\n # Expand configuration by appending a vertex to the path.\\n for v in range(self._N):\\n try:\\n expanded_config = config.expand(v)\\n except ValueError:\\n # Expanded configuration is not valid.\\n continue\\n if expanded_config.is_solution():\\n # Update the global upper bound, if needed.\\n this_solution = expanded_config.get_cycle_cost()\\n if this_solution < upper_bound:\\n # Log it.\\n trace.append((time.time() - start_time, this_solution))\\n # Update the best solution.\\n upper_bound = this_solution\\n tour = list(expanded_config.get_path())\\n elif expanded_config.get_lower_bound() < upper_bound:\\n # Add to the frontier set.\\n heappush(frontier, expanded_config)\\n return (upper_bound, [self._index_to_id[v] for v in tour], trace)\",\n \"def solve(self):\\n \\n # Check if cost is available for both estimators\\n if not self.est0.cost_avail or not self.est1.cost_avail:\\n self.comp_cost = False\\n \\n # Initial estimate from the input node\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est_init(return_cost=True)\\n else:\\n z0, zvar0 = self.est0.est_init(return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0\\n \\n # Initialize other variables\\n self.var_cost0 = 0\\n self.var_cost1 = 0\\n self.cost = 0\\n self.s = np.zeros(self.shape1)\\n \\n for it in range(self.nit):\\n \\n # Forward transform to est1\\n t0 = time.time()\\n rvar1_new = self.A.var_dot(self.zvar0)\\n rvar1_rep = common.repeat_axes(rvar1_new,self.shape1,\\\\\\n self.var_axes1,rep=False)\\n z1_mult = self.A.dot(self.z0)\\n r1_new = z1_mult - rvar1_rep*self.s\\n \\n # Damping\\n if it > 0: \\n self.r1 = (1-self.step)*self.r1 + self.step*r1_new\\n self.rvar1 = (1-self.step)*self.rvar1 + self.step*rvar1_new\\n else:\\n self.r1 = r1_new\\n self.rvar1 = rvar1_new\\n\\n # Estimator 1 \\n if self.comp_cost: \\n z1, zvar1, cost1 = self.est1.est(self.r1, self.rvar1, return_cost=True) \\n if not self.map_est:\\n cost1 -= self.cost_adjust(self.r1,z1,self.rvar1,zvar1,\\\\\\n self.shape1,self.var_axes1)\\n else:\\n z1, zvar1 = self.est1.est(self.r1, self.rvar1, return_cost=False) \\n cost1 = 0\\n self.z1 = z1\\n self.zvar1 = zvar1\\n self.cost1 = cost1 \\n con_new = np.mean(np.abs(z1-z1_mult)**2) \\n \\n # Reverse nonlinear transform to est 0\\n self.s = (self.z1-self.r1)/rvar1_rep\\n self.sprec = 1/self.rvar1*(1-self.zvar1/self.rvar1)\\n t1 = time.time()\\n self.time_est1 = t1-t0\\n \\n # Reverse linear transform to est 0 \\n rvar0_new = 1/self.A.var_dotH(self.sprec)\\n rvar0_rep = common.repeat_axes(rvar0_new,self.shape0,\\\\\\n self.var_axes0,rep=False)\\n r0_new = self.z0 + rvar0_rep*self.A.dotH(self.s)\\n \\n # Damping\\n if it > 0:\\n self.r0 = (1-self.step)*self.r0 + self.step*r0_new\\n self.rvar0 = (1-self.step)*self.rvar0 + self.step*rvar0_new\\n else:\\n self.r0 = r0_new\\n self.rvar0 = rvar0_new\\n \\n \\n # Estimator 0\\n if self.comp_cost:\\n z0, zvar0, cost0 = self.est0.est(self.r0, self.rvar0, return_cost=True)\\n if not self.map_est:\\n cost0 -= self.cost_adjust(self.r0,z0,self.rvar0,zvar0,\\\\\\n self.shape0,self.var_axes0)\\n \\n else:\\n z0, zvar0 = self.est0.est(self.r0, self.rvar0, return_cost=False)\\n cost0 = 0\\n self.z0 = z0\\n self.zvar0 = zvar0\\n self.cost0 = cost0 \\n\\n \\n # Compute total cost and constraint \\n cost_new = self.cost0 + self.cost1 \\n if not self.map_est:\\n cost_new += self.cost_gauss()\\n \\n # Step size adaptation\\n if (self.step_adapt) and (it > 0):\\n if (con_new < self.con):\\n self.step = np.minimum(1,self.step_inc*self.step)\\n else:\\n self.step = np.maximum(self.step_min, self.step_dec*self.step)\\n self.cost=cost_new\\n self.con=con_new\\n \\n t2 = time.time()\\n self.time_est0 = t2-t1\\n self.time_iter = t2-t0\\n \\n # Print progress\\n if self.prt_period > 0:\\n if (it % self.prt_period == 0):\\n if self.comp_cost:\\n print(\\\"it={0:4d} cost={1:12.4e} con={2:12.4e} step={3:12.4e}\\\".format(\\\\\\n it, self.cost, self.con, self.step))\\n else:\\n print(\\\"it={0:4d} con={1:12.4e}\\\".format(\\\\\\n it, self.con))\\n \\n # Save history\\n self.save_hist()\",\n \"def optimize(self):\\n\\n self.logger.info(\\\"Solving with Dynamic Slope Scaling Procedure in Julia :\\\")\\n optimization_start = time.time()\\n\\n # 1. Preprocess for old network graph\\n if self.old_network_graph is not None:\\n\\n # DSSP on old network\\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\\n try:\\n self.check_infeasibility(self.old_network_graph, old_network_obj)\\n except DHCOptimizerException as e:\\n e.data = \\\"Invalid existing network: \\\" + e.data\\n raise e\\n\\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\\n\\n if self.modify_old_network:\\n\\n # Add max capacity on old edges\\n self.old_capacity = deepcopy(flows)\\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\\n for key in flows:\\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\\n\\n # Add Imaginary edges\\n for edge in self.old_capacity:\\n if self.optimization_graph.has_edge(*edge):\\n\\n # add nodes\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\\n # add edges\\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\\n\\n # put cost\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n\\n else:\\n # if we don't modify the old network, we have to change the capacity of the supplies\\n already_consummed = {}\\n for edge in solution_old_graph.edges():\\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\\\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\\n for source in already_consummed:\\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\\n self.network_objective -= already_consummed[source]\\n else:\\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\\n\\n # Remove edges from old network\\n edges_to_remove = set()\\n for e in self.optimization_graph.edges():\\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\\n edges_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(edges_to_remove)\\n\\n # Remove isolated buildings of optimization graph\\n isolated_to_remove = set()\\n for e in self.old_network_graph.edges():\\n if e[0] in self.old_network_graph.nodes() and \\\\\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n isolated_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(isolated_to_remove)\\n\\n # Remove buildings from old network\\n for n, data in self.old_network_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n self.optimization_graph.remove_node(n)\\n\\n # Re-link sources\\n sources = set()\\n for n, data in self.optimization_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n sources.add(n)\\n source_graph = self.optimization_graph.subgraph(sources).copy()\\n self.optimization_graph.remove_nodes_from(sources)\\n gnx.remove_isolates(self.optimization_graph)\\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\\n\\n # fill missing information\\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\\n for e in self.optimization_graph.edges(keys=True):\\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\\\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\\n\\n\\n\\n # 2. Process the DSSP on optimization graph\\n self.check_is_ready()\\n self.check_infeasibility(self.optimization_graph, self.network_objective)\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\\n else:\\n old_buildings = set()\\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\\n\\n # 3. Postprocess for old network graph\\n if self.old_network_graph is not None:\\n \\n if self.modify_old_network:\\n # Put the right supply capacity and cost\\n for edge in self.old_capacity:\\n if self.solution_graph.has_edge(edge[0],edge[1]):\\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\\n \\n # Remove imaginary edges\\n imaginary_nodes_to_remove = set()\\n nodes_to_relabel = {}\\n for edge in self.solution_graph.edges():\\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\\n if not self.solution_graph.has_edge(*real_edge):\\n for i in range(2):\\n nodes_to_relabel[edge[i]] = real_edge[i]\\n else:\\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\\\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\\n imaginary_nodes_to_remove.add(edge[0])\\n imaginary_nodes_to_remove.add(edge[1])\\n elif str(edge[0]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[0])\\n elif str(edge[1]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[1])\\n\\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\\n for node in nodes_to_relabel.values():\\n if self.solution_graph.has_edge(node, node):\\n self.solution_graph.remove_edge(node, node)\\n\\n else:\\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n\\n return flows, obj_val\",\n \"def solve(num_wizards, num_constraints, wizards, constraints): \\n global wiz_const\\n wiz_const = mapConstraints(wizards, constraints)\\n partial_soltns = []\\n\\n # counter for priority queue since it doesn't allow \\n # identical priorities\\n k = 0\\n\\n # list of wizards sorted by lowest to highest degree\\n sorted_wiz = sortWizByConsts(wiz_const)\\n wiz_rankings = {wiz: i for i, wiz in enumerate(sorted_wiz)}\\n\\n const_set = set(map(tuple, constraints))\\n for i in range(4) : \\n heapq.heappush(partial_soltns, (0, k, nx.DiGraph(), const_set.copy()))\\n k += 1\\n\\n print(\\\"setup done, commencing solving\\\")\\n\\n while len(partial_soltns) : \\n\\n # for partial_soltn, const_set in partial_soltns : \\n# partial_soltns.remove(partial_soltn)\\n num_seen, _, partial_soltn, const_set = heapq.heappop(partial_soltns)\\n const = findNextConst(partial_soltn, const_set, wiz_rankings)\\n print(\\\"seen \\\" + str(len(partial_soltn)) + \\\"\\\\t num partial_solutions\\\\t\\\" + str(len(partial_soltns)))\\n try : \\n const_set.remove(const)\\n except KeyError : \\n print(\\\"BAD SHIT\\\")\\n pass\\n possible_arrangements = [(const[0], const[1], const[2]),\\n (const[2], const[0], const[1]), \\n (const[2], const[1], const[0]),\\n (const[1], const[0], const[2])]\\n for arr in possible_arrangements:\\n soltn = partial_soltn.copy()\\n a, b, c = arr\\n if not (soltn.has_node(a) and soltn.has_node(b) and nx.has_path(soltn, a, b)) : \\n soltn.add_edge(a, b)\\n if not (soltn.has_node(b) and soltn.has_node(c) and nx.has_path(soltn, b, c)) : \\n soltn.add_edge(b, c)\\n # see if we violated any other constraints (seen or not seen)\\n is_valid, num_wiz = validNumWiz(soltn, const_set)\\n\\n if is_valid and len(list(nx.simple_cycles(soltn))) == 0 :\\n heapq.heappush(partial_soltns, (-len(soltn), k, soltn, const_set.copy()))\\n k += 1\\n # are we done?\\n if num_wiz == num_wizards :\\n print(\\\"FINAL SOLUTION (found without processing all constraints but validating against them)\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n if foundCompleteOrdering(heapq.heappop(partial_soltns)) : \\n print(\\\"FINAL SOLUTION\\\")\\n ordering = list(nx.topological_sort(soltn))\\n finishEverything(ordering, constraints)\\n return ordering\\n print(\\\"NO SOLUTION FOUND\\\")\\n return \\\"\\\"\",\n \"def CalculatePaths(self):\\n agrid = self.agrid \\n self.apath = array([0 for y in range(self.T)], dtype=float)\\n self.cpath = array([0 for y in range(self.T)], dtype=float)\\n self.npath = array([0 for y in range(self.T)], dtype=float)\\n # generate each generation's asset, consumption and labor supply forward\\n for y in range(self.T-1): # y = 0, 1,..., 58\\n self.apath[y+1] = max(0,interp1d(agrid, self.a[y], kind='cubic')(self.apath[y]))\\n if y >= self.W:\\n self.cpath[y], self.npath[y] = (1+self.r)*self.apath[y] + self.b - self.apath[y+1], 0\\n else:\\n self.cpath[y], self.npath[y] = self.solve(self.apath[y], self.apath[y+1])\\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\\n # the oldest generation's consumption and labor supply\\n self.cpath[self.T-1], self.npath[self.T-1] = (1+self.r)*self.apath[self.T-1]+self.b, 0\\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])\",\n \"def solve():\\n\\n s, g, e = make_lattice(21)\\n stack = deque([[e]])\\n vals = {s: 1}\\n max_n = 0\\n\\n while stack:\\n max_n = max(max_n, len(stack))\\n n, *p = stack.pop()\\n for c in g.get_connected(n):\\n if c > n:\\n continue\\n if c in vals:\\n propagate(c, [n] + p, vals)\\n else:\\n stack.append([c, n] + p)\\n return vals[e]\",\n \"def solver_auto_param(u_init, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, eta_step = 0.5, eta_step_tumor = 0.99, ftol = 1e-3, max_iter = 300, verbose = 0, nnls_max_iter=30):\\n auto_param_obj_history = []\\n auto_param_relaxed_obj_history = []\\n \\n eta_0 = (1/(2*np.max(B)))*0.5 #Initialize eta_0\\n eta = np.array([eta_0/len(H)]*len(H))*0.9\\n eta_lin = np.ones(L_lhs.shape[0])*0.01\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u_init, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 300, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Feasibility')\\n count = 0\\n num_violated = -1\\n while (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n count += 1\\n num_violated_prev = np.copy(num_violated)\\n num_violated_oar = len(H) - cnstr['Relaxed'].sum()\\n num_violated_lin = L_lhs.shape[0] - np.sum(cnstr_linear)#(1 - int(cnstr_linear))\\n num_violated = len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))#(1 - int(cnstr_linear))\\n \\n print('Iter ', count, '# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n print(' Linear constraints on u violation:', L_lhs.shape[0] - np.sum(cnstr_linear))\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n # eta_lin *= eta_step\\n \\n if num_violated == num_violated_prev:\\n print('Increase enforcement')\\n if num_violated_lin > 0:\\n eta_lin[cnstr_linear == False] *= eta_step\\n # eta_0 *= eta_step*2\\n #eta_lin *= eta_step\\n if num_violated_oar > 0:\\n eta[cnstr['Relaxed'] == False] *= eta_step\\n # eta_0 *= eta_step*2\\n \\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n # solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n \\n print('Enforcing Optimality')\\n count = 0\\n while not (len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear))):\\n # (cnstr['Relaxed'].sum()-len(H)): #If nothing is violated -- enforce optimality!\\n count += 1\\n print('Opt Iter', count)\\n obj_prev = obj_u_opt_N_fixed(u, T, alpha, B)\\n u_prev = np.copy(u)\\n eta_0 *= eta_step_tumor\\n print('Current eta_0:', eta_0)\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, T, H, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter, verbose = verbose)\\n u, w_0, w, w_lin, obj_history, relaxed_obj_history = solver(u, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = ftol, max_iter = max_iter//2, verbose = verbose, nnls_max_iter=nnls_max_iter)\\n auto_param_obj_history.append(obj_history)\\n auto_param_relaxed_obj_history.append(relaxed_obj_history)\\n \\n obj_new = obj_u_opt_N_fixed(u, T, alpha, B)\\n if (abs(obj_new - obj_prev)/abs(obj_prev) <= 1e-4) or (obj_new > obj_prev): #two consequent iters, two times bc on iter 2 it stops anyway\\n print('No improvement, increase enforcement')\\n eta_step_tumor *= 0.1\\n eta_0 *= eta_step_tumor\\n if (2*eta_0)**2 <= 1e-80:\\n print('zero reached')\\n break\\n # break\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))#(1 - int(cnstr_linear)))\\n \\n print('Finding the correct solution:')\\n u = u_prev\\n eta_0 = eta_0/eta_step_tumor\\n \\n cnstr = constraints_all(u, H, gamma, D, C, tol = 0.05, verbose = 0)\\n cnstr_linear = linear_constraint(u, L_lhs, L_rhs, tol = 0.05)\\n print('# of violated constr:', len(H) - cnstr['Relaxed'].sum() + (L_lhs.shape[0] - np.sum(cnstr_linear)))\\n # print('# of violated constr:', cnstr['Relaxed'].sum()-len(H))\\n print(\\\"OBJJJJJ:\\\", obj_u_opt_N_fixed(u, T, alpha, B))\\n return u, w_0, w, w_lin, eta_0, eta, eta_lin, auto_param_obj_history, auto_param_relaxed_obj_history\",\n \"def solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths):\\n\\n car_path = [get_car_path(graph,home_clusters,source,all_pairs_distances,all_pairs_shortest_paths, \\n source_in_clusters = B1, christofides = B2) for B1 in [False,True] for B2 in [False,True]]\\n\\n dropoffs = [cluster_solver_utils.nearest_dropoff_efficient(graph,path,homes,all_pairs_distances) for path in car_path]\\n cost = [cluster_solver_utils.eval_cost_efficient(graph,car_path[i],dropoffs[i],all_pairs_distances) for i in range(len(car_path))]\\n\\n minimum_cost = min(cost)\\n idx = cost.index(minimum_cost)\\n\\n return minimum_cost, dropoffs[idx], car_path[idx]\",\n \"def objective(trial):\\n # The parameters that we will calibrate the model for are shown here.\\n # Optuna trial i\\n BOD = trial.suggest_uniform(\\\"BOD\\\", 0, 1) #Review ranges here\\n k_r = trial.suggest_uniform(\\\"k_r\\\", 0, 1) #Review Ranges here \\n \\n def ChLa(t):\\n return 1 # Need to link to data\\n\\n def I(x):\\n return 1 # Need to link to data\\n\\n K_z = 2 * 10**(-5) # p.51\\n a = K_z\\n k_b = 0.1 # Table 5\\n th_b = 1.047 # Table 5\\n k_r = 0.1 # Table 5\\n YCHO2 = 0.0083 # Table 5\\n th_p = 1.036 # Table 5\\n th_s = 1.065 # Table 5\\n th_r = 1.047 # Table 5\\n\\n def Temp(t):\\n \\\"\\\"\\\"\\n Function that maps time to temperature\\n \\\"\\\"\\\"\\n return 20 # Need to link to data\\n\\n def P_max(t):\\n return 9.6 * 1.036 **(Temp(t) - 20) # Eq. 4\\n\\n def L_min(t):\\n I = 1 # Need to link to PAR data\\n K_1 = 0.687 * 1.086**(Temp(t) - 20)\\n K_2 = 15\\n return I * (1 + 2 * np.sqrt(K_1 / K_2)) / (I + K_1 + I**2 / K_2) # Eq. 5\\n \\n # f deals with sink and source terms \\n def f(x, t):\\n return -1 / YCHO2 * k_r * th_r**(Temp(t) - 20) * ChLa(t) + P_max(t) * L_min(t) * ChLa(t) - k_b * th_b**(Temp(t)-20) * BOD \\n\\n L = 200 # Length of domain\\n dt = 1 / 48 # Mesh spacing in t\\n F = a * dt # a * dt / dx**2\\n T = 100 # Simulation time stop\\n\\n # Solving the PDE\\n DO, x, t, _ = solver_FE_simple(I, a, f, L, dt, F, T)\\n \\n # Creating some bogus targets while database errors are happening\\n DO_data = DO + np.random.random(len(DO))\\n\\n # Using mean squared error as the measure of fit, where we want\\n # to minimize this number\\n return ((DO - DO_data)**2).mean()\",\n \"def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\\n # process and activate input settings\\n sigint_callback = kwds.pop('sigint_callback', None)\\n settings = self._process_inputs(kwds)\\n disp = settings['disp'] if 'disp' in settings else False\\n echo = settings['callback'] if 'callback' in settings else None\\n# for key in settings:\\n# exec \\\"%s = settings['%s']\\\" % (key,key)\\n if disp in ['verbose', 'all']: verbose = True\\n else: verbose = False\\n #-------------------------------------------------------------\\n\\n from python_map import python_map\\n if self._map != python_map:\\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\\n from mystic.monitors import Null\\n evalmon = Null()\\n else: evalmon = self._evalmon\\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\\n\\n # set up signal handler\\n #self._EARLYEXIT = False\\n self._generateHandler(sigint_callback) \\n\\n # activate signal_handler\\n #import threading as thread\\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\\n import signal\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,self.signal_handler)\\n\\n # register termination function\\n if termination is not None: self.SetTermination(termination)\\n\\n # get the nested solver instance\\n solver = self._AbstractEnsembleSolver__get_solver_instance()\\n #-------------------------------------------------------------\\n\\n # generate starting points\\n initial_values = self._InitialPoints()\\n\\n # run optimizer for each grid point\\n from copy import deepcopy as _copy\\n op = [_copy(solver) for i in range(len(initial_values))]\\n #cf = [cost for i in range(len(initial_values))]\\n vb = [verbose for i in range(len(initial_values))]\\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\\n at = self.id if self.id else 0 # start at self.id\\n id = range(at,at+len(initial_values))\\n\\n # generate the local_optimize function\\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\\n from copy import deepcopy as _copy\\n from mystic.tools import isNull\\n solver.id = rank\\n solver.SetInitialPoints(x0)\\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\\n solver.SetStrictRanges(min=solver._strictMin, \\\\\\n max=solver._strictMax) # or lower,upper ?\\n solver.Solve(cost, disp=disp, callback=callback)\\n sm = solver._stepmon\\n em = solver._evalmon\\n if isNull(sm): sm = ([],[],[],[])\\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\\n if isNull(em): em = ([],[],[],[])\\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\\n return solver, sm, em\\n\\n # map:: solver = local_optimize(solver, x0, id, verbose)\\n results = self._map(local_optimize, op, initial_values, id, \\\\\\n vb, cb, **self._mapconfig)\\n\\n # save initial state\\n self._AbstractSolver__save_state()\\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\\n # reconnect monitors; save all solvers\\n from mystic.monitors import Monitor\\n while results: #XXX: option to not save allSolvers? skip this and _copy\\n _solver, _stepmon, _evalmon = results.pop()\\n sm = Monitor()\\n sm._x,sm._y,sm._id,sm._info = _stepmon\\n _solver._stepmon.extend(sm)\\n del sm\\n em = Monitor()\\n em._x,em._y,em._id,em._info = _evalmon\\n _solver._evalmon.extend(em)\\n del em\\n self._allSolvers[len(results)] = _solver\\n del results, _solver, _stepmon, _evalmon\\n #XXX: END HACK\\n\\n # get the results with the lowest energy\\n self._bestSolver = self._allSolvers[0]\\n bestpath = self._bestSolver._stepmon\\n besteval = self._bestSolver._evalmon\\n self._total_evals = self._bestSolver.evaluations\\n for solver in self._allSolvers[1:]:\\n self._total_evals += solver.evaluations # add func evals\\n if solver.bestEnergy < self._bestSolver.bestEnergy:\\n self._bestSolver = solver\\n bestpath = solver._stepmon\\n besteval = solver._evalmon\\n\\n # return results to internals\\n self.population = self._bestSolver.population #XXX: pointer? copy?\\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\\n self.bestEnergy = self._bestSolver.bestEnergy\\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\\n self._maxiter = self._bestSolver._maxiter\\n self._maxfun = self._bestSolver._maxfun\\n\\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\\n self._stepmon = bestpath #XXX: pointer? copy?\\n self._evalmon = besteval #XXX: pointer? copy?\\n self.energy_history = None\\n self.solution_history = None\\n #from mystic.tools import isNull\\n #if isNull(bestpath):\\n # self._stepmon = bestpath\\n #else:\\n # for i in range(len(bestpath.y)):\\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\\n # #XXX: could apply callback here, or in exec'd code\\n #if isNull(besteval):\\n # self._evalmon = besteval\\n #else:\\n # for i in range(len(besteval.y)):\\n # self._evalmon(besteval.x[i], besteval.y[i])\\n #-------------------------------------------------------------\\n\\n # restore default handler for signal interrupts\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,signal.default_int_handler)\\n\\n # log any termination messages\\n msg = self.Terminated(disp=disp, info=True)\\n if msg: self._stepmon.info('STOP(\\\"%s\\\")' % msg)\\n # save final state\\n self._AbstractSolver__save_state(force=True)\\n return\",\n \"def solve_environment(self):\\n \\n #The first problem formulation\\n #K kinds of towers\\n #See more details about problem formulation in the writeup \\n \\n #Get a full matrix of the concatenated coverage matrices for \\n #each tower type. THis new matrix has dimensions:\\n #(Ntowers) x (sum(potential sites)), where the sum o=is over all tower types\\n coverage = np.hstack(i for i in self.coverage_matrices)\\n print coverage\\n print coverage.shape \\n \\n #Diagonal matrix of the values of each target\\n #(for the scenarios where we don't care about maximizing covered value,\\n #target_values is just all ones, so this is just the identity matrix)\\n V = np.diag(self.target_values)\\n \\n #If doing scenario where we want to fortify weakest link, only makes\\n #sense if all targets are equal value:\\n if self.objective_type == 'min_entries':\\n V = np.eye(len(self.target_values))\\n\\n #Get the matrix of coverage values / expected value saved:\\n C = np.dot(V,coverage)\\n print 'V', V\\n print 'coverage', coverage\\n print 'C', C\\n \\n \\n #Since not gauranteed to reach global optimum on any particular initialization,\\n #run a few times and take the best result.\\n #Just define \\\"best result\\\" as the result which had the most overall \\n #\\\"converged\\\" x, combined over all tower kinds. \\n# for j in xrange(self.N_random_starts_max):\\n \\n \\n a = 2. #1.\\n tau = 1e-4\\n N = sum(i for i in self.N_tower_sites)\\n w = np.zeros(N)\\n ones = np.ones(N)\\n p = 1. #the exponents power when doing he exponent method:\\n \\n for i in xrange(self.N_reweighting_iterations_max):\\n #The concatenated vector of occupancies: Concatenated over all\\n #of the kinds of towers.\\n x = cvx.Variable(N)\\n \\n #Different objective functions depending on which optimization problem.\\n #These are defined in the scenarios in the main function.\\n if self.objective_type == 'min_entries':\\n operation = cvx.min_entries\\n elif self.objective_type == 'sum_entries':\\n operation = cvx.sum_entries\\n else:\\n raise Exception('must specify valid objective_type')\\n \\n #Objective function includes penalty term for non-binary x values\\n if self.penalty_type == 'reweighted_L1':\\n #objective = cvx.Maximize(t - x.T*w)\\n objective = cvx.Maximize(operation(C*x - x.T*w))\\n\\n\\n #Main constraints on 0<=x<=1\\n constraints = [0<=x, x<=1]\\n \\n \\n #And then for each kind of tower, append the constraint that there\\n #be exactly N_i towers, or <= quota (depending on constraint type)\\n if self.constraints__type == 'fixed_N_towers' or self.constraints__type == 'tower_quotas':\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n print before_sum\\n print before_sum + self.N_tower_sites[tk]\\n if self.constraints__type == 'fixed_N_towers':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )==self.N_towers[tk])\\n elif self.constraints__type == 'tower_quotas':\\n constraints.append(cvx.sum_entries(\\n x[before_sum : before_sum + self.N_tower_sites[tk]]\\n )<=self.budget__tower_quotas[tk])\\n print x[before_sum : before_sum + self.N_tower_sites[tk]]\\n \\n elif self.constraints__type == 'total_cost':\\n costs = np.hstack([np.repeat(self.budget__tower_unit_costs[tk],self.N_tower_sites[tk]) for tk in xrange(self.N_tower_kinds)])\\n constraints.append(cvx.sum_entries(costs * x) <= self.budget__total_cost) \\n \\n \\n \\n\\n\\n \\n \\n print 'penalty_type', self.penalty_type\\n print 'objective_type', self.objective_type\\n print 'constraints__type', self.constraints__type\\n print 'budget__tower_quotas', self.budget__tower_quotas\\n print 'operation', operation\\n print 'objective', objective\\n print 'constraints', constraints\\n cvx.Problem(objective, constraints).solve(verbose=self.VERBOSE)\\n x = np.array(x.value).flatten()\\n print 'x', x\\n w = a/(tau+np.abs(x))\\n p += 1.\\n plt.figure(figsize=(5,5))\\n plt.plot(x,marker='o')\\n plt.savefig('histrograms_{}.png'.format(i))\\n print \\n \\n \\n \\n \\n #From the solution x, get the coordinates of those tower sites where we\\n #really do want to place a tower\\n #use = np.isclose(x,1.)\\n for tk in xrange(self.N_tower_kinds):\\n before_sum = np.concatenate(([0],np.cumsum(self.N_tower_sites)))[tk]\\n y = x[before_sum : before_sum + self.N_tower_sites[tk]]\\n inds = np.argsort(y)\\n s = y[inds]\\n use = np.where(s>.5)[0]\\n print inds\\n print s\\n print use \\n if self.constraints__type == 'fixed_N_towers':\\n if len(use) != self.N_towers[tk]:\\n print 'Solution did not converge properly. Choosing the K best towers.'\\n print self.N_towers[tk], len(use)\\n # use = use[-self.N_towers[tk]:]\\n use = inds[-self.N_towers[tk]:]\\n elif self.constraints__type == 'tower_quotas':\\n pass #Just use the towers thresholded at > .5\\n print use\\n \\n \\n self.coordinates__solved_towers.append([self.coordinates__tower_sites[tk][mm] for mm in inds[use]])\",\n \"def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\\n\\n # Raise('NotImplementedError: only adjusted the arguments.')\\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\\n #precompute the expensive operation:\\n lin_penalties = 1/np.sqrt(2*eta_lin)\\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\\n #!!!!\\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\\n #!!!!\\n u_prev = u_init + 1\\n u = u_init\\n count = 0\\n obj_history = []\\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\\n start = time.time()\\n \\n u_prev = np.copy(u)\\n w_0 = w_0_update(eta_0, u, T, alpha, B) \\n w = w_update(u, H, gamma, D, C) \\n w_lin = w_lin_update(u, L_lhs, L_rhs)\\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\\n #!!!!\\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\\n #!!!!\\n count += 1 \\n if count == 10:\\n u_inf = np.copy(u)\\n w_0_inf = w_0[:]\\n w_inf = w[:]\\n w_lin_inf = w_lin[:]\\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\\n \\n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\\n obj_history.append(cur_obj)\\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\\n relaxed_obj_history.append(cur_relaxed_obj) \\n \\n stop = time.time()\\n duration = stop-start\\n \\n if count%1 == 0 and verbose: \\n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\\n print(' This iteration took: {}'.format(duration))\\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history\",\n \"def solve(self):\\n initial_fes = eades(self.graph, self.force_forward_edges)\\n initial_fes_vec = self.edge_vector(initial_fes)\\n\\n # bounds for the objective\\n lower_bound = 0\\n upper_bound = np.sum(initial_fes_vec @ self.weights)\\n\\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\\n\\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\\n\\n for iteration in itertools.count(1):\\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\\n upper_bound, len(simple_cycles))\\n\\n # Formulate and solve the problem for this iteration:\\n y = cp.Variable(self.m, boolean=True, name=\\\"y\\\")\\n objective = cp.Minimize(cp.sum(y @ self.weights))\\n\\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\\n problem = cp.Problem(objective, constraints)\\n resolution = problem.solve(**self.solver_args)\\n if problem.status != 'optimal':\\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\\n problem.solver_stats.solver_name)\\n self.logger.debug(\\n \\\"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\\\",\\n len(constraints), resolution, problem.solution.status,\\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\\n current_fes = self.edges_for_vector(current_solution)\\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\\n len(current_fes))\\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\\n # from the heuristic\\n lower_bound = max(lower_bound, objective.value)\\n if lower_bound == upper_bound:\\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\\n break # y.value is the optimal solution\\n\\n if resolution > upper_bound:\\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\\n break\\n\\n Gi = self.graph.copy()\\n Gi.remove_edges_from(current_fes)\\n if nx.is_directed_acyclic_graph(Gi):\\n self.logger.info('Graph is acyclic, optimal solution found')\\n break # y.value is the optimal solution\\n\\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\\n # determine additional simple cycles (= constraints)\\n Fi = eades(Gi, self.force_forward_edges)\\n yi = self.edge_vector(Fi) | current_solution\\n zi = np.sum(yi @ self.weights)\\n if zi < upper_bound:\\n upper_bound = zi\\n current_solution = yi\\n simple_cycles |= set(induced_cycles(Gi, Fi))\\n\\n self.solution_vector = current_solution\\n self.solution = self.edges_for_vector(current_solution)\\n self.objective = objective.value\\n self.iterations = iteration\\n self.simple_cycles = simple_cycles\\n return self.solution\",\n \"def solver(feats,\\n asgn,\\n cstrs,\\n cstrs_solver,\\n gts=None,\\n eval_function=None,\\n rounding_function=None,\\n alpha=1e-4,\\n memory_mode='RAM',\\n bias_value=-1.0,\\n n_iterations=10000,\\n block_sampling='uniform',\\n verbose='silent',\\n gap_frequency=2000,\\n eval_frequency=500,\\n verbose_frequency=250,\\n objective_frequency=250,\\n path_save_asgn=None,\\n validation_info=None):\\n\\n compute_objective = False\\n objective_value = None\\n if objective_frequency > 0:\\n compute_objective = True\\n\\n save_asgn = False\\n save_ids = []\\n if path_save_asgn is not None:\\n if not os.path.exists(path_save_asgn):\\n os.makedirs(path_save_asgn)\\n # Monitor evolution of asgn during optim on a subset of samples.\\n save_asgn = True\\n n_save_asgn = min(20, len(asgn))\\n save_ids = np.random.choice(len(asgn), n_save_asgn, replace=False)\\n\\n # Pre-compute the P matrix.\\n p_matrix, n_feats = compute_p_matrix(\\n feats, alpha, memory_mode, bias_value=bias_value)\\n\\n # Compute W.\\n weights = compute_weights(p_matrix, asgn, memory_mode=memory_mode)\\n\\n # Init the gaps.\\n gaps = np.zeros(len(feats))\\n print('Computing init gaps...')\\n for block_idx in tqdm(range(len(feats))):\\n x = get_feat_block(\\n feats, block_idx, memory_mode, bias_value=bias_value)\\n gaps[block_idx] = compute_gap(x, asgn[block_idx], weights, n_feats,\\n cstrs[block_idx], cstrs_solver)\\n\\n if save_asgn and block_idx in save_ids:\\n save_asgn_block(path_save_asgn, block_idx, asgn, 0)\\n save_xw_block(path_save_asgn, block_idx, x, weights, 0)\\n save_gt_block(path_save_asgn, block_idx, gts)\\n\\n print('Init gap: {0:4E}, starting the optimization...'.format(gaps.sum()))\\n\\n eval_metric = -1.0\\n prev_time = time.time() # init time of iterations\\n prev_global_time = prev_time\\n for t in range(n_iterations):\\n if eval_frequency > 0 and t % eval_frequency == 0:\\n # Evaluation.\\n if eval_function is not None and gts is not None:\\n print('Performing evaluation...')\\n eval_metric = eval_function.evaluate(asgn, gts, weights, feats,\\n rounding_function, cstrs)\\n if validation_info is not None:\\n gts_val = validation_info['gts']\\n feats_val = validation_info['feats']\\n eval_function.evaluate(None, gts_val, weights, feats_val,\\n rounding_function, None)\\n else:\\n eval_metric = -1.0\\n\\n if compute_objective and t % objective_frequency == 0:\\n print('Computing objective...')\\n objective_value = {}\\n # Compute the diffrac objective.\\n dfrac_obj = 0.0\\n # Data dependent term: 1.0 / N * ||X * W - Y||_2^2\\n for block_idx in range(len(feats)):\\n x = get_feat_block(\\n feats, block_idx, memory_mode, bias_value=bias_value)\\n dfrac_obj += compute_obj(x, asgn[block_idx], weights, n_feats)\\n\\n # Regularization term: \\\\alpha * || W ||_2^2\\n dfrac_obj += alpha * matrix_norm(weights, ord='fro')**2\\n objective_value['dfrac'] = dfrac_obj\\n\\n # Print information.\\n if t % verbose_frequency == 0:\\n display_information(t, n_iterations, gaps, eval_metric,\\n objective_value, verbose, prev_time, prev_global_time)\\n prev_time = time.time()\\n\\n # Sample a block.\\n block_idx = sample_block(gaps, block_sampling)\\n # Compute gradient.\\n x = get_feat_block(\\n feats, block_idx, memory_mode, bias_value=bias_value)\\n y = asgn[block_idx]\\n\\n grad_y = compute_grad(x, y, weights, n_feats)\\n\\n opt_y = cstrs_solver.solve(cstrs[block_idx], grad_y)\\n gaps[block_idx] = compute_gap(x, y, weights, n_feats,\\n cstrs[block_idx], cstrs_solver,\\n opt_y, grad_y)\\n\\n # Step size computation.\\n p = get_p_block(p_matrix, block_idx, memory_mode)\\n dir_y = opt_y - y\\n gamma_n = gaps[block_idx]\\n\\n gamma_d = 1.0 / n_feats * np.multiply(\\n dir_y, dir_y - np.linalg.multi_dot([x, p, dir_y])).sum()\\n\\n gamma = min(1.0, gamma_n / gamma_d)\\n # gamma should always be positive.\\n if gamma < 0:\\n print 'Warning: gamma = {}, gap_i = {}'.format(\\n gamma, gaps[block_idx])\\n gamma = 0.0\\n\\n # Update variables.\\n asgn[block_idx] += gamma * dir_y\\n weights += gamma * np.dot(p, dir_y)\\n\\n if save_asgn and block_idx in save_ids:\\n save_asgn_block(path_save_asgn, block_idx, asgn, t)\\n save_xw_block(path_save_asgn, block_idx, x, weights, t)\\n\\n # Update gaps if needed.\\n if (t + 1) % gap_frequency == 0:\\n print('Recomputing gaps...')\\n for block_idx in tqdm(range(len(feats))):\\n x = get_feat_block(\\n feats, block_idx, memory_mode, bias_value=bias_value)\\n gaps[block_idx] = compute_gap(x, asgn[block_idx], weights,\\n n_feats, cstrs[block_idx],\\n cstrs_solver)\\n display_information(t, n_iterations, gaps, eval_metric,\\n objective_value, verbose)\\n\\n return asgn, weights\",\n \"def g_solving_subproblem_of_ALR(self,vehicle_id):\\r\\n global_LB = -10000\\r\\n global_UB = 10000\\r\\n iteration_for_RSP = 20\\r\\n optimal_solution_for_RSP = None\\r\\n self.multiplier_v = 0.5\\r\\n\\r\\n # solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 3)\\r\\n\\r\\n # obtain the variance\\r\\n y_ =self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB = 0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 1)\\r\\n LB += self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_searching_mean\\r\\n UB = Label_cost_for_lagrangian_mean + self.reliability * (variance) ** 0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector[0]\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance- y != 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB - global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, global_LB\",\n \"def prob1():\\n # Set up the initial guess, jacobian, and hessian.\\n x0 = np.array([4.0,-2.5])\\n jacobian = opt.rosen_der\\n hessian = opt.rosen_hess\\n\\n # Test each method.\\n info = {}\\n info[\\\"Nelder-Mead\\\"] = opt.minimize(opt.rosen, x0, method='Nelder-Mead',\\n options={'xtol':1e-8})\\n info[\\\"Powell\\\"] = opt.minimize(opt.rosen, x0, method='Powell',\\n options={'xtol':1e-8})\\n info[\\\"CG\\\"] = opt.minimize(opt.rosen, x0, method='CG')\\n info[\\\"BFGS\\\"] = opt.minimize(opt.rosen, x0, method='BFGS')\\n info[\\\"Newton-CG w/out Hessian\\\"] = opt.minimize(opt.rosen, x0, jac=jacobian,\\n method='Newton-CG', options={'xtol':1e-8})\\n info[\\\"Newton-CG, w/ Hessian\\\"] = opt.minimize(opt.rosen, x0, jac=jacobian,\\n hess=hessian, method='Newton-CG',options={'xtol':1e-8})\\n info[\\\"L-BFGS-B\\\"] = opt.minimize(opt.rosen, x0, method='L-BFGS-B',\\n options={'xtol':1e-8})\\n info[\\\"TNC\\\"] = opt.minimize(opt.rosen, x0, method='TNC', \\n options={'xtol':1e-8})\\n info[\\\"COBYLA\\\"] = opt.minimize(opt.rosen, x0, method='COBYLA')\\n info[\\\"SLSQP\\\"] = opt.minimize(opt.rosen, x0, method='SLSQP')\\n\\n # Report the info.\\n print(\\\"\\\\n\\\\t\\\\tOptimization Tests\\\")\\n for method in info:\\n print(\\\"Method: {}\\\\n{}\\\\n\\\\n\\\".format(method, info[method]))\\n \\n # Answer the problem questions.\\n print(\\\"The Powell algorithm takes the least number of iterations (19).\\\")\\n print(\\\"COBYLA fails to find the correct minimum.\\\")\",\n \"def CalculateChebyPaths(self):\\n Kmin, Kmax = self.Kmin, self.Kmax\\n self.apath = array([0 for y in range(self.T)], dtype=float)\\n self.cpath = array([0 for y in range(self.T)], dtype=float)\\n self.npath = array([0 for y in range(self.T)], dtype=float)\\n # generate each generation's asset, consumption and labor supply forward\\n for y in range(self.T-1): # y = 0, 1,..., 58\\n self.cpath[y] = self.chebeval(array([self.apath[y]]),self.ac[y],Kmin,Kmax)\\n # if self.cpath[y] < 0:\\n # self.cpath[y] = 0\\n if y >= self.W:\\n income = self.b\\n else:\\n self.npath[y] = self.chebeval(array([self.apath[y]]),self.an[y],Kmin,Kmax)\\n income = (1-self.tau)*self.w*self.npath[y]\\n self.apath[y+1] = (1+self.r)*self.apath[y] + income - self.cpath[y]\\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\\n # the oldest generation's consumption and labor supply\\n self.cpath[self.T-1] = (1+self.r)*self.apath[self.T-1] + self.b\\n # self.cpath[self.T-1] = self.chebeval(array([self.apath[self.T-1]]),self.ac[self.T-1],Kmin,Kmax)\\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])\\n # print self.cpath, self.apath, self.npath\",\n \"def calculate_path(self):\\n #Se repite el ciclo para el número especificado de veces\\n for i in range(self.iterations):\\n for ant in self.ants:\\n ant.setup_ant()\\n while not ant.final_node_reached:\\n #Seleccion aleatoria del nodo a visitar\\n node_to_vist = self.select_next_node(self.map.nodes_array[int(ant.actual_node[0])][int(ant.actual_node[1])])\\n #Mover la hormiga al siguiente nodo seleccionado al azar\\n ant.move_ant(node_to_visit)\\n #Compruebe si se ha alcanzado la solución\\n ant.is_final_node_reached()\\n #Agregar la ruta resultante a la lista de rutas\\n self.add_to_path_results(self.delete_loops(ant.get_visited_nodes()))\\n # Habilitar a la hormiga para otra busqueda\\n ant.enable_start_new_path()\\n \\n # Actualizar el nivel global de feromonas\\n self.pheromone_update()\\n self.best_result = self.paths[0]\\n\\n #Vaciar la lista de rutas\\n self.empty_paths()\\n print('Iteration: ', i, 'lenght of the path: ', len(self.best_result))\\n return self.best_result\",\n \"def astar_implicit(successors,s,g,cost=(lambda v,w:1),heuristic=(lambda v:0),verbose=1):\\n if not callable(g):\\n gtest = lambda x,goal=g: x==g\\n else:\\n gtest = g\\n inf = float('inf')\\n d = dict()\\n p = dict()\\n d[s] = 0\\n Q = [(0,0,s)] #each element is a tuple (f,-c,v) with f=c + heuristic(v), c=cost from start, v=vertex\\n nnodes = 0\\n while len(Q) > 0:\\n f,minus_c,v = heapq.heappop(Q) #get the element in the queue with the least value of c\\n nnodes += 1\\n if gtest(v):\\n #found a path\\n if verbose: print(\\\"A* succeeded in\\\",nnodes,\\\"iterations\\\")\\n return predecessor_traverse(p,s,v),d,p\\n for w in successors(v):\\n dcand = d[v] + cost(v,w) #this is the cost of going through v to w\\n if dcand < d.get(w,float('inf')):\\n #going through v is optimal\\n #if the predecessor of w is not None, then we'll have to adjust the heap\\n if w in p:\\n Q = [(f,c,x) for (f,c,x) in Q if x is not w]\\n heapq.heapify(Q)\\n d[w] = dcand\\n p[w] = v\\n #put w back on the queue, with the heuristic value as its priority\\n heapq.heappush(Q,(dcand+heuristic(w),-dcand,w))\\n #no path found\\n if verbose: print(\\\"A* failed in\\\",nnodes,\\\"iterations\\\")\\n return None,d,p\",\n \"def solve_assignments(self):\\n # build valuations vector \\n c = -1 * self.valuations.flatten()\\n\\n # empty G and h, no inequality constraints\\n G = np.zeros((1, self.n**2))\\n h = np.zeros((1))\\n\\n # build A and b, enforces unique room-agent matching\\n A = np.zeros((2 * self.n, self.n**2))\\n b = np.ones((2 * self.n))\\n for i in range(self.n):\\n # exactly one room per agent\\n A[i, i * self.n + np.arange(self.n)] = 1.0 \\n # exactyly one agent per room\\n A[self.n + i, (self.n) * np.arange(self.n) + i] = 1.0\\n\\n B = set(range(self.n**2))\\n status, x = ilp(c=matrix(c, tc='d'), G=matrix(G, tc='d'), \\n h=matrix(h, tc='d'), A=matrix(A, tc='d'), \\n b=matrix(b, tc='d'), B=B)\\n\\n # get assignments\\n x = np.argmax(np.array(x).reshape(self.n, self.n), axis=1)\\n self.assignments = x \\n\\n return self.assignments\",\n \"def solve(self) -> Optional[Tuple[list, int]]:\\n agents = copy(self.agents)\\n groups = []\\n\\n # Solve for every group\\n for agent in agents:\\n self.agents = [agent]\\n solver = EPEAStar(self.problem, self.agents, self.cats, self.stat_tracker,\\n max_cost=self.path_set.get_remaining_cost([agent.identifier], self.max_value))\\n solution = solver.solve()\\n if solution is None:\\n return None\\n agent_paths, cost = solution\\n self.path_set.update(agent_paths)\\n\\n groups.append(([agent], cost))\\n\\n # Find and resolve conflicts until solution is conflict-free\\n conflict = self.path_set.find_conflict()\\n while conflict is not None:\\n a, b = conflict\\n groups = self.merge_groups(groups, a, b, self.cats)\\n if groups is None:\\n return None\\n conflict = self.path_set.find_conflict()\\n return self.path_set.paths, sum(self.path_set.costs)\",\n \"def evaluate(G, path, home_idxs, verbose=False):\\n dropoffs = assign_dropoffs(G, path, home_idxs)\\n cost, msg = cost_of_solution(G, path, dropoffs, shortest=all_pairs_dists)\\n if verbose:\\n print(msg)\\n\\n return cost\",\n \"def g_solving_subproblem_of_LR(self,vehicle_id):\\r\\n global_LB=-10000\\r\\n global_UB=10000\\r\\n iteration_for_RSP=20\\r\\n optimal_solution_for_RSP=None\\r\\n optimal_value_y=0\\r\\n self.multiplier_v=0.5\\r\\n\\r\\n #solve the expected shortest path problem\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 4)\\r\\n #obtain the variance\\r\\n y_=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n\\r\\n for k in range(iteration_for_RSP):\\r\\n # print(k)\\r\\n LB=0\\r\\n # step 2: solve decomposed dual problems\\r\\n # Part I: subproblem of x\\r\\n self.g_dynamic_programming_algorithm(vehicle_id, 2)\\r\\n LB+=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian\\r\\n\\r\\n # Part II: subproblem of y\\r\\n obj_of_y_ = self.reliability * (y_) ** 0.5 - self.multiplier_v * y_\\r\\n if obj_of_y_ > 0:\\r\\n y = 0\\r\\n LB += 0\\r\\n else:\\r\\n y = y_\\r\\n LB += obj_of_y_\\r\\n # generate an upper bound\\r\\n variance = self.g_ending_state_vector[vehicle_id].VSStateVector[0].Primal_Label_cost_variance\\r\\n Label_cost_for_lagrangian_mean=self.g_ending_state_vector[vehicle_id].VSStateVector[0].Label_cost_for_lagrangian_mean\\r\\n UB=Label_cost_for_lagrangian_mean+self.reliability*(variance)**0.5\\r\\n\\r\\n # print(\\\"UB:{}\\\".format(UB))\\r\\n # print(\\\"LB:{}\\\".format(LB))\\r\\n\\r\\n # UB and LB update\\r\\n if LB > global_LB:\\r\\n global_LB = LB\\r\\n optimal_solution_for_RSP = self.g_ending_state_vector[vehicle_id].VSStateVector\\r\\n optimal_value_y = y\\r\\n\\r\\n if UB < global_UB:\\r\\n global_UB = UB\\r\\n\\r\\n\\r\\n # step 3: update multipliers\\r\\n if variance-y!= 0:\\r\\n self.multiplier_v+= (global_UB - LB) / (variance-y)\\r\\n # if self.multiplier_v<0:\\r\\n # self.multiplier_v=1\\r\\n # print(self.multiplier_v)\\r\\n\\r\\n # step 4: termination condition test\\r\\n if global_UB != 0:\\r\\n gap = abs((global_UB-global_LB) / global_UB)\\r\\n # print(gap)\\r\\n if gap < 0.02:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP, optimal_value_y,global_LB,global_UB\\r\\n else:\\r\\n if global_UB - global_LB == 0:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\\r\\n\\r\\n if k == iteration_for_RSP - 1:\\r\\n print(\\\"iteration{}\\\".format(k + 1))\\r\\n print(self.multiplier_v)\\r\\n print(global_LB, global_UB)\\r\\n return optimal_solution_for_RSP,optimal_value_y,global_LB,global_UB\",\n \"def _optimize(self) -> None:\\n\\n for i, agent in enumerate(self.agents):\\n states, actions, rewards, next_states, dones = self.memory.sample()\\n\\n actor_next_state = self._agent_states(i, next_states)\\n next_actions = torch.cat(\\n [a.actor_target(actor_next_state) for a in self.agents], 1\\n )\\n next_q = agent.critic_target(next_states, next_actions).detach()\\n target_q = rewards[:, i].view(-1, 1) + self.gamma * next_q * (\\n 1 - dones[:, i].view(-1, 1)\\n )\\n local_q = agent.critic_local(states, actions)\\n\\n value_loss = agent.loss_fn(local_q, target_q)\\n agent.value_optimizer.zero_grad()\\n value_loss.backward()\\n agent.value_optimizer.step()\\n\\n local_actions = []\\n for i, a in enumerate(self.agents):\\n local_states = self._agent_states(i, states)\\n local_actions.append(\\n a.actor_local(local_states)\\n if a == agent\\n else a.actor_local(local_states).detach()\\n )\\n local_actions = torch.cat(local_actions, 1)\\n policy_loss = -agent.critic_local(states, local_actions).mean()\\n\\n agent.policy_optimizer.zero_grad()\\n policy_loss.backward()\\n agent.policy_optimizer.step()\\n\\n self._update_target_model(agent.critic_local, agent.critic_target)\\n self._update_target_model(agent.actor_local, agent.actor_target)\",\n \"def optimal_route(graph,homes,source):\\n number_of_homes = len(homes)\\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\\n \\n cluster_list = range(1,number_of_homes+1)\\n optimal_cost = np.Inf\\n optimal_dropoffs = dict()\\n optimal_route = []\\n optimal_num_clusters = 0\\n\\n\\n for num_clusters in cluster_list:\\n home_clusters = num_clusters_to_clustering[num_clusters]\\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\\n if cost < optimal_cost:\\n optimal_cost = cost\\n optimal_route = route \\n optimal_dropoffs = dropoffs\\n optimal_num_clusters = num_clusters\\n\\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters\",\n \"def get_sol(self):\",\n \"def solve():\\n # the amount of lattice paths from (0, 0) to (n, k) is (n+k) over n (according to Wikipedia)\\n return binomial_coefficient(20 + 20, 20)\",\n \"def solve(self):\\n\\n # Assign variables to each quantity being solved.\\n r_lookup, lookup, num = {}, {}, 0\\n for element in self.elements:\\n if is_wire(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n elif not is_cs(element) and element is not self.ground:\\n lookup[num] = element\\n r_lookup[element] = num\\n num += 1\\n\\n # Set up the linear algebraic equation Ax=b\\n A = np.zeros((num, num))\\n b = np.zeros(num)\\n for row, element in lookup.items():\\n if is_wire(element) and element is not self.ground:\\n for two_sided in element.attached:\\n if is_cs(two_sided):\\n if two_sided.pos is element:\\n b[row] += -1 * two_sided.current\\n else:\\n b[row] += two_sided.current\\n else:\\n if two_sided.pos is element:\\n flow = 1\\n else:\\n flow = -1\\n A[row, r_lookup[two_sided]] = flow\\n elif is_vs(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n b[row] = element.voltage\\n elif is_resistor(element):\\n check_connected(element)\\n if element.pos is not self.ground:\\n A[row, r_lookup[element.pos]] = 1\\n if element.neg is not self.ground:\\n A[row, r_lookup[element.neg]] = -1\\n A[row, r_lookup[element]] = -1 * element.resistance\\n\\n b = b.reshape((num, 1))\\n try:\\n x = np.linalg.solve(A, b)\\n except np.linalg.LinAlgError:\\n raise CircuitError('Insufficient information to solve circuit')\\n\\n # Assign values to all circuit components\\n for i in range(num):\\n item = lookup[i]\\n if is_wire(item):\\n item.potential = x[i, 0]\\n elif isinstance(item, DualSided):\\n item.current = x[i, 0]\\n\\n # Mark circuit as solved\\n self.been_solved = True\",\n \"def solver_GP(self, eta, mu, lambda_, S, D, A_Init=None):\\n\\n epsOut = 1e-3\\n maxIter = 200\\n maxTrial = 20\\n\\n N, M = self.X.shape\\n if mu == -1:\\n nLabeled = np.sum(S + D) / 2\\n nUnlabeled = N * (N - 1) / 2 - nLabeled\\n mu = nLabeled / nUnlabeled\\n\\n if not A_Init:\\n A_Init = M / (M + 1) * np.diag(np.ones(M))\\n\\n iterGP = 0\\n A_pre = (A_Init + A_Init.T) / 2\\n objL_pre = self.computeObj_GP(eta, mu, lambda_, S, D, A_pre)\\n A_best = A_pre\\n objL_best = objL_pre\\n normOut = 1e10\\n\\n while (normOut > epsOut) and (iterGP < maxIter):\\n iterGP += 1\\n\\n # compute gradient\\n grad = self.computeGrad_GP(eta, mu, lambda_, S, D, A_pre)\\n\\n # choose step size\\n deltak = 0.1 * M / (np.linalg.norm(grad, ord='fro') * np.sqrt(iterGP))\\n deltakk = deltak\\n\\n trial = 0\\n while trial < maxTrial:\\n trial += 1\\n\\n # gradient ascent\\n A = A_pre + np.dot(deltak, grad)\\n\\n # projection\\n A = (A + A.T) / 2\\n b, V = np.linalg.eig(A)\\n\\n b = b * (b > 0)\\n A = np.dot(V @ np.diag(b), V.T)\\n\\n # print(A)\\n objL = self.computeObj_GP(eta, mu, lambda_, S, D, A)\\n\\n if objL >= objL_pre: # success\\n objL_pre = objL\\n break\\n else: # fail\\n deltak = deltak / 2\\n\\n if trial == maxTrial: # fail\\n print('GP update fails...\\\\n')\\n A = A_pre + 2 * deltakk * grad\\n A = (A + A.T) / 2\\n b, V = np.linalg.eig(A)\\n # b = np.diag(b)\\n b = b * (b > 0)\\n A = np.dot(V @ np.diag(b), V.T)\\n\\n objL = self.computeObj_GP(eta, mu, lambda_, S, D, A)\\n\\n elif objL >= objL_best: # beat best\\n A_best = A\\n objL_best = objL\\n\\n normOut = np.linalg.norm(A_pre - A, ord='fro')\\n A_pre = A\\n objL_pre = objL\\n\\n A_Final = A_best\\n\\n return A_Final, iterGP\",\n \"def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\\n best = route.copy()\\n cost_list, T_list = [], []\\n accept_list = [[],[]]\\n\\n chains, iterations = 0, 0\\n T_0 = T\\n iterations = 0\\n\\n while T > 0:\\n for i in range(1, len(route) - 2):\\n # test\\n # Adjust temperature\\n if scheme == \\\"exp\\\":\\n T = T*c\\n if scheme == \\\"log\\\":\\n alpha = 50\\n T = T_0/(1+alpha*np.log(1+iterations))\\n # if scheme == \\\"std\\\":\\n # delta = .01\\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\\n if scheme == \\\"quad\\\":\\n alpha = 1\\n T = T_0/(1+alpha*iterations**2)\\n\\n iterations += 1\\n \\n for j in range(i + 1, len(route)):\\n chains += 1\\n\\n if j - i == 1: continue\\n\\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\\n T_list.append(T)\\n\\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\\\\n best[j - 1], best[j]) < 0:\\n best[i:j] = best[j - 1:i - 1:-1]\\n else:\\n temp = best.copy()\\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\\n temp[i:j] = temp[j - 1:i - 1:-1]\\n _, cost1 = calculate_cost(temp,adjacency_matrix)\\n\\n U = rs.uniform()\\n Z = np.exp((cost0-cost1)/T)\\n\\n if U < Z:\\n accept_list[1].append(Z)\\n accept_list[0].insert(0,T)\\n\\n best[i:j] = best[j - 1:i - 1:-1]\\n\\n if chains > max_chain_length:\\n print(\\\"End by chainlength: \\\",chains,\\\"T =\\\",T,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\\n\\n route = best.copy()\\n print(\\\"End by T: \\\",T,\\\"Chains: \\\",chains,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\",\n \"def solve_cg_eps(self, params, r, sz, energy, aux):\\n\\n dp0_i, g2_i, itr, nsamples = aux\\n\\n jac = self.vmap_getder(params, r, sz, nsamples)\\n #jac_T = conj_transpose(jac)\\n\\n f_i = jnp.real(-2 * psum(jnp.matmul(energy, jnp.conjugate(jac)), axis_name='p') / nsamples)\\n g2_i = self.beta * g2_i + (1. - self.beta) * f_i**2\\n g2h_i = jnp.sqrt(g2_i / (1. - self.beta**itr))\\n\\n# cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(v_i, jac_T), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\\n cg_mult = lambda v_i: jnp.real(psum(jnp.matmul(jnp.matmul(jnp.conjugate(jac), v_i), jac), axis_name='p') / nsamples) + self.eps * (0.001 + g2h_i) * v_i\\n\\n dp_i, info = jax.scipy.sparse.linalg.cg(cg_mult, f_i, x0=dp0_i, tol=1e-5, atol=0.0, maxiter=200)\\n return dp_i, g2_i\",\n \"def solve(\\n self,\\n initial_routes=None,\\n solver=\\\"cbc\\\",\\n cspy=False,\\n exact=True,\\n pricing_strategy=\\\"PrunePaths\\\",\\n ):\\n if cspy:\\n self.G.graph[\\\"subproblem\\\"] = \\\"cspy\\\"\\n else:\\n self.G.graph[\\\"subproblem\\\"] = \\\"lp\\\"\\n print(self.G.graph[\\\"name\\\"], self.G.graph[\\\"subproblem\\\"])\\n print(\\\"===========\\\")\\n prob = VehicleRoutingProblem(\\n self.G,\\n duration=self.max_duration,\\n load_capacity=self.max_load,\\n drop_penalty=self.penalty,\\n pickup_delivery=self.activate_pickup_delivery,\\n distribution_collection=self.activate_distribution_collection,\\n time_windows=self.activate_time_windows,\\n )\\n prob.solve(\\n initial_routes=initial_routes,\\n cspy=cspy,\\n exact=exact,\\n pricing_strategy=pricing_strategy,\\n solver=solver,\\n )\\n self.best_value, self.best_routes = prob.best_value, prob._best_routes_as_graphs\\n self.best_routes_nodes = prob.best_routes\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def tryEverything(g, verbose, graphname):\\r\\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\\r\\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\\r\\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\\r\\n desc = ['DLS/DC', None, 'DCP']\\r\\n useOfBIM = [False, True]\\r\\n insertion = [False, True]\\r\\n BSA = [False, True]\\r\\n res: Dict[str, List[float]] = {}\\r\\n cnt = 0\\r\\n\\r\\n for ip, p in enumerate(prio):\\r\\n for ipl, pl in enumerate(placement):\\r\\n for ic, c in enumerate(costFunction):\\r\\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\\r\\n for idd, d in enumerate(desc):\\r\\n for iu, u in enumerate(useOfBIM):\\r\\n for ii, i in enumerate(insertion):\\r\\n for ib, b in enumerate(BSA):\\r\\n cnt += 1\\r\\n name = \\\";\\\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\\r\\n\\r\\n # dispName = \\\"-\\\".join(map(str, [p, pl, c, d, u, i, b]))\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", dispName)\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", name)\\r\\n\\r\\n startScheduling = timeit.default_timer()\\r\\n try:\\r\\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\\r\\n strategyPlacement=pl,\\r\\n useOfBIM=u, desc=d,\\r\\n insertion=i, bsa=b, verbose=verbose)\\r\\n verifPrec(g, schedule, verbose)\\r\\n endScheduling = timeit.default_timer()\\r\\n # print(\\\"Ended in :\\\", 1000*(endScheduling - startScheduling), \\\"ms\\\")\\r\\n # print(\\\"Ended in :\\\", round(1000 * (endScheduling - startScheduling),2), \\\"ms\\\")\\r\\n timeS = round(1000 * (endScheduling - startScheduling), 2)\\r\\n # print(f\\\"timeS : {timeS}\\\")\\r\\n if verbose:\\r\\n print(f\\\"Time : {timeS}ms\\\")\\r\\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\\r\\n except Exception as _:\\r\\n\\r\\n print(\\\"Error for : \\\" + name + \\\" on file \\\" + graphname)\\r\\n file = open(\\\"error.log\\\", 'a')\\r\\n file.write(f\\\"Error for {name} on file {graphname}\\\\n\\\")\\r\\n file.close()\\r\\n raise _\\r\\n return res\\r\\n return res\",\n \"def solve(self):\\n smallest_f = self.get_smallest_f_cost_unvisited_node()\\n smallest_f_node = smallest_f[0]\\n\\n if smallest_f[1] > 1:\\n current_node = self.get_smallest_h_cost_unvisited_node()\\n else:\\n current_node = smallest_f_node\\n if current_node.f_cost == self.inf:\\n return\\n\\n self.set_h_cost(current_node)\\n self.unvisited_pos.remove(current_node.pos)\\n self.visited_pos.append(current_node.pos)\\n neighbours = algo_utils.get_neighbours(current_node, self.grid, self.wall_pos)\\n\\n for neigh in neighbours:\\n neighbour_dist = neigh.g_cost\\n current_dist = current_node.g_cost\\n new_dist = current_dist + 1\\n if neighbour_dist < new_dist:\\n continue\\n neigh.g_cost = new_dist\\n self.set_h_cost(neigh)\\n mix_neigh = {neigh.pos: neigh.g_cost}\\n self.mix.update(mix_neigh)\\n mix_current = {current_node.pos: current_node.g_cost}\\n self.mix.update(mix_current)\\n\\n smallest_f = self.get_smallest_f_cost_unvisited_node()\\n smallest_f_node = smallest_f[0]\\n smallest_h_node = self.get_smallest_h_cost_unvisited_node()\\n\\n if (\\n self.end_pos not in self.unvisited_pos\\n or algo_utils.get_smallest_g_cost_unvisited_node(\\n self.grid, self.unvisited_pos\\n ).g_cost\\n == self.inf\\n ):\\n for key, value in self.mix.items():\\n self.mix[key] = round((value * 1.0) / self.end_node.g_cost, 3)\\n self.backtrack_path(self.end_node)\\n else:\\n if smallest_f[1] > 1:\\n current_node = smallest_h_node\\n else:\\n current_node = smallest_f_node\\n self.solve()\",\n \"def solve(args):\\n\\n global a\\n global b\\n global c\\n\\n a, b, c = args\\n mem = {}\\n\\n # a tree of 30 levels should be enough (all values are < 2^30)\\n sol = count_pairs(30, 1, 1, 1, mem)\\n\\n return sol\",\n \"def get_pathologic_covering_routes(n_pl, n_target, attacker_strategy, target_values):\\n # computes the coefficient used by the greedy oracle to choose routes\\n targets_coeff = np.transpose(np.multiply(attacker_strategy, target_values))\\n\\n # randomly selects the player for which the non optimal choice will be made\\n wrong_pl = randint(1, n_pl)\\n\\n # generate the non optimal route randomly\\n n_covered_targets = randint(n_pl,n_target-1)\\n non_opt_action = np.zeros(n_target)\\n for i in range(0, n_covered_targets):\\n random_covered_target = randint(0, n_target-1)\\n non_opt_action[random_covered_target] = 1\\n\\n # compute the value of the non optimal route\\n non_opt_val = get_value_single_route(non_opt_action, targets_coeff)\\n\\n # generate routes that have, as a single, values smaller than the best greedy route but taken togher perform\\n # at least as well. [[0,1,...],[...],...] a[r][t]=1 iff t is covered by r.\\n # The returned list should have n_pl - 1 routes\\n opt_routes = get_opt_routes(n_pl, non_opt_action)\\n\\n I={}\\n for pl in range(1, n_pl+1):\\n\\n n_r = randint(0, MAX_ROUTES)\\n temp = lil_matrix((n_r+1, n_target), dtype='int8')\\n\\n if pl == wrong_pl:\\n # put the non opt route in the bucket\\n for t in non_opt_action.nonzero():\\n temp[0,t] = 1\\n else:\\n for t in opt_routes.pop().nonzero():\\n temp[0,t] = 1\\n\\n # generate other random routes with single value less than the non_opt_value\\n for r in range(1, n_r):\\n new_route = get_r_limited_val(non_opt_val, targets_coeff)\\n\\n for t in new_route.nonzero():\\n temp[r,t] = 1\\n\\n I[pl] = temp.tocsr()\\n\\n return I\",\n \"def alg(c):\\n return c[0]*G[0] + c[1]*G[1] + c[2]*G[2]\",\n \"def solve(self):\",\n \"def gen_sol(self, start, n_candidats):\\n sol = np.zeros(self.n_objets)\\n poidrestant = self.W\\n visited = set() # liste des objets visité\\n # ajouter le premier objet\\n r = rn.randint(1, poidrestant // self.poids[start])\\n sol[start] = r\\n poidrestant -= self.poids[start] * r\\n gain = r * self.benifices[start]\\n visited.add(start) # ajouter le debut a la liste civité\\n\\n # la liste candidates avec les pheromones mis a jours localement (0 sur les visited)\\n candidats, pheromones = self.listeCandidate(\\n self.pheromone, visited, n_candidats\\n )\\n\\n for i in candidats:\\n # Choisir le prochain objets parmi les candidats ainsi que le nombre\\n move, nb = self.pick_move(\\n pheromones, candidats, n_candidats, self.utilites, visited\\n )\\n toPop = candidats.index(move)\\n candidats.pop(toPop)\\n n_candidats -= 1\\n np.delete(\\n pheromones, toPop\\n ) # rendre le pheromone à 0 pour indiquer qu'il a été visité\\n\\n # Mise a jour poidRestant et gain de la solution\\n poidrestant -= self.poids[move] * nb\\n while poidrestant < 0:\\n nb -= 1\\n poidrestant += self.poids[move]\\n\\n sol[move] = nb\\n gain += nb * self.benifices[move]\\n\\n # ajouter l'objet a visited\\n visited.add(move)\\n # print(\\\"s\\\",i,sol,gain)\\n return sol, gain, self.W - poidrestant\",\n \"def solve_lp(facilities, clients):\\n facility_costs = [facility['cost'] for facility in facilities]\\n client_costs = [client['costs'] for client in clients]\\n\\n flat_ccosts = reduce(lambda acc, curr: acc + curr, client_costs)\\n sol = lp.solve(facility_costs, flat_ccosts)\\n primal = sol['x']\\n dual = sol['y']\\n\\n return primal, dual\",\n \"def aStar(sx = 1.55, sy = 2.05, gx = 1.55, gy = 4.05, d_diagnoal = 14, d_straight = 10, grid_reso = 0.1, grid_width = 6, grid_height = 3):\\n width = int(grid_width/grid_reso)\\n height = int(grid_height/grid_reso)\\n #TODO\\n A_sx, A_sy = realPosTogridPos(sx, sy, grid_reso = grid_reso)\\n A_gx, A_gy = realPosTogridPos(gx, gy, grid_reso = grid_reso)\\n startNode = Node(A_sx,A_sy,None,0,0,0)\\n goalNode = Node(A_gx,A_gy,None,0,0,0)\\n # The set of nodes already evaluated\\n closedSet = set()\\n # The set of currently discovered nodes that are not evaluated yet.\\n openSet = set()\\n # Initially, only the start node is known.\\n openSet.add(startNode)\\n # For each node, which node it can most efficiently be reached from.If a node can be reached from many nodes, cameFrom will eventually contain the most efficient previous step.\\n cameFrom = []\\n # For each node, the cost of getting from the start node to that node.\\n gScore = create_gScore(width, height)\\n start_x = startNode.x\\n start_y = startNode.y\\n # The cost of going from start to start is zero.\\n startNode.g_value = 0\\n gScore[start_x][start_y] = 0\\n # For each node, the total cost of getting from the start node to the goal by passing by that node. That value is partly known, partly heuristic.\\n fScore = create_fScore(width, height)\\n # For the first node, that value is completely heuristic.\\n startNode.f_value = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\\n fScore[start_x][start_y] = heuristic_cost_estimate(startNode, goalNode,d_diagnoal,d_straight)\\n while len(openSet) != 0:\\n # current := the node in openSet having the lowest fScore[] value\\n current = node_lowest_fScore(openSet)\\n # If it is the item we want, retrace the path and return it\\n if current.equal(goalNode):\\n path = reconstruct_path(cameFrom, current) # path in real\\n # print \\\"path\\\",path\\n pathInReal = convertGridPathToReal(path, sx, sy, gx, gy, grid_reso = grid_reso) # path in grid\\n return pathInReal\\n\\n openSet.remove(current)\\n closedSet.add(current)\\n current_neighbors = getNeighbors(current, width, height)\\n current_neighbors_num = current_neighbors.shape[1]\\n # for neighbor in current_neighbors:\\n for index in range(current_neighbors_num):\\n [neighbor_x,neighbor_y] = current_neighbors[:,index]\\n neighbor = Node(neighbor_x,neighbor_y,None,np.inf,np.inf,np.inf)\\n if neighbor_in_closedSet(neighbor,closedSet):\\n continue\\n if neighbor_not_in_openSet(neighbor,openSet):\\t# Discover a new node\\n openSet.add(neighbor)\\n\\n # The distance from start to a neighbor the \\\"dist_between\\\" function may vary as per the solution requirements.\\n current_x = current.x\\n current_y = current.y\\n tentative_gScore = gScore[current_x][current_y] + dist_between(current, neighbor,d_diagnoal,d_straight)\\n neighbor_x = neighbor.x\\n neighbor_y = neighbor.y\\n if tentative_gScore >= gScore[neighbor_x][neighbor_y]:\\n continue\\t\\t# This is not a better path.\\n\\n neighbor.father = current\\n cameFrom.append(neighbor)\\n gScore[neighbor_x][neighbor_y] = tentative_gScore\\n neighbor.g_value = tentative_gScore\\n neighbor_f_value = gScore[neighbor_x][neighbor_y] + heuristic_cost_estimate(neighbor, goalNode,d_diagnoal,d_straight)\\n fScore[neighbor_x][neighbor_y] = neighbor_f_value\\n neighbor.f_value = neighbor_f_value\\n return False\",\n \"def solve(self):\\n start = datetime.now()\\n f = self.function\\n while not self.converged():\\n self.history.append(self.vertices)\\n\\n #step 1: sort\\n self.order_vertices()\\n\\n #step 3: reflect\\n reflected = self.get_reflected_point()\\n if f(*self.vertices[0]) < f(*reflected) < f(*self.vertices[-1]):\\n self.reflect()\\n continue\\n\\n #step 4: expand\\n if self.reflected_is_best():\\n expanded = self.get_expanded_point()\\n if f(*expanded) < f(*reflected):\\n self.expand()\\n else:\\n self.reflect()\\n continue\\n\\n #step 5: contract\\n contracted = self.get_contracted_point()\\n if f(*contracted) < f(*self.vertices[-1]):\\n self.contract()\\n continue\\n\\n #step 6: shrink\\n self.shrink()\\n print(\\\"optimization took {0}\\\".format(datetime.now()-start))\\n return self.history, self.cache.history\",\n \"def refugia_adj_5(params, ns):\\n #17 parameters \\n nu1_1, nu1_2, nuA, nu2, nu3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nu_T1 = [nu1_1, nuA]\\n fs.integrate(nu_T1, T1a)\\n ## Population function and migration matrix for T1b\\n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\\n fs.integrate(nu_T1, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1_2, nu2, nu3]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1_2, nu2, nu3]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def refugia_adj_5_full(params, ns):\\n #22 parameters \\n nu1_1a, nu1_1b, nu1_2, nu1_3, nuA_a, nuA_b, nu2_2, nu2_3, nu3_2, nu3_3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nu_T1a = [nu1_1a, nuA_a]\\n fs.integrate(nu_T1a, T1a)\\n ## Population function and migration matrix for T1b\\n nu_T1b = [nu1_1b, nuA_b] \\n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\\n fs.integrate(nu_T1b, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1_2, nu2_2, nu3_2]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1_3, nu2_3, nu3_3]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def solution(n, s, a, b, fares):\\n\\n table = [[float(\\\"inf\\\")]*n for _ in range(n)]\\n for (c, d, f) in fares:\\n table[c-1][d-1] = f\\n table[d-1][c-1] = f\\n\\n for idx in range(n):\\n table[idx][idx] = 0\\n\\n # do floyd to find all shortest paths\\n for kdx in range(n):\\n for idx in range(n):\\n for jdx in range(n):\\n table[idx][jdx] = min(table[idx][jdx], table[idx][kdx] + table[kdx][jdx])\\n \\n# for row in table:\\n# print(row)\\n \\n answer = table[s-1][a-1] + table[s-1][b-1]\\n # print(\\\"seperate:\\\", answer)\\n for idx in range(n):\\n # print(\\\"idx 경유:\\\", idx, table[s-1][idx] + table[idx][a-1] + table[idx][b-1])\\n answer = min(answer, table[s-1][idx] + table[idx][a-1] + table[idx][b-1])\\n\\n # print(\\\"answer:\\\", answer)\\n return answer\",\n \"def Problem3(n):\\n A = Problem2(n)\\n b = np.vstack(np.random.random(n))\\n return A,sl.spsolve(A,b),b\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n\\n\\n\\n\\n path = [starting_car_location]\\n dict = {}\\n index = 0\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == starting_car_location:\\n index = i\\n\\n path = [index]\\n\\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\\n\\n home_indexes = []\\n\\n for home in list_of_homes:\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == home:\\n home_indexes.append(i)\\n break\\n\\n new_adjacency = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n # for sake of figuring out where to walk\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, index, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2:\\n di_path = nx.dijkstra_path(G, home1, home2)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n\\n all_driving_path = list(nx.dfs_edges(G2))\\n\\n\\n\\n\\n walking_to = []\\n walking_from = {}\\n\\n for i in range(len(new_adjacency)):\\n if i in home_indexes:\\n count = 0\\n edge_to = 0\\n for j in range(len(new_adjacency)):\\n if new_adjacency[i][j] != \\\"x\\\":\\n count += 1\\n edge_to = j\\n\\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\\n if count == 1 and i != index and i not in walking_from.keys():\\n new_adjacency[i][edge_to] = \\\"x\\\"\\n new_adjacency[edge_to][i] = \\\"x\\\"\\n walking_to.append(i)\\n if edge_to in walking_from:\\n walking_from[edge_to] = walking_from[edge_to] + [i]\\n else:\\n walking_from[edge_to] = [i]\\n\\n #\\n # for i in range(len(all_driving_path) - 1):\\n # #if first vertex in edge is the same, we should walk\\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\\n # print(all_driving_path[i][0])\\n # print(all_driving_path[i][1])\\n # #get rid of only edge connected to this home\\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \\\"x\\\"\\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \\\"x\\\"\\n # walking_to.append(all_driving_path[i][1])\\n # if all_driving_path[i][0] in walking_from:\\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\\n # else:\\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\\n\\n\\n\\n dropoff_locations = list(walking_from.keys())\\n for loc in dropoff_locations:\\n if loc in home_indexes:\\n dropoff_locations.remove(loc)\\n\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n # G = G2\\n # pos=nx.spring_layout(G2)\\n # nx.draw_networkx_nodes(G2,pos)\\n # nx.draw_networkx_labels(G2, pos)\\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\\n #\\n # plt.draw()\\n # plt.show()\\n\\n # condensed shortest paths to edges - use G3 for real\\n\\n new_adjacency2 = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n for home in home_indexes:\\n if home not in walking_to:\\n di_path = nx.dijkstra_path(G2, index, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\\n di_path = nx.dijkstra_path(G2, home1, home2)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G2, index, loc)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G2, loc, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\\n drive_path = list(nx.dfs_edges(final_G, source=index))\\n drive_path.append(index)\\n\\n mst = nx.minimum_spanning_tree(final_G)\\n\\n\\n\\n new_mst = nx.MultiGraph(mst)\\n for edge in mst.edges():\\n new_mst.add_edge(edge[0], edge[1])\\n\\n\\n if new_mst.degree[index] != 0:\\n to_remove = []\\n for node in new_mst:\\n if (new_mst.degree[node] == 0):\\n to_remove.append(node)\\n new_mst.remove_nodes_from(to_remove)\\n\\n eulerian = list(nx.eulerian_circuit(new_mst, index))\\n\\n path = []\\n for edge in eulerian:\\n path.append(edge[0])\\n\\n path.append(eulerian[len(eulerian) - 1][1])\\n\\n already_seen = []\\n to_remove = []\\n for i in range(len(path) - 1):\\n if path[i] in already_seen:\\n to_remove.append(i)\\n else:\\n already_seen.append(path[i])\\n\\n new_path = []\\n for i in range(len(path) - 1):\\n if i not in to_remove:\\n new_path.append(path[i])\\n path = new_path\\n print(eulerian)\\n else:\\n path = [index]\\n print(path)\\n\\n\\n\\n\\n\\n\\n\\n # print(path)\\n final_path = []\\n for node in path:\\n if node == index:\\n final_path.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path.append(index)\\n #print(walking_from)\\n # print(final_path)\\n # nx.draw(mst)\\n # plt.draw()\\n # plt.show()\\n for node in final_path:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path = []\\n for i in range(len(final_path) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path.append(condensed_path[j])\\n\\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\\n very_final_path.append(index)\\n\\n if len(very_final_path) == 0:\\n very_final_path = [index]\\n\\n print(very_final_path)\\n print(dict)\\n\\n\\n path2 = list(nx.dfs_preorder_nodes(mst, index))\\n\\n final_path2 = []\\n for node in path2:\\n if node == index:\\n final_path2.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path2.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path2.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path2.append(index)\\n\\n\\n for node in final_path2:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path2 = []\\n for i in range(len(final_path2) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path2.append(condensed_path[j])\\n\\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\\n very_final_path2.append(index)\\n\\n if len(very_final_path2) == 0:\\n very_final_path2 = [index]\\n\\n opt1 = cost_of_solution(G, very_final_path, dict)\\n opt2 = cost_of_solution(G, very_final_path2, dict)\\n\\n ultra_final_path = []\\n if (opt1 <= opt2):\\n ultra_final_path = very_final_path\\n else:\\n ultra_final_path = very_final_path2\\n\\n return ultra_final_path, dict\\n\\n pass\",\n \"def value_iteration(P, nS, nA, gamma=0.9, tol=1e-3):\\n\\n\\tvalue_function = np.zeros(nS)\\n\\tpolicy = np.zeros(nS, dtype=int)\\n\\tmax_num_iterations = 2000\\n\\n\\t############################\\n\\t# YOUR IMPLEMENTATION HERE #\\n\\n\\tfor i in range(max_num_iterations):\\n\\t\\tprevious_value_function = np.copy(value_function)\\n\\t\\tfor s in range(nS):\\t# for each state\\n\\t\\t\\tq_values = np.zeros(nA)\\n\\t\\t\\tfor action in range(nA):\\t# for each action\\n\\t\\t\\t\\tq_value = 0\\n\\t\\t\\t\\tfor transition in P[s][action]:\\t# for every possible transition\\n\\t\\t\\t\\t\\tprobability = transition[0]\\n\\t\\t\\t\\t\\treward = transition[2]\\n\\t\\t\\t\\t\\tnext_state = transition[1]\\n\\t\\t\\t\\t\\tvalue_next_state = previous_value_function[next_state]\\n\\n\\t\\t\\t\\t\\t# print(\\\"probability: \\\" + str(probability) + \\\"reward: \\\" + str(reward) + \\\"value next state: \\\" + str(value_next_state))\\n\\n\\t\\t\\t\\t\\tq_value += probability * (reward + gamma * value_next_state)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tq_values[action] = q_value\\n\\n\\t\\t\\tvalue_function[s] = np.amax(q_values)\\t# the value is the max of these q values\\n\\t\\t\\t# extract policy\\n\\t\\t\\tpolicy[s] = np.argmax(q_values)\\n\\n\\t\\t# find the maximum difference between the previous value function and the current value function\\n\\t\\tdifArray = np.subtract(value_function, previous_value_function)\\n\\t\\tfor x in range(nS):\\n\\t\\t\\tdifArray[x] = abs(difArray[x])\\n\\t\\tmaxDif = np.amax(difArray)\\n\\n\\t\\tif (maxDif < tol):\\n\\t\\t\\tprint(\\\"optimal policy found at iteration \\\" + str(i + 1))\\n\\t\\t\\tbreak\\n\\n\\t############################\\n\\treturn value_function, policy\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def generate(self):\\n \\n ##Dictionary of put values\\n self.put = {}\\n ##Dictionary of call values\\n self.call = {}\\n \\n bottom = self.range[0]\\n top = self.range[2]\\n iter = self.range[1]\\n \\n if self.meth == 'bi':\\n for E in range(bottom,top+iter,iter):\\n solver = bi.binomial_euro(S=self.S,E=E,r=self.r,M=400,sigma=self.sigma,method='higham',T=self.T,opt='put')\\n self.put[E] = solver.solve()\\n del solver\\n for E in range(bottom,top+iter,iter):\\n solver = bi.binomial_euro(S=self.S,E=E,r=self.r,M=400,sigma=self.sigma,method='higham',T=self.T,opt='call')\\n self.call[E] = solver.solve()\\n del solver\\n elif self.meth == 'mc':\\n for E in range(bottom,top+iter,iter):\\n solver = mc.mcfast_euro(S=self.S,E=E,r=self.r,M=20000,sigma=self.sigma,T=self.T,opt='put')\\n self.put[E] = solver.solve()\\n del solver\\n for E in range(bottom,top+iter,iter):\\n solver = mc.mcfast_euro(S=self.S,E=E,r=self.r,M=20000,sigma=self.sigma,T=self.T,opt='call')\\n self.call[E] = solver.solve()\\n del solver\\n elif self.meth == 'all':\\n pass\",\n \"def compute_complexity(folder: str,\\n neat: bool = False,\\n neat_gru: bool = False,\\n neat_lstm: bool = False,\\n neat_sru: bool = False,\\n neat_sru_s: bool = False,\\n gen: int = 500,\\n max_v: int = 50,\\n ):\\n # Collect all the populations\\n populations = []\\n if neat: populations.append(D_NEAT)\\n if neat_gru: populations.append(D_NEAT_GRU)\\n if neat_lstm: populations.append(D_NEAT_LSTM)\\n if neat_sru: populations.append(D_NEAT_SRU)\\n if neat_sru_s: populations.append(D_NEAT_SRU_S)\\n if len(populations) == 0: return\\n \\n # Go over all possibilities\\n print(f\\\"\\\\n===> COMPUTING POPULATION'S ELITE COMPLEXITY <===\\\")\\n path = f\\\"population_backup/storage/{folder}/\\\"\\n genes_dict = dict()\\n for pop in populations:\\n path_eval = get_subfolder(f\\\"{path}{pop}/\\\", 'evaluation')\\n complexity = Counter()\\n genes = Counter()\\n genes_detailed = dict()\\n for v in range(1, max_v + 1):\\n population = Population(\\n name=f'{pop}/v{v}',\\n folder_name=folder,\\n use_backup=True,\\n )\\n if population.generation == 0: raise Exception(f\\\"Population {pop}/v{v} loaded incorrectly\\\")\\n if population.generation != gen: population.load(gen=gen)\\n s = population.best_genome.size()\\n complexity[str(s)] += 1\\n c = str(s[0] + s[1])\\n genes[c] += 1\\n if c in genes_detailed:\\n genes_detailed[c].append(v)\\n else:\\n genes_detailed[c] = [v]\\n \\n # Store results at populations themselves\\n update_dict(f'{path_eval}complexity_topology', complexity, overwrite=True)\\n update_dict(f'{path_eval}complexity_genes', genes, overwrite=True)\\n update_dict(f'{path_eval}complexity_genes_detailed', genes_detailed, overwrite=True)\\n \\n # Update global dictionary\\n keys = list(genes.keys())\\n for k in keys:\\n genes[int(k)] = genes[k]\\n del genes[k]\\n genes_dict[pop] = list(sorted(genes.items()))\\n \\n plt.figure(figsize=(10, 2.5))\\n max_x = max([max([a for a, _ in genes_dict[pop]]) for pop in populations])\\n min_x = min([min([a for a, _ in genes_dict[pop]]) for pop in populations])\\n for idx, pop in enumerate(populations):\\n keys = [a for a, _ in genes_dict[pop]]\\n for x in range(max_x):\\n if x not in keys: genes_dict[pop].append((x, 0))\\n x, y = zip(*genes_dict[pop])\\n width = 0.8 / len(populations)\\n plt.bar(x=np.asarray(x) - 0.4 + width / 2 + idx * width,\\n height=y,\\n width=width,\\n linewidth=2,\\n label=pop,\\n color=COLORS[pop])\\n \\n # Beautify the plot\\n plt.xlim(min_x - .5, max_x + .5)\\n plt.xticks([i for i in range(min_x, max_x + 1)])\\n leg = plt.legend(loc='upper center',\\n bbox_to_anchor=(0.5, 1.18),\\n fancybox=True,\\n fontsize=10,\\n ncol=len(populations))\\n for line in leg.get_lines():\\n line.set_linewidth(4.0)\\n plt.grid(axis='y')\\n plt.tight_layout()\\n plt.xlabel(\\\"complexity expressed in #genes\\\")\\n plt.ylabel(\\\"#elites\\\")\\n plt.savefig(f\\\"population_backup/storage/{folder}/images/complexity.png\\\", bbox_inches='tight', pad_inches=0.02)\\n plt.savefig(f\\\"population_backup/storage/{folder}/images/complexity.eps\\\",\\n format='eps',\\n bbox_inches='tight',\\n pad_inches=0.02)\\n # plt.show()\\n plt.close()\\n \\n # Also create a violin plot of the distribution if only two populations\\n if len(populations) == 2:\\n max_x = 0\\n min_x = float('inf')\\n df = pd.DataFrame()\\n palette = []\\n for idx, pop in enumerate(populations):\\n values = []\\n for a, b in genes_dict[pop]:\\n for _ in range(b):\\n values.append(a)\\n \\n # Remove outliers\\n values = sorted(values)\\n q1 = min(values[int(round(1 / 4 * len(values)))], values[int(round(3 / 4 * len(values)))])\\n q3 = max(values[int(round(1 / 4 * len(values)))], values[int(round(3 / 4 * len(values)))])\\n iqr = q3 - q1\\n \\n for i in range(len(values) - 1, -1, -1):\\n if (values[i] < (q1 - 1.5 * iqr)) or (values[i] > (q3 + 1.5 * iqr)): del values[i]\\n if min(values) < min_x: min_x = min(values)\\n if max(values) > max_x: max_x = max(values)\\n df = df.append(pd.DataFrame({'complexity': values, 'y': 'ignore', 'pop': pop}))\\n palette.append(COLORS[pop])\\n \\n # Create the plot\\n plt.figure(figsize=(10, 2.5))\\n sns.violinplot(data=df,\\n x=\\\"complexity\\\", y=\\\"y\\\", hue=\\\"pop\\\",\\n palette=palette, split=True,\\n inner=\\\"quartile\\\")\\n plt.xlim(min_x - .5, max_x + .5)\\n plt.xticks([i for i in range(min_x, max_x + 1)])\\n plt.xlabel(\\\"complexity expressed in #genes\\\")\\n plt.yticks([])\\n plt.ylabel('elite genome density')\\n leg = plt.legend(loc='upper center',\\n bbox_to_anchor=(0.5, 1.25),\\n fancybox=True,\\n fontsize=10,\\n ncol=len(populations))\\n for line in leg.get_lines():\\n line.set_linewidth(4.0)\\n plt.tight_layout()\\n plt.savefig(f\\\"population_backup/storage/{folder}/images/complexity_violin.png\\\",\\n bbox_inches='tight',\\n pad_inches=0.02)\\n plt.savefig(f\\\"population_backup/storage/{folder}/images/complexity_violin.eps\\\",\\n format='eps',\\n bbox_inches='tight',\\n pad_inches=0.02)\\n plt.show()\\n plt.close()\",\n \"def cost_function(H, n_qubits, p, params):\\n ini_state=plus_state(n_qubits)\\n for i in range(p):\\n ini_state=qaoa_step(ini_state,H,n_qubits,params=[params[2*i],params[2*i+1]])\\n return ((sparse.spmatrix.getH(ini_state)).dot(H.dot(ini_state))).real, ini_state\",\n \"def prob3():\\n #set up the matrices\\n solvers.options['show_progress'] = False\\n c = np.array([4., 7., 6., 8., 8., 9.])\\n\\n G = np.array([[1.,1.,0.,0.,0.,0.],\\n [-1.,-1.,0.,0.,0.,0.],\\n [0.,0.,1.,1.,0.,0.],\\n [0.,0.,-1.,-1.,0.,0.],\\n [0.,0.,0.,0.,1.,1.],\\n [0.,0.,0.,0.,-1.,-1.],\\n [1.,0.,1.,0.,1.,0.],\\n [-1.,0.,-1.,0.,-1.,0.],\\n [0.,1.,0.,1.,0.,1.],\\n [0.,-1.,0.,-1.,0.,-1.]])\\n G = np.vstack((G, -1*np.eye(6)))\\n h = np.array([7,-7,2,-2,4,-4,5,-5,8,-8,0,0,0,0,0,0],dtype=\\\"float\\\")\\n\\n #convert the matrices\\n c = matrix(c)\\n G = matrix(G)\\n h = matrix(h)\\n #solve the matrices\\n sol = solvers.lp(c, G, h)\\n return np.ravel(sol['x']), sol['primal objective']\",\n \"def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n result_list = []\\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n \\\"\\\"\\\"Embedded function version\\n \\\"\\\"\\\"\\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\\n fidelities = []\\n for training_state in training_states:\\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\\n exact=exact, noisy=noisy)\\n fidelities.append(fid)\\n avg_fid = np.mean(fidelities)\\n result_list.append(1-avg_fid)\\n print(1-avg_fid)\\n return 1. - avg_fid\\n\\n \\n # Initialize parameters\\n half_turn_min = 0\\n half_turn_max = 2\\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\\n size=num_param)\\n\\n # Optimization using Nelder-Mead.\\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\\n \\n if noisy:\\n maxiter = 60\\n else:\\n maxiter = None\\n \\n res = minimize(h2_qae_wrap, init_params, args=(),\\n method='Nelder-Mead', tol=None, \\n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\\n 'return_all': False, 'fatol': 0.001})\\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\\n return res.x\",\n \"def optimize(self, iterations=1000):\\r\\n prev = None\\r\\n finalx = None\\r\\n finaly = None\\r\\n while iterations:\\r\\n maxei, eis = self.acquisition()\\r\\n new_y = self.f(maxei)\\r\\n if maxei == prev:\\r\\n break\\r\\n self.gp.update(maxei, new_y)\\r\\n pycodehack = finaly is None or self.minimize and finaly > new_y\\r\\n if ((pycodehack or not self.minimize and finaly < new_y)):\\r\\n finaly = new_y\\r\\n finalx = maxei\\r\\n prev = maxei\\r\\n iterations -= 1\\r\\n return finalx, finaly\",\n \"def refugia_adj_1_growthall(params, ns):\\n #14 parameters \\n nu10, nu1, nuA0, nuA, nu20, nu2, nu30, nu3, m3_1, m3_2, m3_3, T1, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1\\n nuA_func = lambda t: nuA0 * (nuA/nuA0)**(t/T1) \\n ## Population function for T1\\n nu_T1_func = lambda t: [nu1, nuA_func(t)]\\n fs.integrate(nu_T1_func, T1)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1, nu2, nu3]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu1_func = lambda t: nu10 * (nu1/nu10)**(t/T3) \\n nu2_func = lambda t: nu20 * (nu2/nu20)**(t/T3) \\n nu3_func = lambda t: nu30 * (nu3/nu30)**(t/T3) \\n nu_T3_func = lambda t: [nu1_func(t), nu2_func(t), nu3_func(t)] \\n mig3 = numpy.array([[0, m3_1, m3_3],[m3_1, 0, m3_2], [m3_3, m3_2, 0]]) \\n fs.integrate(nu_T3_func, T3, m=mig3) \\n return fs\",\n \"def solve(self, niter):\\n E = self.list_PDE[0]\\n I = self.list_PDE[1]\\n\\n # ...\\n un = E.unknown\\n unew = I.unknown\\n\\n# un.set(E.rhs)\\n # ...\\n\\n # ...\\n for i in range(0,niter):\\n\\n rhs = E.dot(un)\\n I.solve(rhs)\\n\\n un.set(unew)\\n # ...\",\n \"def get_problem():\\n\\n # Rename this and/or move to optim package?\\n problem = beluga.optim.Problem('Hannibal_HPAdemo')\\n problem.mode='analytical' #Other options: 'numerical', 'dae'\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n #~~~~~!!!\\n #problem.quantity('terrain3','(-0.3*exp(-0.5*((x-2.7)^2+1.5*(y-2.1)^2))+2.6*exp(-0.55*(0.87*(x-6.7)^2+(y-2.2)^2))+2.1*exp(-0.27*(0.2*(x-5.5)^2+(y-7.2)^2))+1.6*(cos(0.8*y))^2*(sin(0.796*x))^2)')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','m') \\\\\\n .state('y','V*sin(hdg)','m') \\\\\\n\\n # Define controls\\n problem.control('hdg','rad')\\n\\n # Define Cost Functional\\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','m') \\\\\\n .initial('y-y_0','m') \\\\\\n .terminal('x-x_f','m') \\\\\\n .terminal('y-y_f','m')\\n\\n #Define constants\\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\\n problem.constant('conv',1,'s/m^2') #Integral conversion factor\\n problem.constant('V',1,'m/s') #Vehicle speed\\n problem.constant('elev',1,'m') #Initial Elevation\\n\\n #Unit scaling\\n problem.scale.unit('m',1) \\\\\\n .unit('s',1) \\\\\\n .unit('rad',1)\\n\\n #Configure solver\\n #problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=8)\\n problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=15, verbose = True, cached = False)\\n\\n #Initial Guess (Classic test example [4.9,0.4])\\n problem.guess.setup('auto',start=[9.0,0.5], costate_guess=[0.0,-0.1]) #City A\\n #problem.guess.setup('auto',start=[4.9,0.4], costate_guess=[0.1,-0.1]) #City A\\n\\n #Add Continuation Steps (Classic test example [7.2,8.5]) [8, 4.5]\\n problem.steps.add_step(strategy='HPA',hweight=0.9) \\\\\\n .terminal('x', 3.0, 10) \\\\\\n .terminal('y', 9.5, 10) \\\\\\n # .const('w', 0.9, 2, confined=True)\\n\\n #problem.steps.add_step(strategy='manual').num_cases(10) \\\\\\n # .terminal('x', 3.0) \\\\\\n # .terminal('y', 9.5) \\\\\\n\\n #problem.steps.add_step().num_cases(30) \\\\\\n # .const('w',0.99) #Final Terrain weighting factor\\n\\n\\n return problem\",\n \"def compute_costs(self, node, observation=None, area=None):\\n if (node.RRT.hierarchy_number == 0) and (\\n node in node.RRT.starts.values()): # in case an observation is made immediately (root node has no parent)\\n return node.path_costs, node.terminal_costs, node.node_costs\\n\\n C = self.get_C(observation, area)\\n node.vs = self.get_vs(node, C)\\n\\n # Compute node, and terminal costs\\n h = []\\n hN = []\\n for i in range(self.N_goal_states):\\n h.append(self.cost_h(node, self.goal_states[i]))\\n hN.append(self.cost_hN(node, self.goal_states[i]))\\n\\n path_costs = node.parent.path_costs.copy() + node.parent.node_costs.copy()\\n\\n N_vs = len(node.vs)\\n node_costs = []\\n terminal_costs = []\\n for i in range(N_vs):\\n node_costs.append(np.dot(h, node.vs[i]))\\n terminal_costs.append(np.dot(hN, node.vs[i]))\\n node_costs = np.array(node_costs).reshape((1, N_vs))\\n terminal_costs = np.array(terminal_costs).reshape((1, N_vs))\\n\\n if path_costs.shape[1] == node_costs.shape[1] / self.N_goal_states:\\n path_costs_temp = np.zeros(node_costs.shape)\\n for i in range(int(node_costs.shape[1] / self.N_goal_states)):\\n for j in range(self.N_goal_states):\\n path_costs_temp[0, self.N_goal_states * i + j] = path_costs[0, i].copy() + node_costs[\\n 0, self.N_goal_states * i + j].copy()\\n path_costs = path_costs_temp.copy()\\n\\n return path_costs, terminal_costs, node_costs\",\n \"def optimal_nc(f, xl: float, xr: float, n: int, tol: float, *params):\\n # required local variables to return\\n # S : computed value of the integral with required tolerance\\n # N : number of steps for S\\n # err : estimated error of S\\n # iter : number of iterations (steps doubling)\\n iter = 1\\n N = 200\\n h_old = (xr - xl) / (4*N)\\n\\n s1 = composite_quad(f, xl, xr, N, n, *params)\\n N *= 2\\n s2 = composite_quad(f, xl, xr, N, n, *params)\\n N *= 2\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n\\n L = 2\\n m = aitken(s1, s2, s3, L)\\n\\n\\n # если m далеко от теоретического значения, значит мы находимся в области,\\n # где отброшенные величины не малы и нам нужно продолжать делить шаг\\n while m > 4.5 or m < 2.5:\\n s1 = s2\\n s2 = s3\\n N *= 2\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n m = aitken(s1, s2, s3, L)\\n\\n # далее предлагаем идти по оптимальному шагу\\n coef = 0.95\\n h_new = coef * h_old * (tol / np.abs(runge(s2, s3, L, m))) ** (1 / m)\\n\\n N = int((xr - xl) / h_new) + 1\\n\\n while iter != MAXITER + 1:\\n s1 = s2\\n s2 = s3\\n\\n s3 = composite_quad(f, xl, xr, N, n, *params)\\n\\n m = aitken(s1, s2, s3, L)\\n\\n # берём погрешность из метода рунге\\n estimate = np.abs(runge(s2, s3, L, m))\\n\\n if estimate < tol:\\n return N, s3, estimate\\n\\n N *= 2\\n iter += 1\\n\\n print(\\\"Convergence not reached!\\\")\\n return 0, 0, 10 * tol, -100\",\n \"def optimize_parameters(self):\\n # forward\\n for i in range(min(self.big_iter+1,len(self.orders_rev))):\\n if(self.orders_rev):\\n # compute fake images and reconstruction images.\\n self.forward(i,False)\\n # G_A and G_B\\n # Ds require no gradients when optimizing Gs\\n self.set_requires_grad(self.netD, False)\\n # set G_A and G_B's gradients to zero\\n self.optimizers_G[self.orders_rev[i]].zero_grad()\\n # calculate gradients for G_A and G_B\\n self.backward_G(i,False)\\n # update G_A and G_B's weights\\n self.optimizers_G[self.orders_rev[i]].step()\\n # D_A and D_B\\n self.set_requires_grad(self.netD, True)\\n self.optimizer_D.zero_grad() \\n self.backward_D(i,False) \\n self.optimizer_D.step() \\n else:\\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\\n self.backward_DY() # calculate gradients for D_A\\n self.optimizer_D.step()\\n for i in range(min(self.big_iter+1, len(self.orders))):\\n if(self.orders):\\n if(i>0):\\n self.real_A = self.fake_B.detach()\\n self.forward(i,True) # compute fake images and reconstruction images.\\n # G_A and G_B\\n # Ds require no gradients when optimizing Gs\\n self.set_requires_grad(self.netD, False)\\n # set G_A and G_B's gradients to zero\\n self.optimizers_G[self.orders[i]].zero_grad()\\n self.backward_G(i,True) # calculate gradients for G_A and G_B\\n # update G_A and G_B's weights\\n self.optimizers_G[self.orders[i]].step()\\n # D_A and D_B\\n self.set_requires_grad(self.netD, True)\\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\\n self.backward_D(i,True) # calculate gradients for D_A\\n self.optimizer_D.step() \\n else:\\n self.optimizer_D.zero_grad() # set D_A and D_B's gradients to zero\\n self.backward_DX() # calculate gradients for D_A\\n self.optimizer_D.step() \\n self.current_label=self.labels[0]\\n self.current_order=self.orders\\n self.current_pred = np.concatenate((self.pred_real.detach().cpu().numpy().mean(\\n axis=2).mean(axis=2), self.pred_fake.detach().cpu().numpy().mean(axis=2).mean(axis=2)))\",\n \"def linearize_and_solve(g):\\n\\n # initialize the sparse H and the vector b\\n H = np.zeros((len(g.x), len(g.x)), dtype='float')\\n b = np.zeros(len(g.x), dtype='float')\\n\\n # set flag to fix gauge\\n needToAddPrior = True\\n Fx = 0\\n\\n # compute the addend term to H and b for each of our constraints\\n print('linearize and build system')\\n\\n for edge in g.edges:\\n\\n # pose-pose constraint\\n if edge.Type == 'P':\\n\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node state for the current edge\\n x_i = g.x[fromIdx:fromIdx + 3]\\n x_j = g.x[toIdx:toIdx + 3]\\n\\n # (TODO) compute the error and the Jacobians\\n e, A, B = linearize_pose_pose_constraint(\\n x_i, x_j, edge.measurement)\\n\\n # # (TODO) compute the terms\\n b_i = e.transpose() @ edge.information @ A\\n b_j = e.transpose() @ edge.information @ B\\n H_ii = A.transpose() @ edge.information @ A\\n H_ij = A.transpose() @ edge.information @ B\\n H_jj = B.transpose() @ edge.information @ B\\n\\n # (TODO) add the terms to H matrix and b\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\\n H[toIdx:toIdx + 3, toIdx:toIdx + 3] += H_jj\\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 3] += H_ij\\n H[toIdx:toIdx + 3, fromIdx:fromIdx + 3, ] += H_ij.transpose()\\n b[fromIdx:fromIdx + 3] += b_i[0, :]\\n b[toIdx:toIdx + 3] += b_j[0, :]\\n\\n # Add the prior for one pose of this edge\\n # This fixes one node to remain at its current location\\n if needToAddPrior:\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx +\\n 3] = H[fromIdx:fromIdx + 3,\\n fromIdx:fromIdx + 3] + 1000 * np.eye(3)\\n needToAddPrior = False\\n\\n # pose-pose constraint\\n elif edge.Type == 'L':\\n print(\\\"you shouldn't be here...\\\")\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node states for the current edge\\n x = g.x[fromIdx:fromIdx + 3]\\n l = g.x[toIdx:toIdx + 2]\\n\\n # (TODO) compute the error and the Jacobians\\n e, A, B = linearize_pose_landmark_constraint(\\n x, l, edge.measurement)\\n\\n # (TODO) compute the terms\\n b_i = e.transpose() @ edge.information @ A\\n b_j = e.transpose() @ edge.information @ B\\n H_ii = A.transpose() @ edge.information @ A\\n H_ij = A.transpose() @ edge.information @ B\\n H_jj = B.transpose() @ edge.information @ B\\n\\n # (TODO )add the terms to H matrix and b\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\\n H[toIdx:toIdx + 2, toIdx:toIdx + 2] += H_jj\\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 2] += H_ij\\n H[toIdx:toIdx + 2, fromIdx:fromIdx + 3, ] += H_ij.transpose()\\n b[fromIdx:fromIdx + 3] = b_i\\n b[toIdx:toIdx + 2] = b_j\\n # solve system\\n dx = np.linalg.solve(H, b)\\n\\n return dx\",\n \"def solve(self):\\n self.enforce_node_consistency()\\n self.ac3()\\n return self.backtrack(dict())\",\n \"def solve(self):\\n self.enforce_node_consistency()\\n self.ac3()\\n return self.backtrack(dict())\",\n \"def solve(self):\\n self.enforce_node_consistency()\\n self.ac3()\\n return self.backtrack(dict())\",\n \"def resolve_internal(g, path):\\n n = len(g)\\n for step in range(1, n):\\n for k in range(n):\\n for i in range(n):\\n for j in range(n):\\n cost = g[i][k][step-1] * g[k][j][0]\\n if g[i][j][step] < cost:\\n g[i][j][step] = cost\\n path[i][j][step] = k\\n if i == j and g[i][i][step] > 1.01:\\n return recover_path(path, n, step, i, j)\\n return None\",\n \"def solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\\n\\n print(\\\"Solving random problems with solver %s\\\\n\\\" % solver)\\n\\n # Define statistics to record\\n std_solve_time = np.zeros(len(n_vec))\\n avg_solve_time = np.zeros(len(n_vec))\\n min_solve_time = np.zeros(len(n_vec))\\n max_solve_time = np.zeros(len(n_vec))\\n\\n n_prob = len(n_vec)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n # Add OSQP solve times statistics\\n avg_osqp_solve_time = np.zeros(len(n_vec))\\n\\n # reset random seed\\n np.random.seed(seed)\\n\\n for i in range(n_prob):\\n\\n # Get dimensions\\n n = n_vec[i]\\n m = m_vec[i]\\n p = p_vec[i]\\n\\n print(\\\"problem n = %i, m = %i, p = %i\\\" % (n, m, p))\\n\\n # Define vector of cpu times\\n solve_time_temp = np.zeros(repeat)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n osqp_solve_time_temp = np.zeros(repeat)\\n\\n for j in tqdm(range(repeat)):\\n # for j in range(repeat):\\n\\n # Generate random vector of indeces\\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\\n\\n # Generate random Matrices\\n Pt = spa.random(n, n, density=dns_level)\\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\\n q = sp.randn(n)\\n A = spa.random(m, n, density=dns_level)\\n u = 2 + sp.rand(m)\\n l = -2 + sp.rand(m)\\n\\n # Enforce [0, 1] bounds on variables\\n i_l = np.zeros(p)\\n i_u = np.ones(p)\\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\\n\\n if solver == 'gurobi':\\n # Solve with gurobi\\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\\n verbose=False, Threads=1)\\n if res_gurobi.status != 'optimal':\\n import ipdb\\n ipdb.set_trace()\\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\\n\\n elif solver == 'miosqp':\\n # Define problem settings\\n miosqp_settings = {\\n # integer feasibility tolerance\\n 'eps_int_feas': 1e-03,\\n # maximum number of iterations\\n 'max_iter_bb': 1000,\\n # tree exploration rule\\n # [0] depth first\\n # [1] two-phase: depth first until first incumbent and then best bound\\n 'tree_explor_rule': 1,\\n # branching rule\\n # [0] max fractional part\\n 'branching_rule': 0,\\n 'verbose': False,\\n 'print_interval': 1}\\n\\n osqp_settings = {'eps_abs': 1e-03,\\n 'eps_rel': 1e-03,\\n 'eps_prim_inf': 1e-04,\\n 'verbose': False}\\n\\n model = miosqp.MIOSQP()\\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\\n miosqp_settings,\\n osqp_settings)\\n res_miosqp = model.solve()\\n\\n # DEBUG (check if solutions match)\\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\\n # import ipdb; ipdb.set_trace()\\n#\\n # import ipdb; ipdb.set_trace()\\n\\n if res_miosqp.status != miosqp.MI_SOLVED:\\n import ipdb\\n ipdb.set_trace()\\n \\n # Solution time \\n solve_time_temp[j] = 1e3 * res_miosqp.run_time\\n\\n # Store OSQP time in percentage\\n if solver == 'miosqp':\\n osqp_solve_time_temp[j] = \\\\\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\\n\\n # Get time statistics\\n std_solve_time[i] = np.std(solve_time_temp)\\n avg_solve_time[i] = np.mean(solve_time_temp)\\n max_solve_time[i] = np.max(solve_time_temp)\\n min_solve_time[i] = np.min(solve_time_temp)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\\n\\n # Create pandas dataframe for the results\\n df_dict = {'n': n_vec,\\n 'm': m_vec,\\n 'p': p_vec,\\n 't_min': min_solve_time,\\n 't_max': max_solve_time,\\n 't_avg': avg_solve_time,\\n 't_std': std_solve_time}\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\\n\\n timings = pd.DataFrame(df_dict)\\n\\n return timings\",\n \"def solve(self, **kwargs):\\n\\n sorted_compute_nodes = sorted(\\n self.physical.compute_nodes,\\n key=lambda x: self.physical.cores(x) * 1000 + self.physical.memory(x),\\n reverse=True,\\n )\\n\\n for n_partitions_to_try in range(\\n self.lower_bound(), len(sorted_compute_nodes) + 1\\n ):\\n\\n # partitioning of virtual nodes in n_partitions_to_try partitions\\n k_partition = get_partitions(\\n self.virtual.g, n_partitions=n_partitions_to_try\\n )\\n\\n # subset of hosts of size n_partitions_to_try\\n chosen_physical = sorted_compute_nodes[:n_partitions_to_try]\\n\\n #\\n # check if the partitioning is a feasible solution\\n #\\n try:\\n # virtual nodes to physical nodes assignment\\n res_node_mapping = {}\\n\\n # iterate over each pair (physical_node i, virtual nodes assigned to i)\\n for physical_node, assigned_virtual_nodes in zip(\\n chosen_physical, k_partition\\n ):\\n # keep track of the node physical resources used\\n cores_used = memory_used = 0\\n # check if node resources are not exceeded:\\n for virtual_node in assigned_virtual_nodes:\\n # cpu cores\\n cores_used += self.virtual.req_cores(virtual_node)\\n if self.physical.cores(physical_node) < cores_used:\\n raise NodeResourceError(physical_node, \\\"cpu cores\\\")\\n # memory\\n memory_used += self.virtual.req_memory(virtual_node)\\n if self.physical.memory(physical_node) < memory_used:\\n raise NodeResourceError(physical_node, \\\"memory\\\")\\n # assign the virtual nodes to a physical node\\n res_node_mapping[virtual_node] = physical_node\\n\\n #\\n # virtual links to physical links assignment\\n #\\n res_link_mapping = {}\\n rate_used = defaultdict(int)\\n\\n # iterate over each virtual link between two virtual nodes not mapped on the same physical machine\\n for (u, v) in (\\n (u, v)\\n for (u, v) in self.virtual.sorted_edges()\\n if res_node_mapping[u] != res_node_mapping[v]\\n ):\\n\\n res_link_mapping[(u, v)] = []\\n\\n # physical nodes on which u and v have been placed\\n phy_u, phy_v = res_node_mapping[u], res_node_mapping[v]\\n\\n # for each link in the physical path\\n for (i, j, device_id) in self.physical.find_path(\\n phy_u,\\n phy_v,\\n req_rate=self.virtual.req_rate(u, v),\\n used_rate=rate_used,\\n ):\\n # else update the rate\\n rate_used[(i, j, device_id)] += self.virtual.req_rate(u, v)\\n\\n res_link_mapping[(u, v)].append((i, device_id, j))\\n\\n # build solution from the output\\n self.solution = Solution.build_solution(\\n self.virtual, self.physical, res_node_mapping, res_link_mapping\\n )\\n self.status = Solved\\n return Solved\\n\\n except (NodeResourceError, NoPathFoundError):\\n # unfeasible, increase the number of partitions to be used\\n pass\\n else:\\n self.status = Infeasible\\n return Infeasible\",\n \"def computeForces(self, neighbors=[]): #computing forces to drive the agents and avoid collisions \\n if not self.atGoal:\\n if self.entry_state % 2 == 0 and len(self.entrancex) > 0 and self.id != 4 : #checks if assigned curve is entry and switches to state 1 to follow entry bezier curve\\n time2=0.5 # time used to calculate driving force \\n self.local_goal = [self.entrancex[0], self.entrancey[0]] #assigning waypoint as goal\\n self.rel_posi = self.local_goal - self.pos #calculating relative position between agents\\n self.n_bez = (self.rel_posi + (self.prefspeed*time2))/(abs(self.rel_posi + (self.prefspeed*time2))) #calculating direction vector\\n self.F = ((max(self.timehor - time2/100, 0)/time2)*self.n_bez) #driving force\\n self.entrancex = np.delete(self.entrancex,0) #eliminating the used waypoints from the list \\n self.entrancey = np.delete(self.entrancey,0) #eliminating the used waypoints from the list \\n \\n elif self.force_state == 1 and (abs(self.pos[0] - self.goal[0]) >400 or abs(self.pos[1] - self.goal[1]) >400): #checks if force-based navigation is assigned, switches to state 2\\n self.F = (self.gvel-self.vel)/self.ksi #driving force\\n for neighbor in neighbors:\\n if neighbor.id != self.id: #and not neighbor.atGoal: \\n distSq = (neighbor.pos-self.pos).dot(neighbor.pos-self.pos)\\n #print(distSq, self.dhorSq)\\n if distSq < self.dhorSq: # neighbor is inside the sensing radius\\n tau = self.ttc(neighbor)\\n #print(tau, self.timehor)\\n if tau < self.timehor: # will the two agents collide in less than timehor?\\n dir = self.pos + self.vel*tau - neighbor.pos - neighbor.vel*tau \\n length = sqrt(dir.dot(dir))\\n if length > 0:\\n dir = dir/length # the direction of the force\\n mag = (self.timehor - tau)/(tau + 1e-6) # the magnitude of the force\\n self.F += mag*dir # add the force\\n \\n else: #state 3 - following the exit bezier curve\\n time2=0.5 # time used to calculate driving force\\n self.local_goal = [self.exitx[0], self.exity[0]]\\n if abs(sqrt((self.local_goal - self.pos).dot((self.local_goal - self.pos)))) >10: #to reach first point of exit curve from agents previous state position\\n self.F = ((self.local_goal - self.pos)/(sqrt((self.local_goal - self.pos).dot((self.local_goal - self.pos) )))*self.prefspeed)/self.ksi\\n else:\\n self.rel_posi = self.local_goal - self.pos #calculating relative position between agents\\n self.n_bez = (self.rel_posi + (self.prefspeed*time2))/(abs(self.rel_posi + (self.prefspeed*time2)))\\n self.F = ((max(self.timehor - time2/100, 0)/time2)*self.n_bez)\\n #print(self.pos, self.local_goal)\\n if len(self.exitx) > 1 :\\n self.exitx = np.delete(self.exitx,0)\\n self.exity = np.delete(self.exity,0)\",\n \"def refugia_adj_5_full_2_iter3 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def main():\\n A = np.array([\\n [40, 36],\\n [36, 45]\\n ])\\n b = np.array([-64, -66])\\n c = 27\\n solve(Task1TargetFunction(A, b, c))\",\n \"def Optimizer(r_grasp,PAM_r, PAM_s, object_s, object_f, object_params, phi, r_max, walls, obstacles, obstacles_PAM, current_leg, n, n_p, v_max, force_max, legs, dt):\\n global action_push_pull, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\\n # assigning cost of changing from one leg to another based on the distance to the desired pose\\n cost_ChangeLeg = 1\\n dz_final = np.sqrt((object_s.x - object_f.x) ** 2 + (object_s.y - object_f.y) ** 2)\\n if dz_final < 1:\\n cost_ChangeLeg = 10\\n elif dz_final < 2:\\n cost_ChangeLeg = 20\\n else:\\n cost_ChangeLeg = 10\\n\\n # assigning weight for cost of predicted repositioning and cost of robot motion\\n w_cost_reposition = 40\\n w_cost_motion = 10\\n\\n # finding object's leg cordinates\\n object_leg = find_corners(object_s.x, object_s.y, object_s.phi, object_params[7], object_params[8])\\n\\n # initialization (initializeing cost to infinity)\\n cost = [float('inf'), float('inf'), float('inf'), float('inf')]\\n cost_legchange = [0, 0, 0, 0]\\n cost_PAM = [[0, 0],[0, 0],[0, 0],[0, 0]]\\n cost_manipulation = [0, 0, 0, 0]\\n cost_motion = [0, 0, 0, 0]\\n force = [0, 0, 0, 0]\\n path = [[[], []], [[], []], [[], []], [[], []]]\\n planned_path_w = [[],[],[],[]]\\n PAM_g = [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]\\n command = [[], [], [], []]\\n des = [[], [], [], [], []]\\n PAM_goal = state()\\n\\n # find the nominal trajectory for manipulation\\n theta = nominal_traj([object_s.x,object_s.y,object_s.phi], [object_f.x,object_f.y,object_f.phi], v_max, walls, obstacles, n, dt)\\n\\n # itterate through each leg to find the leg with minimum cost\\n for leg in range(4):\\n phi_linear = theta\\n psi_linear = [theta[k] + phi[leg] for k in range(len(theta))]\\n \\t# find the cost and required force for manipulation for the leg\\n force[leg], cost_manipulation[leg], planned_path_w[leg], command[leg], des= OptTraj([object_s.x, object_s.y, object_s.phi, object_s.xdot, object_s.ydot, object_s.phidot], [object_f.x, object_f.y, object_f.phi, object_f.xdot, object_f.ydot, object_f.phidot], v_max, walls, obstacles, object_params[0:4], object_params[4:7], phi_linear, psi_linear, force_max, r_max[leg], n, dt, object_leg[leg])\\n \\t# adding cost of changing leg\\n if leg != current_leg:\\n cost_legchange[leg] = cost_ChangeLeg\\n # adding cost of PAM motion to PAM goal pose\\n phi0 = np.arctan2(object_leg[leg][1]-object_s.y,object_leg[leg][0]-object_s.x)\\n # finding the better option between pulling and pushing for each leg, with the same manipulation plan\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost_PAM[leg][push_pull], path[leg][push_pull], command_pam, goal_orientation = OptPath([PAM_s.x, PAM_s.y, PAM_s.phi], PAM_g[leg][push_pull], walls, obstacles_PAM, n_p, dt)\\n if cost_PAM[leg][push_pull]!= float(\\\"inf\\\"):\\n PAM_s_sim = copy.deepcopy(PAM_s)\\n PAM_s_sim.x, PAM_s_sim.y, PAM_s_sim.phi = [PAM_r * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], PAM_r * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n # adding cost of predicted re-positionings\\n n_transition = traj_simulation(copy.deepcopy(PAM_s_sim), copy.deepcopy(object_s), force[leg], legs, leg, command[leg])\\n # print(n_transition)\\n cost_PAM[leg][push_pull] += w_cost_reposition*n_transition\\n cost_motion[leg] += min(cost_PAM[leg])*w_cost_motion\\n action_push_pull[leg] = np.argmin(cost_PAM[leg])\\n else:\\n phi0 = np.arctan2(force[leg][0][1], force[leg][0][0])\\n for push_pull in [0,1]:\\n PAM_g[leg][push_pull] = [r_grasp * np.cos(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][0], r_grasp * np.sin(phi0) * np.sign(push_pull * 2 - 1) + object_leg[leg][1], np.pi * push_pull + phi0]\\n cost = [cost_legchange[leg] + cost_motion[leg] + cost_manipulation[leg] for leg in range(4)]\\n\\n if min(cost) < float(\\\"inf\\\"):\\n \\t[min_index, min_value] = [np.argmin(cost), min(cost)]\\n \\t# Finding the grasping goal pose based on the selected plan\\n \\tphi0 = np.arctan2(object_leg[min_index][1]-object_s.y,object_leg[min_index][0]-object_s.x)\\n \\tgrasping_goal = [PAM_r * np.cos(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][0], PAM_r * np.sin(phi0) * np.sign(action_push_pull[min_index] * 2 - 1) + object_leg[min_index][1], np.pi * action_push_pull[min_index] + phi0]\\n \\tPAM_goal = state()\\n \\tPAM_goal.x, PAM_goal.y, PAM_goal.phi = PAM_g[min_index][action_push_pull[min_index]]\\n \\tobject_path_planned = Path()\\n \\tobject_path_planned.header.frame_id = 'frame_0'\\n \\tfor i in range(len(planned_path_w[min_index])):\\n \\t\\tpose = PoseStamped()\\n \\t\\tpose.pose.position.x = planned_path_w[min_index][i][0]\\n \\t\\tpose.pose.position.y = planned_path_w[min_index][i][1]\\n \\t\\tpose.pose.position.z = 0\\n \\t\\tobject_path_planned.poses.append(pose)\\n\\n \\tPAM_path_planned = Path()\\n \\tPAM_path_planned.header.frame_id = 'frame_0'\\n \\tif min_index != current_leg:\\n \\t\\tfor i in range(len(path[min_index][action_push_pull[min_index]])):\\n \\t\\t\\tpose = PoseStamped()\\n \\t\\t\\tpose.pose.position.x, pose.pose.position.y, pose.pose.orientation.z =path[min_index][action_push_pull[min_index]][i]\\n \\t\\t\\tPAM_path_planned.poses.append(pose)\\n else:\\n \\tmin_index = 5\\n \\tmin_value = float(\\\"inf\\\")\\n if 0 < min_index and min_index <= 4:\\n force_d = force[min_index][0]\\n else:\\n force_d = [0,0,0]\\n\\n return cost ,min_index, force_d, PAM_goal, grasping_goal, object_path_planned, PAM_path_planned\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n #Creamos las estructuras de datos necesarias (priority queue y set)\\n openNodes = util.PriorityQueue()\\n closedNodes = set([])\\n\\n #Guardamos el nodo inicial\\n node = Node(problem.getStartState(), '', 0, None)\\n\\n #Calculamos funcion heuristica y el coste acumulado para sacar la funcion de evaluacion del nodo inicial\\n fn = problem.getCostOfActions(node.path) + nullHeuristic(node.name, problem);\\n\\n #Lo metemos en la cola con su funcion de evaluacion como prioridad\\n openNodes.push(node, fn)\\n\\n #Iteramos para cada nodo\\n while True:\\n if openNodes.isEmpty():\\n break #ERROR: throw exception\\n else :\\n #sacamos el nodo de arriba de la cola\\n node = openNodes.pop()\\n if problem.isGoalState(node.name): #Comprobamos si el nodo es Goal. Si lo es terminamos.\\n break\\n else: #Expandimos los nodos sucesores del nodo si no estan en closed\\n if nodeIsClosed(node, closedNodes) is False:\\n for successor in problem.getSuccessors(node.name):\\n n, p, c = successor\\n succNode = Node(n, p, c, node)\\n if nodeIsClosed(succNode, closedNodes) is False:\\n fn = problem.getCostOfActions(findPath(succNode)) + nullHeuristic(succNode.name, problem);\\n openNodes.push(succNode, fn)\\n #Metemos el nodo en closed\\n closedNodes.add(node)\\n\\n #Devolvemos el camino al Goal\\n return findPath(node)\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n path_to_point = {}\\n cost_to_point = {}\\n\\n # Get the start node\\n start_node = problem.getStartState()\\n fringe_node = [start_node]\\n path_to_point[start_node] = []\\n cost_to_point[start_node] = problem.getCostOfActions(path_to_point[start_node])\\n\\n goal_found = False\\n\\n while(not goal_found):\\n #for i in range(100): \\n nodes_to_expand = set()\\n # get max value node in the fringe node\\n min_val = float(\\\"inf\\\")\\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] < min_val:\\n min_val = cost_to_point[one_node]\\n \\n for one_node in fringe_node:\\n # Compute the cost to reach a node\\n if cost_to_point[one_node] == min_val:\\n nodes_to_expand.add(one_node)\\n fringe_node.remove(one_node)\\n\\n # Expand the fringe node \\n for one_node in nodes_to_expand:\\n path_to_parent = path_to_point[one_node]\\n for nxt_node in problem.getSuccessors(one_node):\\n pos = nxt_node[0]\\n mv = nxt_node[1]\\n # check if point already present in path to point\\n prev_cost = float(\\\"inf\\\")\\n if pos in cost_to_point:\\n prev_cost = cost_to_point[pos]\\n new_path = path_to_parent + [mv]\\n if prev_cost > problem.getCostOfActions(new_path):\\n path_to_point[pos] = new_path\\n cost_to_point[pos] = problem.getCostOfActions(new_path)\\n fringe_node.append(pos)\\n\\n # Check if destination is reached in the fringe node\\n for one_node in fringe_node:\\n if problem.isGoalState(one_node):\\n final_node = one_node\\n goal_found = True\\n break\\n \\n #print(len(fringe_node))\\n print(final_node)\\n print(path_to_point[final_node])\\n return path_to_point[final_node] \\n\\n util.raiseNotDefined()\",\n \"def astar(G,s,g,cost=(lambda v,w:1),heuristic=(lambda v:0),verbose=1):\\n if not callable(g):\\n gtest = lambda x,goal=g: x==g\\n else:\\n gtest = g\\n d = dict((v,float('inf')) for v in G.nodes())\\n p = dict((v,None) for v in G.nodes())\\n d[s] = 0\\n Q = [(0,0,s)] #each element is a tuple (f,-c,v) with f=c + heuristic(v), c=cost from start, v=vertex\\n nnodes = 0\\n while len(Q) > 0:\\n f,minus_c,v = heapq.heappop(Q) #get the element in the queue with the least value of c\\n nnodes += 1\\n if gtest(v):\\n #found a path\\n if verbose: print(\\\"A* succeeded in\\\",nnodes,\\\"iterations\\\")\\n return predecessor_traverse(p,s,v),d,p\\n for w in G.neighbors(v):\\n dcand = d[v] + cost(v,w) #this is the cost of going through v to w\\n if dcand < d[w]:\\n #going through v is optimal\\n #if the predecessor of w is not None, then we'll have to adjust the heap\\n if p[w] is not None:\\n Q = [(f,c,x) for (f,c,x) in Q if x is not w]\\n heapq.heapify(Q)\\n d[w] = dcand\\n p[w] = v\\n #put w back on the queue, with the heuristic value as its priority\\n heapq.heappush(Q,(dcand+heuristic(w),-dcand,w))\\n #no path found\\n if verbose: print(\\\"A* failed in\\\",nnodes,\\\"iterations\\\")\\n return None,d,p\",\n \"def heuristic_main(data):\\n arcs, nodes, periods = data.arcs.size, data.nodes, data.periods\\n commodities = data.commodities\\n arc_origins, arc_destinations = get_2d_index(data.arcs, nodes)\\n\\n model = make_model(data)\\n\\n open_arcs = np.zeros((periods, arcs), dtype=np.double)\\n\\n objective = 0.\\n\\n for t in xrange(periods):\\n fixed_cost, variable_cost = data.fixed_cost[t, :], data.variable_cost\\n demand = data.demand[t, :]\\n flow, arc_open = model._flow, model._arc_open\\n\\n for arc in xrange(arcs):\\n i, j = arc_origins[arc], arc_destinations[arc]\\n con_name = 'cap_{}-{}'.format(i, j)\\n con = model.getConstrByName(con_name)\\n # We pay for arcs that are not already open\\n if arc_open[arc].lb == 0:\\n arc_open[arc].obj = fixed_cost[arc]\\n for c in xrange(commodities):\\n model.chgCoeff(con, flow[c, arc], demand[c])\\n flow[c, arc].obj = variable_cost[arc] * demand[c]\\n model.optimize()\\n if model.status == grb.GRB.status.INFEASIBLE:\\n model.computeIIS()\\n print 'model is infeasible'\\n model.write(str(model.ModelName) + '_{}.ilp'.format(t))\\n if model.SolCount > 0:\\n objective += model.objVal\\n # If we use an arc and it has not been opened before, we should\\n # mark it as open now, and keep it open all along\\n for count, var in enumerate(arc_open):\\n if var.X > 0.1:\\n var.lb = 1.\\n var.obj = 0.\\n if np.sum(open_arcs[:t, count]) < 10e-5:\\n open_arcs[t, count] = 1.\\n print 'Period : {} Objective value: {}'.format(t, objective)\\n\\n return objective, open_arcs\",\n \"def solve(self, Dn, Dm, c, b):\\n m =self.m\\n n =self.n\\n kA =self.kA\\n iA =self.iA\\n A =self.A\\n kAt=self.kAt\\n iAt=self.iAt\\n At =self.At\\n kQ =self.kQ\\n iQ =self.iQ\\n Q =self.Q\\n _max =self.max\\n\\n _pass=0\\n consistent = True\\n\\n m2 = m+n\\n\\n # Replaced MALLOC & REALLOC with np.empty\\n if self.y_k is None:\\n self.y_k = np.empty(m)\\n else:\\n self.y_k.resize(m)\\n if self.x_k is None:\\n self.x_k = np.empty(n)\\n else:\\n self.x_k.resize(n)\\n if self.r is None:\\n self.r = np.empty(m)\\n else:\\n self.r.resize(m)\\n if self.s is None:\\n self.s = np.empty(n)\\n else:\\n self.s.resize(n)\\n if self.z is None:\\n self.z = np.empty(m2)\\n else:\\n self.z.resize(m2)\\n if self.Qx is None:\\n self.Qx = np.empty(n)\\n else:\\n self.Qx.resize(n)\\n\\n y_k = self.y_k\\n x_k = self.x_k\\n r = self.r\\n s = self.s\\n z = self.z\\n Qx = self.Qx\\n iperm = self.iperm\\n\\n maxbc = max(np.abs(b).max(), np.abs(c).max()) + 1\\n maxrs = HUGE_VAL\\n\\n while True:\\n\\n if _pass == 0:\\n for j in range(n):\\n z[iperm[j]] = c[j]\\n for i in range(m):\\n z[iperm[n+i]] = b[i]\\n else:\\n for j in range(n):\\n z[iperm[j]] = s[j]\\n for i in range(m):\\n z[iperm[n+i]] = r[i]\\n\\n consistent = self.rawsolve()\\n\\n if _pass == 0:\\n for j in range(n):\\n x_k[j] = z[iperm[j]]\\n for i in range(m):\\n y_k[i] = z[iperm[n+i]]\\n else:\\n for j in range(n):\\n x_k[j] = x_k[j] + z[iperm[j]]\\n for i in range(m):\\n y_k[i] = y_k[i] + z[iperm[n+i]]\\n\\n smx(m, n, A, kA, iA, x_k,r)\\n smx(n, m, At,kAt,iAt,y_k,s)\\n smx(n, n, Q ,kQ ,iQ ,x_k,Qx)\\n\\n for j in range(n):\\n s[j] = c[j] - (s[j] - Dn[j]*x_k[j] - _max*Qx[j])\\n for i in range(m):\\n r[i] = b[i] - (r[i] + Dm[i]*y_k[i])\\n\\n oldmaxrs = maxrs\\n maxrs = max(np.abs(r).max(), np.abs(s).max())\\n\\n # --- for tuning purposes ---\\n if (self.verbose>2 and _pass>0):\\n print(\\\"refinement({:3d}): {:8.2e} {:8.2e} {:8.2e}\\\".format(\\n _pass, np.abs(s).max(), np.abs(r).max(), maxrs/maxbc ))\\n\\n _pass += 1\\n if maxrs > (1.0e-10*maxbc) and maxrs < (oldmaxrs/2):\\n continue\\n else:\\n break\\n\\n if maxrs > oldmaxrs and _pass > 1:\\n for j in range(n):\\n x_k[j] = x_k[j] - z[iperm[j]]\\n for i in range(m):\\n y_k[i] = y_k[i] - z[iperm[n+i]]\\n\\n \\t#----------------------------------------------------------\\n \\t#| overwrite input with output\\n\\n for j in range(n):\\n c[j] = x_k[j]\\n for i in range(m):\\n b[i] = y_k[i]\\n\\n return consistent\",\n \"def refugia_adj_4_growth(params, ns):\\n #12 parameters \\n nu1, nuA0, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nuA_func = lambda t: nuA0 * (nuA/nuA0)**(t/T1a) \\n nu_T1_func = lambda t: [nu1, nuA_func(t)]\\n fs.integrate(nu_T1_func, T1a)\\n ## Population function and migration matrix for T1b\\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\\n nu_T1 = [nu1, nuA]\\n fs.integrate(nu_T1, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1, nu2, nu3]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1, nu2, nu3]\\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def precompute_options_values(adj, skills, g):\\n rewards = np.zeros((4604, len(skills)))\\n dests = np.zeros((4604, len(skills)), dtype='int')\\n discounts = np.zeros((4604, len(skills))) #Containing prefactors g **(avg_len)\\n skill_vals = []\\n skill_Zs = []\\n adj = adjusted_adj_list_4\\n for skill in skills:\\n out = value_iteration(adj, [], skill[1], g=g, goal=skill[0])\\n skill_vals.append(out[0])\\n skill_Zs.append(out[1])\\n print skill_vals, skill_Zs\\n for s_index, skill in enumerate(skills):\\n for index in adj.keys():\\n dests[index, s_index] = skill[0]\\n out = option(index, skill[0], skill[1], g,\\n vals=skill_vals[s_index], Z=skill_Zs[s_index], n_repeat=30)\\n if out[0] == None: #Skill is disconnected from destination\\n dests[index, s_index] = index\\n rewards[index, s_index] = -1\\n discounts[index, s_index] = g\\n else:\\n rewards[index, s_index] = out[1]\\n discounts[index, s_index] = np.power(g, out[2])\\n print 'Done skill {}'.format(dests, rewards, discounts)\\n skill_vals_2 = discounts * 0\\n skill_Zs_2 = discounts * 0\\n for index in adj.keys():\\n for s_index in range(len(skills)):\\n skill_vals_2[index, s_index] = skill_vals[s_index][index]\\n skill_Zs_2[index, s_index] = skill_Zs[s_index][index]\\n dests = np.array(dests, dtype='int')\\n return rewards, dests, discounts, skill_vals_2, skill_Zs_2\",\n \"def compute_likelihood_given(O_a, skills, beta, g, theta, vals, Zs, povs):\\n O_os, P_os = gen_option_trajectories(O_a, skills, beta, g, theta, vals, Zs, povs) #Generate all option-trajectories\\n if povs != []:\\n rewards, dests, discounts, _, _ = povs\\n probs = []\\n for index, O_o in enumerate(O_os): #For option-trajectory in option-trajectories\\n state = O_a[0] #Initial state\\n prob = 0\\n for o_index, o in enumerate(O_o): #For option in option-trajectory (either state to go to or [goal, beta_k] pair\\n #Now compute the prob of choosing the option o that was actually chosen\\n if type(o) != list and o == theta:\\n to_add = np.exp(beta*20) / Zs[state]\\n state = o\\n elif type(o) != list:\\n to_add = np.exp(beta*(-1 + g*vals[o])) / Zs[state]\\n state = o\\n else: #Compound option\\n Q = (rewards[tuple([state, o_dict[o[0]]])] +\\n vals[dests[tuple([state, o_dict[o[0]]])]]*discounts[tuple([state, o_dict[o[0]]])])\\n # out = option(state, o[0], o[1], g, povs[3][:, o_dict[o[0]]], povs[4][:, o_dict[o[0]]], 10) #Gives samples, discounted rewards, lengths\\n # to_add = np.exp(beta*(out[1] + (pow(g,out[2]))*vals[o[0]])) / Zs[state]\\n to_add = np.exp(beta*Q) / Zs[state]\\n state = o[0]\\n if prob == 0:\\n prob = to_add\\n else:\\n prob *= to_add\\n if prob == 0:\\n print O_a\\n print '??'\\n probs.append(prob)\\n return np.sum(probs)\",\n \"def refugia_adj_4(params, ns):\\n #11 parameters \\n nu1, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nu_T1 = [nu1, nuA]\\n fs.integrate(nu_T1, T1a)\\n ## Population function and migration matrix for T1b\\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\\n fs.integrate(nu_T1, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1, nu2, nu3]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1, nu2, nu3]\\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def random_choose_candidate_solve (x_v, C, A, S, budgets, start_time, verbose=True):\\n A = A.copy()\\n edges_removed = []\\n budget = np.max(budgets)\\n results_info = []\\n for i in range(budget):\\n if (len(C) == 0):\\n # Maximum balance achieved -> budget high.\\n results_info = update_res(results_info, budgets, time.time() - start_time, len(x_v.nonzero()[0]) - len(S))\\n break\\n while (True):\\n try:\\n e_chosen = C[np.random.choice(range(len(C)))]\\n except:\\n results_info = update_res(results_info, budgets, time.time() - start_time, len(x_v.nonzero()[0]) - len(S))\\n return results_info, np.nonzero(x_v)[0], A, edges_removed\\n if (is_connected_postdel(delete_edge(A.copy(), e_chosen), e_chosen)):\\n break\\n else:\\n C.remove(e_chosen)\\n edges_removed.append(e_chosen)\\n try:\\n ue = node_out (x_v, e_chosen)\\n except:\\n print(e_chosen, \\\" is not on the periphery\\\")\\n return\\n A = delete_edge (A, e_chosen)\\n x_v[ue] = find_label (A, ue, x_v)\\n C.remove(e_chosen)\\n if (verbose):\\n print(e_chosen, \\\" is chosen\\\")\\n if (x_v[ue] != 0):\\n C, C_i = update_chosen(ue, x_v, A, C)\\n # if (verbose):\\n # print(\\\"Edges added to C: \\\", C_i)\\n C = C + C_i\\n if (len(edges_removed) in budgets):\\n select_time = time.time() - start_time\\n results_info.append({\\\"Budget\\\": len(edges_removed), \\\"RT\\\": select_time, \\\"Delta\\\": len(np.nonzero(x_v)[0]) - len(S)})\\n if (verbose):\\n print(\\\"\\\\n\\\")\\n return results_info, np.nonzero(x_v)[0], A, edges_removed\",\n \"def option(start, destination, beta, g, vals=-1*np.ones((4604)), Z=-1*np.ones((4604)),\\n n_repeat=10):\\n if vals[0] == -1: #Default value\\n vals, Z = value_iteration(adj_list, [], beta, g, 0, destination)\\n else:\\n vals = vals[:]\\n Z = Z[:]\\n states_chains = []\\n for _ in range(n_repeat):\\n states = birl_agent(start, destination, [], beta, g, 0, vals=vals, Z=Z)\\n states_chains.append(states)\\n if states_chains[0] == None: #States are disconnected\\n return None, -1, g\\n else:\\n # print states_chains\\n return states_chains, np.mean([expsum(len(state), g) for state in states_chains]), np.mean([len(state) for state in states_chains])\",\n \"def solve_tsp(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n drop_off_dict = {}\\n car_path = []\\n home_map = {}\\n home_indexes = convert_locations_to_indices(list_of_homes, list_of_locations)\\n\\n start = list_of_locations.index(starting_car_location)\\n graph, msg = adjacency_matrix_to_graph(adjacency_matrix)\\n all_paths = dict(nx.all_pairs_dijkstra(graph))\\n\\n start_in_home = start in home_indexes\\n if start in home_indexes:\\n home_indexes.remove(start)\\n home_indexes.insert(0, start)\\n home_count = 0;\\n\\n for home in home_indexes:\\n #print(home, end = \\\" \\\")\\n home_map[home_count] = home\\n home_count += 1\\n # Instantiate the data problem.\\n #print(len(home_map))\\n data = create_data_model(home_indexes, 0)\\n\\n # Create the routing index manager.\\n manager = pywrapcp.RoutingIndexManager(len(data['locations']),\\n data['num_vehicles'], data['depot'])\\n\\n #print(manager.NodeToIndex(15))\\n # Create Routing Model.\\n routing = pywrapcp.RoutingModel(manager)\\n\\n def distance_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n #print(home_map[to_index], end = \\\" \\\")\\n from_index = manager.IndexToNode(from_index)\\n to_index = manager.IndexToNode(to_index)\\n dist_to = all_paths.get(home_map[from_index])[0][home_map[to_index]]\\n #if from_index >= 25 or to_index >= 25:\\n # print(\\\"from\\\" if from_index >= 25 else \\\"to\\\", end = \\\" \\\")\\n #dist_to = all_paths[from_index][0][to_index]\\n return dist_to\\n\\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\\n\\n # Define cost of each arc.\\n routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)\\n\\n # Setting first solution heuristic.\\n \\\"\\\"\\\"\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.first_solution_strategy = (\\n routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)\\n \\\"\\\"\\\"\\n\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.local_search_metaheuristic = (\\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\\n search_parameters.time_limit.seconds = 3\\n #search_parameters.log_search = True\\n\\n # Solve the problem.\\n assignment = routing.SolveWithParameters(search_parameters)\\n\\n # if assignment:\\n # print_solution(manager, routing, assignment)\\n # Print solution on console.\\n\\n if start in home_indexes:\\n drop_off_dict[start] = [start]\\n\\n\\n index = routing.Start(0)\\n car_path.append(start)\\n\\n while not routing.IsEnd(index):\\n previous_index = manager.IndexToNode(index)\\n index = assignment.Value(routing.NextVar(index))\\n\\n car_path.pop();\\n to_index = manager.IndexToNode(index)\\n path_to = all_paths.get(home_map[previous_index])[1][home_map[to_index]]\\n drop_off_dict[home_map[to_index]] = [home_map[to_index]]\\n #print(to_index, end = ' ')\\n car_path.extend(path_to)\\n #route_distance += routing.GetArcCostForVehicle(previous_index, index, 0)\\n # for i in car_path:\\n # print(i)\\n if start in drop_off_dict.keys() and not start_in_home:\\n drop_off_dict.pop(start, None)\\n\\n return car_path, drop_off_dict\",\n \"def cost_state(s,state_considered,L,Q,gamma):\\n if s==s.goal:\\n return 0\\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 theta_Q_theta=np.dot(theta.T,np.dot(Q,theta))\\n v=vertices_cube(s.n)\\n J={}\\n for index in range(v.shape[0]):\\n p=v[index,:].reshape(s.n,1)\\n J[index]=0\\n for row in range(s.n):\\n for k in range(s.n):\\n J[index]+=np.asscalar(p[row]*p[k]*GLG[row,k]+p[row]*p[k]*theta_Q_theta[row,k])\\n return max(J.values())+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 refugia_adj_5_full_2_iter4 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def run_two_opt_annealing(tsp_file, T, scheme, N_sim, max_chain_length=100000, c=.95):\\n # create empty lists for to be stored values\\n best_routes, costs, cost_lists = [], [], []\\n\\n adjacency_matrix = make_matrix(tsp_file)\\n\\n for _ in range(N_sim):\\n # generate random initial route\\n x = list(range(len(adjacency_matrix)))\\n init_route = random.sample(x,len(x))\\n \\n # find best route with SA algorithm\\n best_route, cost_list, accept_list = two_opt_annealing(T, scheme, init_route, adjacency_matrix, max_chain_length, c)\\n\\n # append all values from simulation to lists\\n costs.append(calculate_cost(best_route,adjacency_matrix)[1])\\n best_routes.append(best_route)\\n cost_lists.append(cost_list)\\n\\n return best_routes, costs, cost_lists\",\n \"def Option3_routing(self, S, D, L):\\n if self.has_path(S, D): \\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \\n Opt_path = Shortest_path\\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\\n return path_cost_with_concave_function, Opt_path\\n while len(Shortest_path) != 0:\\n path_cost = self.additive_path_cost(Shortest_path, 'w') \\n #self.logger.info('Path cost - %d', path_cost)\\n if path_cost <= L:\\n \\\"\\\"\\\"go to path cost with weighted sum\\\"\\\"\\\"\\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\\n self.G = self.rm_edge_constraint(path_cost_with_concave_function) # remove all links where the concave link is greater than PathConcave_cost \\n Opt_path = Shortest_path\\n if self.has_path(S, D):\\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\\n else:\\n Shortest_path = [] \\n else:\\n break \\n else:\\n self.logger.info('No path from %s to %s', S, D)\\n Opt_path = []\\n path_cost_with_concave_function = 0\\n return path_cost_with_concave_function, Opt_path\",\n \"def consolidation_heuristics(to_print = False):\\n # Instantiate the data problem.\\n data = create_data_model()\\n # Create the routing index manager.\\n manager = pywrapcp.RoutingIndexManager(len(data['distance_matrix']),\\n data['num_vehicles'], data['depot'])\\n # Create Routing Model.\\n routing = pywrapcp.RoutingModel(manager)\\n # Create and register a transit callback.\\n def distance_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return data['distance_matrix'][from_node][to_node]\\n def pending_callback(from_index, to_index):\\n \\\"\\\"\\\"Returns the distance between the two nodes.\\\"\\\"\\\"\\n # Convert from routing variable Index to distance matrix NodeIndex.\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return data['post'][to_node]\\n transit_callback_index = routing.RegisterTransitCallback(distance_callback)\\n pending_callback_index = routing.RegisterTransitCallback(pending_callback)\\n # Define cost of each arc.\\n for i in range(data['num_vehicles']-1):\\n routing.SetArcCostEvaluatorOfVehicle(transit_callback_index, i) #Transit cost\\n routing.SetFixedCostOfVehicle(data['fixed_cost'], i) #Fixed cost\\n routing.SetArcCostEvaluatorOfVehicle(pending_callback_index, data['num_vehicles']-1) #Postponement and/or NonService cost\\n # Add Capacity constraint.\\n def demand_callback(from_index): #\\n \\\"\\\"\\\"Returns the demand of the node.\\\"\\\"\\\"\\n # Convert from routing variable Index to demands NodeIndex.\\n from_node = manager.IndexToNode(from_index) \\n return data['demands'][from_node]\\n demand_callback_index = routing.RegisterUnaryTransitCallback(\\n demand_callback)\\n routing.AddDimensionWithVehicleCapacity(\\n demand_callback_index,\\n 0, # null capacity slack\\n data['vehicle_capacities'], # vehicle maximum capacities\\n True, # start cumul to zero\\n 'Capacity')\\n # Add time constraint.\\n def time_callback(from_index,to_index): #\\n \\\"\\\"\\\"Returns the demand of the node.\\\"\\\"\\\"\\n # Convert from routing variable Index to NodeIndex in time\\n from_node = manager.IndexToNode(from_index)\\n to_node = manager.IndexToNode(to_index)\\n return time_matrix[from_node][to_node] \\n time_callback_index = routing.RegisterTransitCallback(time_callback) \\n routing.AddDimensionWithVehicleCapacity(\\n time_callback_index,\\n 0, # null capacity slack\\n data['time_capacities'], # vehicle maximum capacities\\n True, # start cumul to zero\\n 'Time')\\n # Setting solution heuristic-procedure.\\n search_parameters = pywrapcp.DefaultRoutingSearchParameters()\\n search_parameters.local_search_metaheuristic = (\\n routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)\\n search_parameters.time_limit.seconds = 5 #10 # 60 #20 #3000\\n search_parameters.log_search = True\\n # Solve the problem.\\n assignment = routing.SolveWithParameters(search_parameters)\\n # Print solution on console.\\n if assignment:\\n sent, sol_results, routes_results = print_solution(data, manager, routing, assignment) \\n return sent, sol_results, routes_results\",\n \"def getAction(self, gameState):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # Again, we use the fundamental foundation built in Q2 for Q4, however here we modify our minimizer function\\n # to serve the purpose of finding the expected value\\n actionList = gameState.getLegalActions(0)\\n pacmanAgentIndex = 0\\n ghostAgentIndices = list(range(1,gameState.getNumAgents())) # List of each agent index for looping\\n count = util.Counter()\\n agentEnd = gameState.getNumAgents()-1 # Last agent in the list\\n def maximizer(curState, agentIndex, depth):\\n\\n ghostActions = curState.getLegalActions(agentIndex)\\n maxDepth = self.depth # Quantifying the end of the tree so we know when we reached a leaf node\\n weight = -99999999 # Worst case starting value to be changed in the code\\n if depth == maxDepth: # If we are at a leaf node\\n return self.evaluationFunction(curState) # evaluate the state of this leaf node\\n # Otherwise, we progress the tree until the above condition is reached\\n if len(ghostActions) != 0:\\n for x in ghostActions:\\n if weight >= minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth):\\n weight = weight\\n else:\\n weight = minimizer(curState.generateSuccessor(agentIndex, x), agentIndex + 1, depth)\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n def minimizer(curState, agentIndex, depth):\\n ghostActions = curState.getLegalActions(agentIndex)\\n weight = 0 # Starting value of zero to be incremented below\\n if len(ghostActions) != 0:\\n if agentIndex == agentEnd: # If we've reached the last ghost, we maximise\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*maximizer(curState.generateSuccessor(agentIndex, x), pacmanAgentIndex, depth+1)\\n weight = weight + temp\\n else: # Otherwise, we continue to minimize\\n for x in ghostActions: # For each legal action in the current position\\n temp = (float(1.0) / len(ghostActions))*minimizer(curState.generateSuccessor(agentIndex, x), agentIndex+1, depth)\\n weight = weight + temp\\n return weight\\n else:\\n # if there are no legal actions left then evaluate at the last known state\\n return self.evaluationFunction(curState)\\n\\n # Executing the minimizer for all possible actions\\n for x in actionList:\\n tempState = gameState.generateSuccessor(pacmanAgentIndex,x)\\n count[x] = minimizer(tempState,1,0)\\n # print('HELLO THERE')\\n # print(count)\\n return count.argMax()\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n locations = student_utils.convert_locations_to_indices(list_of_locations, list_of_locations)\\n homes = student_utils.convert_locations_to_indices(list_of_homes, list_of_locations)\\n start = list_of_locations.index(starting_car_location)\\n\\n start_time = time.time()\\n\\n if params[0] == 'naive':\\n car_path, drop_off = naive_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy':\\n car_path, drop_off = greedy_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'three_opt':\\n car_path, drop_off = three_opt_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'ant_colony':\\n car_path, drop_off = ant_colony(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy_clustering_three_opt':\\n car_path, drop_off = greedy_clustering_three_opt(locations, homes, start, adjacency_matrix, int(params[1]))\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'mst':\\n car_path, drop_off = mst_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'two_opt':\\n car_path, drop_off = two_opt_solver(locations, homes, start, adjacency_matrix)\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n elif params[0] == 'greedy_clustering_two_opt':\\n car_path, drop_off = greedy_clustering_two_opt(locations, homes, start, adjacency_matrix, int(params[1]))\\n print(\\\"--- %s seconds ---\\\" % (time.time() - start_time))\\n return car_path, drop_off\\n else:\\n pass\",\n \"def incompatibility_solve_cg(self, useAMS=True):\\n \\n zero = Expression((\\\"0.0\\\", \\\"0.0\\\", \\\"0.0\\\"), degree=1)\\n bc = DirichletBC(self.PN, zero, DirichletBoundary())\\n \\n T1 = Function(self.PN) # Solution for the curl curl problem\\n T2 = Function(self.PN) # Solution for the curl curl problem\\n T3 = Function(self.PN) # Solution for the curl curl problem\\n\\n if useAMS:\\n \\n # Set operator for the linear solver\\n L_X = inner(self.strain_diff_1, curl(self.inc_v0))*dx\\n A_X, b_X = assemble_system(self.a_X, L_X, bc)\\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T1.vector()).vec())\\n\\n # Show linear solver details\\n self.ksp_X.view()\\n\\n # Solve 2nd system\\n L_X = inner(self.strain_diff_2, curl(self.inc_v0))*dx\\n A_X, b_X = assemble_system(self.a_X, L_X, bc)\\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T2.vector()).vec())\\n\\n # Solve 3nd system\\n L_X = inner(self.strain_diff_3, curl(self.inc_v0))*dx\\n A_X, b_X= assemble_system(self.a_X, L_X, bc)\\n self.ksp_X.setOperators(as_backend_type(A_X).mat())\\n self.ksp_X.solve(as_backend_type(b_X).vec(), as_backend_type(T3.vector()).vec())\\n \\n else:\\n\\n ### vanilla CG works with potential as RHS\\n\\n L_X = inner(self.strain_diff_1, curl(self.inc_v0))*dx\\n solve(self.a_X == L_X, T1, bc, \\n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'}) \\n\\n L_X = inner(self.strain_diff_2, curl(self.inc_v0))*dx\\n solve(self.a_X == L_X, T2, bc, \\n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'}) \\n\\n L_X = inner(self.strain_diff_3, curl(self.inc_v0))*dx\\n solve(self.a_X == L_X, T3, bc, \\n solver_parameters={'linear_solver': 'cg', 'preconditioner': 'jacobi'})\\n\\n return project( self.X_0(curl(T1),curl(T2),curl(T3)), \\n self.TFS, solver_type=\\\"cg\\\", preconditioner_type=\\\"ilu\\\")\",\n \"def solve(self, topology, algorithm=\\\"SLSQP\\\", grad=\\\"AD\\\", step_size=1e-6, iters=100, eps=1e-6, kappa=1e-8, tmax=100, eta=1e-6, verbose=False):\\n if verbose:\\n print(\\\"----------\\\")\\n print(\\\"Optimization with {} started!\\\".format(algorithm))\\n print(f\\\"# Parameters: {self.number_of_parameters()}, # Constraints {self.number_of_constraints()}\\\")\\n\\n # test for bad stuff before going any further\\n self.check_optimization_sanity()\\n\\n # compose gradient and objective functions\\n if grad not in (\\\"AD\\\", \\\"FD\\\"):\\n raise ValueError(f\\\"Gradient method {grad} is not supported!\\\")\\n if grad == \\\"AD\\\":\\n if verbose:\\n print(\\\"Computing gradients using automatic differentiation!\\\")\\n x_func = partial(self._optimize_form, topology=topology.copy(), tmax=tmax, eta=eta)\\n grad_func = partial(grad_autograd, grad_func=agrad(x_func)) # x, grad, x_func\\n\\n elif grad == \\\"FD\\\":\\n if verbose:\\n print(f\\\"Warning: Calculating gradients using finite differences with step size {step_size}. This may take a while...\\\")\\n grad_func = self.gradient_func(grad_finite_differences, topology.copy(), tmax, eta, step_size)\\n\\n # grad_func = self.gradient_func(grad_func, topology.copy(), tmax, eta, step_size)\\n obj_func = self.objective_func(topology, grad_func, tmax, eta)\\n\\n # generate optimization variables\\n x = self.optimization_parameters(topology)\\n\\n # extract the lower and upper bounds to optimization variables\\n bounds_low, bounds_up = self.optimization_bounds(topology)\\n\\n # stack keyword arguments\\n hyper_parameters = {\\\"f\\\": obj_func,\\n \\\"algorithm\\\": algorithm,\\n \\\"dims\\\": self.number_of_parameters(),\\n \\\"bounds_low\\\": bounds_low,\\n \\\"bounds_up\\\": bounds_up,\\n \\\"iters\\\": iters,\\n \\\"eps\\\": eps,\\n \\\"ftol\\\": kappa}\\n\\n # assemble optimization solver\\n solver = nlopt_solver(**hyper_parameters)\\n\\n # solve optimization problem\\n x_opt = None\\n start = time()\\n try:\\n x_opt = solver.optimize(x)\\n if verbose:\\n print(\\\"Optimization ended correctly!\\\")\\n except RoundoffLimited:\\n print(\\\"Optimization was halted because roundoff errors limited progress\\\")\\n print(\\\"Results may still be useful though!\\\")\\n x_opt = self.optimization_parameters(topology)\\n except RuntimeError:\\n print(\\\"Optimization failed due to a runtime error!\\\")\\n print(f\\\"Optimization total runtime: {round(time() - start, 4)} seconds\\\")\\n return static_equilibrium(topology)\\n\\n # fetch last optimum value of loss function\\n time_opt = time() - start\\n loss_opt = solver.last_optimum_value()\\n evals = solver.get_numevals()\\n status = nlopt_status(solver.last_optimize_result())\\n\\n # set optimizer attributes\\n self.time_opt = time_opt\\n self.x_opt = x_opt\\n self.penalty = loss_opt\\n self.evals = evals\\n self.status = status\\n\\n # set norm of the gradient\\n # NOTE: np.zeros is a dummy array (signature requirement set by nlopt)\\n self.gradient = grad_func(x_opt, np.zeros(x_opt.size))\\n self.gradient_norm = np.linalg.norm(self.gradient)\\n\\n if verbose:\\n print(f\\\"Optimization total runtime: {round(time_opt, 6)} seconds\\\")\\n print(\\\"Number of evaluations incurred: {}\\\".format(evals))\\n print(f\\\"Final value of the objective function: {round(loss_opt, 6)}\\\")\\n print(f\\\"Norm of the gradient of the objective function: {round(self.gradient_norm, 6)}\\\")\\n print(f\\\"Optimization status: {status}\\\".format(status))\\n print(\\\"----------\\\")\\n\\n # exit like a champion\\n return static_equilibrium(topology)\",\n \"def solve_driv(v, ene, s, n, h):\\n\\n xs = np.array([(k+1)*h for k in range(n)])\\n h2 = h*h\\n k = np.sqrt(2.0*ene)\\n \\n vs = [v(x)-ene for x in xs]\\n\\n mat = laplacian_mat(n) -2.0 * h2 * scipy.sparse.diags(vs, 0) + bc_outgoing_mat(n, h, k)\\n vec = np.array([-2.0*h*h*s(x) for x in xs])\\n\\n ys = scipy.sparse.linalg.spsolve(mat, vec)\\n return (xs, ys)\",\n \"def opt(self, demands: Demand) -> float:\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('multicommodity_flow_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the splitting ratios for each edge\\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(self.num_edges):\\n flow_variable_edges.append(\\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Capacity constraint\\n capacity_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint between 0 and edge capacity\\n constraint_i = solver.Constraint(\\n 0, self.graph.get_edge_data(*edge)['weight'],\\n '(1,{},{})'.format(*edge))\\n for j, commodity in enumerate(self.commodities):\\n # Coefficient for jth flow over ith edge is scaled by flow width\\n constraint_i.SetCoefficient(flow_variables[j][i],\\n # cast because or-tools :'(\\n float(demands[j]))\\n capacity_constraints.append(constraint_i)\\n\\n # Conservation on transit nodes\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.num_nodes):\\n if j != commodity[0] and j != commodity[1]:\\n # Constraint must sum to zero\\n constraint_j = solver.Constraint(0, 0,\\n '(2,{},{})'.format(i, j))\\n for k in list(sorted(self.graph.adj[j].keys())):\\n # Ingress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\\n # Egress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Conservation of flow at source node\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[0], edge_dest)]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[0])]],\\n -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Conservation of flow at destination node\\n conservation_dest_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[1])]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[1], edge_dest)]],\\n -1)\\n conservation_dest_constraints.append(constraint_i)\\n\\n ## OBJECTIVES\\n # Implementation of the load-balancing example from Wikipedia\\n # First we add more constraints so that we are minimising the maximum\\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\\n 'max_link_utilisation')\\n min_of_max_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\\n # i.e 'f_0 + f_1 + ... < max'\\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\\n '(5,{})'.format(i))\\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\\n for j, flow_variable in enumerate(flow_variables):\\n constraint_i.SetCoefficient(flow_variable[i],\\n demands[j] /\\n self.graph.get_edge_data(*edge)[\\n 'weight'])\\n min_of_max_constraints.append(constraint_i)\\n\\n # Objective now is to minimise the maximum link utilisation\\n objective = solver.Objective()\\n objective.SetCoefficient(max_utilisation_variable, 1)\\n objective.SetMinimization()\\n solver.Solve()\\n\\n return objective.Value()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.645377","0.6445745","0.63432974","0.62200356","0.61490154","0.6128947","0.61050683","0.60996634","0.5940299","0.5918258","0.59127754","0.59035313","0.5874269","0.5844865","0.5841971","0.5836568","0.58337045","0.5832805","0.58261335","0.58163935","0.5784229","0.57713073","0.5770905","0.5770644","0.5761277","0.5757747","0.5751662","0.5706007","0.56798416","0.5677895","0.5675958","0.56733644","0.56493217","0.5645962","0.5645826","0.5642562","0.56256896","0.56231654","0.5621709","0.56197554","0.56142205","0.5607613","0.5606697","0.5586766","0.5570623","0.55703753","0.55458456","0.5543682","0.5530759","0.5529093","0.55268455","0.5526315","0.55257374","0.5523466","0.5522471","0.5522296","0.5509472","0.5506129","0.5499007","0.54891455","0.5483254","0.5476536","0.54743177","0.5472423","0.545604","0.5455044","0.5449164","0.5443165","0.5443165","0.5443165","0.5437282","0.5428614","0.54083806","0.5399621","0.53929347","0.5386872","0.53799284","0.5375397","0.53734815","0.5368057","0.5364645","0.5358287","0.535676","0.5353103","0.53520954","0.53484863","0.5336056","0.53339976","0.5330909","0.5327973","0.53204346","0.53188974","0.5317284","0.53161526","0.5314581","0.5313732","0.5305557","0.5297192","0.52964497","0.52918893"],"string":"[\n \"0.645377\",\n \"0.6445745\",\n \"0.63432974\",\n \"0.62200356\",\n \"0.61490154\",\n \"0.6128947\",\n \"0.61050683\",\n \"0.60996634\",\n \"0.5940299\",\n \"0.5918258\",\n \"0.59127754\",\n \"0.59035313\",\n \"0.5874269\",\n \"0.5844865\",\n \"0.5841971\",\n \"0.5836568\",\n \"0.58337045\",\n \"0.5832805\",\n \"0.58261335\",\n \"0.58163935\",\n \"0.5784229\",\n \"0.57713073\",\n \"0.5770905\",\n \"0.5770644\",\n \"0.5761277\",\n \"0.5757747\",\n \"0.5751662\",\n \"0.5706007\",\n \"0.56798416\",\n \"0.5677895\",\n \"0.5675958\",\n \"0.56733644\",\n \"0.56493217\",\n \"0.5645962\",\n \"0.5645826\",\n \"0.5642562\",\n \"0.56256896\",\n \"0.56231654\",\n \"0.5621709\",\n \"0.56197554\",\n \"0.56142205\",\n \"0.5607613\",\n \"0.5606697\",\n \"0.5586766\",\n \"0.5570623\",\n \"0.55703753\",\n \"0.55458456\",\n \"0.5543682\",\n \"0.5530759\",\n \"0.5529093\",\n \"0.55268455\",\n \"0.5526315\",\n \"0.55257374\",\n \"0.5523466\",\n \"0.5522471\",\n \"0.5522296\",\n \"0.5509472\",\n \"0.5506129\",\n \"0.5499007\",\n \"0.54891455\",\n \"0.5483254\",\n \"0.5476536\",\n \"0.54743177\",\n \"0.5472423\",\n \"0.545604\",\n \"0.5455044\",\n \"0.5449164\",\n \"0.5443165\",\n \"0.5443165\",\n \"0.5443165\",\n \"0.5437282\",\n \"0.5428614\",\n \"0.54083806\",\n \"0.5399621\",\n \"0.53929347\",\n \"0.5386872\",\n \"0.53799284\",\n \"0.5375397\",\n \"0.53734815\",\n \"0.5368057\",\n \"0.5364645\",\n \"0.5358287\",\n \"0.535676\",\n \"0.5353103\",\n \"0.53520954\",\n \"0.53484863\",\n \"0.5336056\",\n \"0.53339976\",\n \"0.5330909\",\n \"0.5327973\",\n \"0.53204346\",\n \"0.53188974\",\n \"0.5317284\",\n \"0.53161526\",\n \"0.5314581\",\n \"0.5313732\",\n \"0.5305557\",\n \"0.5297192\",\n \"0.52964497\",\n \"0.52918893\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.63130635"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":84678,"cells":{"query":{"kind":"string","value":"Directly solve capital and labor supply given next two periods capitals y is given as 2, 3, ..., 60, i.e., through the nexttolast to the first"},"document":{"kind":"string","value":"def DirectSolve(self, y):\n if y >= -self.R:\n a1 = self.apath[y+1]\n if y == -2:\n a2 = 0\n else:\n a2 = self.apath[y+2] \n def constraints(a):\n c0 = (1+self.r)*a + self.b - a1\n c1 = (1+self.r)*a1 + self.b - a2\n return self.uc(c0,0)-self.beta*self.uc(c1,0)*(1+self.r)\n a, n = fsolve(constraints, a1), 0\n c = (1+self.r)*a + self.b - a1\n else:\n a1 = self.apath[y+1]\n a2 = self.apath[y+2]\n if y == -(self.R+1):\n n1 = 0\n c1 = (1+self.r)*a1 + self.b - a2\n else:\n n1 = self.npath[y+1]\n c1 = (1+self.r)*a1 + (1-self.tau)*self.w*n1 - a2\n def constraints((a0,n0)):\n c0 = (1+self.r)*a0 + (1-self.tau)*self.w*n0 - a1\n return self.uc(c0,n0) - self.beta*self.uc(c1,n1)*(1+self.r),\\\n (1-self.tau)*self.w*self.uc(c0,n0) + self.un(c0,n0)\n a, n = fsolve(constraints,(a1,n1))\n c = (1+self.r)*a + (1-self.tau)*self.w*n - a1\n return a, n, c"},"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 solve_working(\n assets_this_period,\n assets_next_period,\n hc_this_period,\n hc_next_period,\n interest_rate,\n wage_rate,\n income_tax_rate,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n delta_hc,\n zeta,\n psi,\n n_gridpoints_capital,\n n_gridpoints_hc,\n efficiency,\n survival_rate,\n):\n # Initialize objects\n policy_labor_working_tmp = np.zeros(\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\n )\n\n # Implied hc effort\n hc_effort = get_hc_effort(\n hc_this_period=hc_this_period,\n hc_next_period=hc_next_period,\n zeta=zeta,\n psi=psi,\n delta_hc=delta_hc,\n )\n\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\n\n # Implied labor supply\n labor_input = 1 - hc_effort\n\n # Consumption\n consumption = get_consumption(\n assets_this_period=assets_this_period,\n assets_next_period=assets_next_period,\n pension_benefit=np.float64(0.0),\n labor_input=labor_input,\n interest_rate=interest_rate,\n wage_rate=wage_rate,\n income_tax_rate=income_tax_rate,\n productivity=hc_this_period,\n efficiency=efficiency,\n )\n\n # Flow utility\n flow_utility = util(\n consumption=consumption,\n labor_input=labor_input,\n hc_effort=hc_effort,\n gamma=gamma,\n sigma=sigma,\n )\n\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\n\n # Value function on the complete mesh (i.e. for all possible choices)\n value_full = flow_utility + beta * survival_rate * continuation_value\n\n # Derive optimal policies and store value function given optimal choices\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\n for assets_this_period_idx in range(n_gridpoints_capital):\n for hc_this_period_idx in range(n_gridpoints_hc):\n assets_next_period_idx = policy_capital_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n hc_next_period_idx = policy_hc_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n policy_labor_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ] = labor_input[\n assets_this_period_idx,\n assets_next_period_idx,\n hc_this_period_idx,\n hc_next_period_idx,\n ]\n\n return (\n policy_capital_working_tmp,\n policy_hc_working_tmp,\n policy_labor_working_tmp,\n value_working_tmp,\n )","def solve_retired(\n assets_this_period,\n assets_next_period,\n interest_rate,\n pension_benefit,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n survival_rate,\n):\n # Consumption\n consumption = get_consumption(\n assets_this_period=assets_this_period,\n assets_next_period=assets_next_period,\n pension_benefit=pension_benefit,\n labor_input=np.float64(0.0),\n interest_rate=interest_rate,\n wage_rate=np.float64(0.0),\n income_tax_rate=np.float64(0.0),\n productivity=np.float64(0.0),\n efficiency=np.float64(0.0),\n )\n\n # Flow utility\n flow_utility = util(\n consumption=consumption,\n labor_input=np.float64(0.0),\n hc_effort=np.float64(0.0),\n gamma=gamma,\n sigma=sigma,\n )\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\n\n # Calculate value on meshes (i.e. for all choices)\n value_full = flow_utility + beta * survival_rate * continuation_value\n\n # Derive optimal policies and store value function given optimal choices\n policy_capital_retired_tmp = np.argmax(value_full, axis=1)\n value_retired_tmp = np.max(value_full, axis=1)\n\n return value_retired_tmp, policy_capital_retired_tmp","def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\n\n \"\"\"\n This function calculates American Opportunity Credit\n for up to four eligible students\n\n \"\"\"\n\n # Expense should not exceed the cap of $4000.\n if _cmp == 1:\n\n c87482 = max(0., min(e87482, 4000.))\n c87487 = max(0., min(e87487, 4000.))\n c87492 = max(0., min(e87492, 4000.))\n c87497 = max(0., min(e87497, 4000.))\n else:\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\n\n # Credit calculated as 100% of the first $2000 expense plus\n # 25% of amount exceeding $2000.\n if max(0, c87482 - 2000) == 0:\n c87483 = c87482\n else:\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\n\n if max(0, c87487 - 2000) == 0:\n c87488 = c87487\n else:\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\n\n if max(0, c87492 - 2000) == 0:\n c87493 = c87492\n else:\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\n\n if max(0, c87497 - 2000) == 0:\n c87498 = c87497\n else:\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\n\n # Sum of credits of all four students.\n c87521 = c87483 + c87488 + c87493 + c87498\n\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\n c87521)","def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n\n for i in range(total_days):\n if i==0:\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n elif i==total_days-1: # last day\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n invt_daily_list.append(today_invt_dict)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Baseline Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Baseline (1st day buy->hold->last day sell) Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()\n return","def _step(self, w1, y1,y1_short):\n\n #reajust the return y1 using the sign of w1\n #if is negative means we shorted so the return is the inverse\n\n y1_aux=y1.copy()\n for i in range(len(w1)):\n if(w1[i]<0):\n y1_aux[i]=y1_short[i]\n y1=y1_aux.copy()\n\n\n\n\n #print (\"enter step\")\n assert w1.shape == y1.shape, 'w1 and y1 must have the same shape'\n assert y1[0] == 1.0, 'y1[0] must be 1'\n\n p0 = self.p0\n\n dw1 = (y1 * w1) / (np.dot(y1, w1) + eps) # (eq7) weights evolve into\n\n mu1 = self.cost * (np.abs(dw1 - w1)).sum() # (eq16) cost to change portfolio\n\n assert mu1 < 1.0, 'Cost is larger than current holding'\n\n p1 = p0 * (1 - mu1) * np.dot(y1, w1) # (eq11) final portfolio value\n\n p1 = p1 * (1 - self.time_cost) # we can add a cost to holding\n\n rho1 = p1 / p0 - 1 # rate of returns\n r1 = np.log((p1 + eps) / (p0 + eps)) # log rate of return\n reward = r1 / self.steps * 1000. # (22) average logarithmic accumulated return\n # remember for next step\n self.p0 = p1\n\n # if we run out of money, we're done (losing all the money)\n done = p1 == 0\n\n\n info = {\n \"reward\": reward,\n \"log_return\": r1,\n \"portfolio_value\": p1,\n \"return\": y1.mean(),\n \"rate_of_return\": rho1,\n \"weights_mean\": w1.mean(),\n \"weights_std\": w1.std(),\n \"cost\": mu1,\n }\n\n #print (info)\n\n self.infos.append(info)\n return reward, info, done","def americanprice(self):\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\n discount = math.exp( self.r*self.deltatime )\n for i in range(self.steps,0,-1):\n for j in range(i):\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\n return self.americanpay[0][0]","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 getRateFromProjectedAccruedment(from_capital, to_capital, period):\n \"\"\"\n vc = 100 * pow(1+50.0/100,2)\n vc = 1e9\n print vc\n period = 500\n print period\n \"\"\"\n return 100 * (pow(float(to_capital)/from_capital, 1.0/period)-1)","def calc_savings_needed():\r\n annual_salary_real = float(input(\"Starting Salary: \"))\r\n #portion_saved = float(input(\"Enter the percent of your salary to save, as a decimal: \"))\r\n total_cost = 1000000#float(input(\"Enter the cost of your dream home: \"))\r\n semi_annual_raise = .07#float(input(\"Enter the semi annual raise as decimal: \"))\r\n portion_down_payment = .25\r\n current_savings = 0\r\n r = .04;\r\n monthly_salary = annual_salary_real / 12 \r\n \r\n months = 36\r\n epsilon = 100\r\n low = 0.0\r\n high = 1.0\r\n guess = (low + high) / 2.0\r\n num_guesses = 0\r\n breaked = False\r\n \r\n while(abs(current_savings - total_cost*portion_down_payment) > epsilon):\r\n if(guess == 1.0):\r\n breaked = True\r\n break\r\n #print(\"new guess: \",guess)\r\n annual_salary = annual_salary_real\r\n monthly_salary = annual_salary/12\r\n num_guesses += 1 \r\n \r\n month = 0\r\n current_savings = 0\r\n while( month < months):\r\n \r\n current_savings += (current_savings * r /12) + (guess * monthly_salary)\r\n month += 1\r\n if ((month % 6) == 0):\r\n annual_salary += annual_salary * semi_annual_raise\r\n monthly_salary = annual_salary / 12\r\n \r\n if(abs(current_savings - (total_cost*portion_down_payment)) > epsilon):\r\n #print(\"current_savings: \",current_savings)\r\n if(current_savings < (total_cost*portion_down_payment)):\r\n low = guess\r\n else:\r\n high = guess\r\n guess = (low + high) / 2.0\r\n \r\n if(breaked):\r\n print(\"It is not possible to pay down payment in 3 years.\")\r\n else: \r\n print(\"Best savings rate: \", guess)\r\n print(\"Steps in bisection search: \", num_guesses)","def advance(self):\n\n f, n, rtol, atol, neq = \\\n self.f, self.n, self.rtol, self.atol, self.neq\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\n dt = t_next - t_n\n\n first_step = dt # try one big step to next desired level\n\n def middle(x,y,z): # Auxilary function\n return sorted([x,y,z])[1]\n\n # Extract coefficients from Butcher-tableau\n table = self._butcher_tableau\n k_len = table.shape[1] - 1 # number of internal stages\n\n # coefficients for internal stages\n factors_u = np.asarray(table[:k_len, 1:])\n # coefficients for t\n factors_t = table[:k_len, 0]\n # coefficients for u_new\n factors_u_new = table[k_len, 1:]\n\n # coefficients for local error between 2 levels\n factors_error = table[k_len+1, 1:] - factors_u_new\n\n u_intermediate = [u_n,]\n t_intermediate = [t_n,]\n u, t, h = u_n, t_n, first_step # initial values\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\n\n if self.verbose > 0:\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\n\n # Loop until next time point is reached\n while (abs(t - t_n) < abs(t_next - t_n)):\n u, t = u_intermediate[-1], t_intermediate[-1]\n\n # Internal steps\n k[:, :] = 0. # initialization for next step\n for m in range(k_len):\n k_factors = (np.dot(factors_u, k))[m]\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\n u_new = u + h*(np.dot(factors_u_new, k))\n\n self.info['rejected'] += 1 # reduced below if accepted\n if self.verbose > 0:\n print ' u(t=%g)=%g: ' % (t+h, u_new),\n\n # local error between 2 levels\n error = h*np.abs(np.dot(factors_error, k))\n # Acceptable error tolerance\n tol = rtol*np.abs(u_new) + atol\n\n accurate = (error <= tol).all()\n\n if accurate or h <= self.min_step or h >= self.max_step:\n # Accurate enough,\n # or the step size exceeds valid range,\n # must accept this solution\n u_intermediate.append(u_new)\n t_intermediate.append(t+h)\n if not self.disk_storage:\n self.u_all.append(u_new)\n self.t_all.append(t+h)\n self.info['rejected'] -= 1\n\n if self.verbose > 0:\n print 'accepted, ',\n else:\n if self.verbose > 0:\n print 'rejected, ',\n\n if self.verbose > 0:\n print 'err=%s, ' % str(error),\n if hasattr(self, 'u_exact') and callable(self.u_exact):\n print 'exact-err=%s, ' % \\\n (np.asarray(self.u_exact(t+h))-u_new),\n if h <= self.min_step:\n print 'h=min_step!! ',\n\n\n # Replace 0 values by 1e-16 since we will divide by error\n error = np.asarray([(1e-16 if x == 0. else x) \\\n for x in error])\n\n # Normarized error rate\n rms = error/tol\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\n\n order = float(self._method_order[0])\n # factor to adjust the size of next step\n # Formula is from <Numerical Methods for Engineers,\n # Chappra & Cannle>\n s = .8 *((1./rms_norm)**(1/order))\n # scalar should be in range(0.1, 4.)\n # for better accuracy and smoothness\n s = middle(s, 0.1, 4.0)\n h *= s\n\n # step size should be in range [min_step, max_step]\n h = middle(h, self.min_step, self.max_step)\n # adjust h to fit the last step\n h = min(h, t_next - t_intermediate[-1])\n\n if self.verbose > 0:\n print 'new h=%g' % h\n\n if h == 0:\n break\n\n return u_new","def part_2():\n input_ = parse_input() + list(range(10, 1_000_001))\n cups = turn_input_into_cups(input_)\n cups = solve(cups, first_cup=cups[input_[0]], turns=10_000_000)\n\n return cups[1].next.number * cups[1].next.next.number","def run():\n ncases = int(utils.get_input(\"Amount of cases: \"))\n cases = []\n for icase in range(ncases):\n credit = int(utils.get_input(\"Credit for case {}: \".format(icase+1)))\n prices_raw = utils.get_input(\"Item prices for case {}: \".format(icase+1))\n prices = [int(price_raw) for price_raw in prices_raw.split()]\n cases.append((prices, credit))\n results = [lt.first_sum_pair(pr, cr) for pr, cr in cases]\n [print(\"Case #{}: {} {}\".format(icase+1, *result)) for icase, result in enumerate(results)]","def part_1():\n input_ = parse_input()\n cups = turn_input_into_cups(input_)\n cups = solve(cups, first_cup=cups[input_[0]], turns=100)\n\n answer = []\n current_cup = cups[1].next\n while current_cup != cups[1]:\n answer.append(str(current_cup.number))\n current_cup = current_cup.next\n\n return \"\".join(answer)","def alice(\n partner1_salary_compound_rate: float,\n partner1_salary_plateau: float,\n partner2_salary_compound_rate: float,\n partner2_salary_plateau: float,\n base_spending: float,\n spending_luxury_compound_rate: float,\n rrsp_interest_rate: float,\n tfsa_interest_rate: float,\n):\n\n ruleset_func = ruleset.get_couple_ruleset(\n salary_rules.get_compound_plateau(\n partner1_salary_compound_rate, partner1_salary_plateau\n ),\n salary_rules.get_compound_plateau(\n partner2_salary_compound_rate, partner2_salary_plateau\n ),\n couple_spending_rules.get_luxury_over_basic(\n base_spending, spending_luxury_compound_rate\n ),\n couple_savings_rules.get_equalizing_rrsp_only_split(),\n rrsp_interest_rate,\n tfsa_interest_rate,\n )\n\n return ruleset_func","def solve(self, state, times):","def cvp():\r\n c = float(input(\"Please Enter Total Fixed Costs Value: \"))\r\n a = float(input(\"Please Enter Sale Price Per Unit: \"))\r\n b = float(input(\"Please Enter Variable Cost Per Unit: \"))\r\n ccm = float(a)-float(b)\r\n cuu = float(c)/float(ccm)\r\n ccmr = (float(ccm)/float(a))*float(100)\r\n cda = float(c)/(float(ccmr)/float(100))\r\n print \">> Your Contribution Margin is\",ccm\r\n print \">> Your Breakeven Sales in Units is\",round(cuu)\r\n print \">> Your Contribution Margin Ratio is\",ccmr,\"%\"\r\n print \">> Your Breakeven Sales in Dollars is\",cda,\"\\n\"\r\n qq = input(\" Press 1 To Compute Target Profit\\n Press 2 To Compute Margin of Safety\\n Press 3 To Perform Sensitivity Analysis\\n Or Press 0 To Exit: \")\r\n if(qq == 1):\r\n dds = float(input(\"Please Enter Your Target Profit: \"))\r\n xxx = (float(c)+float(dds))/float(ccm)\r\n xxxx = (float(c)+float(dds))/(float(ccmr)/float(100))\r\n print \">> Your Target Profit in Units To Earn\",dds,\"$ is\",round(xxx)\r\n print \">> Your Target Profit in Dollars To Earn\",dds,\"$ is\",xxxx\r\n elif(qq == 0):\r\n print \"Canceled\"\r\n elif(qq == 2):\r\n xc = float(input(\"Please Enter Expected Sales in Units: \"))\r\n zzz = float(xc)-float(cuu)\r\n zzzz = float(zzz)*float(a)\r\n print \">> Your Margin of Safety in Units is\",round(zzz)\r\n print \">> Your Margin of Safety in Dollars is\",zzzz\r\n elif(qq == 3):\r\n i = input(\"Please Enter Total Fixed Costs Value: \")\r\n o = input(\"Please Enter Sale Price Per Unit: \")\r\n p = input(\"Please Enter Variable Cost Per Unit: \")\r\n n = 0\r\n for x,y,z in zip(i,o,p):\r\n cm = float(y)-float(z)\r\n uu = float(x)/float(cm)\r\n cmr = (float(cm)/float(y))*float(100)\r\n da = float(x)/(float(cmr)/float(100))\r\n n += 1\r\n print \"Your Results in Case\",int(n),\"is :\"\r\n print \">> Your Contribution Margin is\",cm\r\n print \">> Your Breakeven Sales in Units is\",round(uu)\r\n print \">> Your Contribution Margin Ratio is\",cmr,\"%\"\r\n print \">> Your Breakeven Sales in Dollars is\",da,\"\\n\"\r\n if(cm > ccm):\r\n a = float(cm)-float(ccm)\r\n print \">> Your Contribution Margin Increased by\",a\r\n elif(ccm > cm):\r\n a = float(ccm)-float(cm)\r\n print \">> Your Contribution Margin Decreased by\",a\r\n if(uu > cuu):\r\n b = float(uu)-float(cuu)\r\n print \">> Your Breakeven Sales in Units Increased by\",round(b)\r\n elif(cuu > uu):\r\n b = float(cuu)-float(uu)\r\n print \">> Your Breakeven Sales in Units Decreased by\",round(b)\r\n if(cmr > ccmr):\r\n c = float(cmr)-float(ccmr)\r\n print \">> Your Contribution Margin Ratio Increased by\",c,\"%\"\r\n elif(ccmr > cmr):\r\n c = float(ccmr)-float(cmr)\r\n print \">> Your Contribution Margin Ratio Decreased by\",c,\"%\"\r\n if(da > cda):\r\n d = float(da)-float(cda)\r\n print \">> Your Breakeven Sales in Dollars Increased by\",d\r\n elif(cda > da):\r\n d = float(cda)-float(da)\r\n print \">> Your Breakeven Sales in Dollars Decreased by\",d,\"\\n\"","def budget_problem3(balance, annualInterestRate):\r\n remaining = balance\r\n\r\n # creating the following bounds assists with bisection search\r\n lo = balance/12\r\n hi = ((balance * (annualInterestRate/12))**12)/12\r\n payment = (lo + hi)/2\r\n\r\n while remaining != 0:\r\n for month in range(12):\r\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\r\n if remaining > 0:\r\n lo = payment\r\n elif round(remaining,2) < -0.11:\r\n hi = payment\r\n else:\r\n break\r\n payment = (lo + hi)/2\r\n remaining = balance\r\n print 'Lowest Payment: ' + str(round(payment,2))\r\n return round(payment,2)","def double_declining_balance():\r\n cost = float(input(\"Please Enter The Cost Of Asset: \"))\r\n accdepreciation = float(input(\"Please Enter The Value Of Accumulated Depreciation: \"))\r\n life = float(input(\"Please Enter Estimated Useful Life Of Asset(Years): \"))\r\n rv = float(input(\"Please Enter Estimated Residual Value Of Asset: \"))\r\n n = 0\r\n a = (float(cost)-float(accdepreciation)) * (float(2)/float(life))\r\n bn = float(a)/float(12)\r\n print \">> Your Monthly Depreciation For First Year is\",bn\r\n while(n != (life-1)):\r\n bk = float(cost)\r\n a = ((float(cost)-float(accdepreciation)) * (float(2)/float(life)))\r\n cost -= float(a)\r\n bk -= float(a)\r\n n += 1\r\n vvv = float(bk)-float(rv)\r\n print \">> Your Depreciation For Year No.\",n,\"is\",a\r\n print \">> Your Book Value After\",n,\"Years is\",bk,\"\\n\"\r\n print \">> Your Depreciation For Year No.\",int(life),\"is\",vvv\r\n print \">> Your Book Value After\",int(life),\"Years is\",rv","def find_subsidy_rate(self, tau):\n \n #a. find residual with lower and upper guesses\n tauv_0 = np.array([-self.tau_s_0, 0, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv_0) \n \n Kss_d = self.solve_stationary_equilibrium()[1]\n residual0 = Kss_d / self.Kss_b - 1\n \n tauv_1 = np.array([-self.tau_s_1, 0, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv_1) \n \n Kss_d = self.solve_stationary_equilibrium()[1]\n residual1 = Kss_d / self.Kss_b - 1\n \n assert residual0*residual1 < 0, 'find_subsidy_rate -- WARNING: No equilibrium tau exists'\n \n #b. bisection to find the subsidy rate that genereates the same ss capital as in benchmark case\n \n tau_s_0 = self.tau_s_0 \n tau_s_1 = self.tau_s_1\n \n for i_t in range(self.maxit):\n taus = (tau_s_0 + tau_s_1)/2\n tauv = np.array([-taus, 0, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv) \n \n Kss_d = self.solve_stationary_equilibrium()[1]\n residual = Kss_d / self.Kss_b - 1\n \n if np.abs(residual) < self.tol:\n \n taus_star = taus\n break\n \n else:\n if residual1 * residual>0 :\n tau_s_1 = taus\n else :\n tau_s_0 = taus\n \n assert i_t+1 < self.maxit, 'find_subsidy_rate -- taus has not converged'\n \n return taus_star","def calc_capital_costs (self):\n self.capital_costs = self.max_boiler_output * \\\n self.comp_specs[\"cost per btu/hrs\"]\n #~ print self.capital_costs","def y2k_coding(n):\n if n < 60:\n return 2000 + n\n else:\n return 1900 + n","def rhs_fenics(y,t):\n #print \"time: \",t\n uprev.vector()[:]=y\n f.t = t #dolfin needs to know the current time for cos(t)\n uprime_solver.solve()\n return uprime_solution.vector().array()","def lax(_x,_y,_cs,_dx,_dt):\n s = _cs * _dt / (2. * _dx)\n next_y = 0.5 *(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1])) \\\n - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\n return next_y","def calc_capital_costs (self):\n powerhouse_control_cost = 0\n if not self.cd['switchgear suitable for renewables']:\n powerhouse_control_cost = self.cd['switchgear cost']\n\n #~ road_needed = self.comp_specs['road needed for transmission line']\n\n\n if str(self.comp_specs['transmission capital cost'])\\\n != 'UNKNOWN':\n transmission_line_cost = \\\n int(self.comp_specs['transmission capital cost'])\n else:\n if str(self.comp_specs['distance to resource']) \\\n != 'UNKNOWN':\n distance = \\\n float(self.comp_specs\\\n ['distance to resource'])\n transmission_line_cost = \\\n distance*self.comp_specs['est. transmission line cost']\n\n secondary_load_cost = 0\n if self.comp_specs['secondary load']:\n secondary_load_cost = self.comp_specs['secondary load cost']\n\n if str(self.comp_specs['generation capital cost']) \\\n != 'UNKNOWN':\n wind_cost = \\\n int(self.comp_specs['generation capital cost'])\n self.cost_per_kw = np.nan\n else:\n for i in range(len(self.comp_specs['estimated costs'])):\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\n self.load_offset_proposed:\n if i == len(self.comp_specs['estimated costs']) - 1:\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n continue\n\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n\n wind_cost = self.load_offset_proposed * cost\n self.cost_per_kw = cost\n\n #~ print powerhouse_control_cost\n #~ print transmission_line_cost\n #~ print secondary_load_cost\n #~ print wind_cost\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\n secondary_load_cost + wind_cost\n\n #~ print 'self.capital_costs',self.capital_costs","def main():\r\n d = CoupleBreaker()\r\n d.makeCouples()\r\n\r\n \"\"\"here k is taken as 2 , any value can be taken\"\"\"\r\n t= int(input(\"Enter the no. of days :-\"))\r\n\r\n for i in range(0, t):\r\n d.breakLeastHappy(2)\r\n d.PatchThemUp()","def trailing_stop_pct(self, offset=0.33, ts_o_type='market', tschase=False, max_chase=None):\n\n\n # rpnl = float(r) * 0.00000001\n # bal = float(self.get_balance()) * 0.00000001\n\n while True:\n pos = self.get_position()\n entry_price = pos['avgEntryPrice']\n # last_price = self.ws.get_ticker()['last']\n qty = pos['currentQty']\n (r, u, b) = self.get_pnl()\n upnl = float(u) * 0.00000001\n bal = float(b) * 0.00000001\n if u > 0.0:\n self.logger.info(f'Trailing stop triggered: UPNL {upnl} BAL {bal}')\n break\n else:\n self.logger.info('No unrealized PNL, waiting ... ')\n time.sleep(3)\n if qty > 0:\n # long position, so this will be a sell stop\n sell_price = self.ws.get_ticker()['sell']\n offset_price = self.rounded_price(sell_price - (float(offset) * (sell_price - entry_price)), self.symbol)\n text = f'Trailing sell stop for long position, type {ts_o_type}'\n qty = qty * -1\n side = 'Sell'\n self.logger.info(\n f'Trailing Stop for long position of entry price: {entry_price} triggered: offset price {offset_price}'\n f' current price: {[sell_price]}')\n else:\n # short position, so this will be a buy stop\n buy_price = self.ws.get_ticker()['buy']\n offset_price = self.rounded_price(buy_price - float(offset) * (buy_price - entry_price), self.symbol)\n text = f'Trailing buy stop for short position, type {ts_o_type}'\n qty = qty * -1\n side = 'Buy'\n self.logger.info(\n f'Trailing Stop for short position of entry price: {entry_price} triggered: offset price {offset_price}'\n f' current price: {[buy_price]}')\n\n iteration = 0\n while True:\n\n if side == \"Sell\":\n sell_price = self.ws.get_ticker()['sell']\n offset_pct = self.rounded_price((sell_price - entry_price) * offset, self.symbol)\n if (float(sell_price) - float(offset_pct)) > float(offset_price):\n offset_price = self.rounded_price(sell_price - (float(offset) * (sell_price - entry_price)), self.symbol)\n self.logger.info(\"New high observed: %.8f Updating stop loss to %.8f\" % (sell_price, offset_price))\n\n elif float(sell_price) < float(offset_price):\n sell_price = self.ws.get_ticker()['sell']\n if tschase:\n self.logger.info(f'Chasing sell order ... max chase: {max_chase}')\n self.logger.info(\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\" % (ts_o_type, sell_price,\n offset_price))\n chaser = threading.Thread(target=self.limit_chase, args=(qty, max_chase, True))\n chaser.start()\n else:\n self.logger.info(\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\" % (ts_o_type, sell_price,\n offset_price))\n ret = self.send_order(oq=qty, ot=ts_o_type, text=text)\n self.logger.debug(ret)\n\n self.triggered = False\n break\n\n\n if side == \"Buy\":\n buy_price = self.ws.get_ticker()['buy']\n offset_pct = self.rounded_price((entry_price - buy_price) * offset, self.symbol)\n if (float(buy_price) + float(offset_pct)) < float(offset_price):\n offset_price = self.rounded_price(buy_price - float(offset) * (buy_price - entry_price))\n\n self.logger.info(\"New low observed: %.8f Updating stop loss to %.8f\" % (buy_price, offset_price))\n\n elif float(buy_price) > float(offset_price):\n buy_price = self.ws.get_ticker()['buy']\n if tschase:\n self.logger.info(f'Chasing buy order ... max chase: {max_chase}')\n self.logger.info(\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\" % (ts_o_type, buy_price,\n offset_price))\n chaser = threading.Thread(target=self.limit_chase, args=(qty, max_chase, True))\n chaser.start()\n else:\n self.logger.info(\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\" % (ts_o_type, buy_price,\n offset_price))\n ret = self.send_order(oq=qty, ot=ts_o_type, text=text)\n self.logger.debug(ret)\n\n self.triggered = False\n break","def stage_order(self,tol=1.e-14):\n from sympy import simplify\n simp_array = np.vectorize(sympy.simplify)\n k,B,C=0,0.,0.\n while np.all(abs(B)<tol) and np.all(abs(C)<tol):\n k=k+1\n B=simplify(np.dot(self.b,self.c**(k-1)))-1./k\n C=simp_array(np.dot(self.A,self.c**(k-1))-self.c**k/k)\n return k-1","def test(test_env, Q):\n observation = test_env._reset()\n test_cap = []\n done = False\n while not done:\n # Get action with maximum future expected reward\n action = action = Q.q_table.loc[str(test_env._get_obs())].idxmax()\n # Apply action\n observation_, reward, done = test_env._step(action)\n # Save current cash to observe over testing period\n test_cap.append(test_env.current_capital)\n # Current obs becomes next obs\n observation = observation_\n # If completed time frame\n if done:\n break\n\n plt.scatter(np.arange(len(test_cap)), test_cap, marker='.', c='k' )\n plt.title('Capital Attained at Each Decision')\n plt.xlabel('Day')\n plt.ylabel('Capital Attained')\n plt.show()\n return","def getY90(inp):\n\tinp = sorted(inp, key = lambda x: x[0])\n\tfor i in xrange(len(inp)):\n\t\te = inp[i]\n\t\tif e[1]>=0.9:\n\t\t\tsecond = e\n\t\t\tfirst = inp[i-1]\n\t\t\tbreak\n\treturn first[0]+(0.9-first[1])/(second[1]-first[1])*(second[0]-first[0])","def step2(self):\n\t\tif self.b[self.k - 1] == 'a':\n\t\t\tif self.ends(\"ational\"): self.r(\"ate\")\n\t\t\telif self.ends(\"tional\"): self.r(\"tion\")\n\t\telif self.b[self.k - 1] == 'c':\n\t\t\tif self.ends(\"enci\"):\t self.r(\"ence\")\n\t\t\telif self.ends(\"anci\"): self.r(\"ance\")\n\t\telif self.b[self.k - 1] == 'e':\n\t\t\tif self.ends(\"izer\"):\t self.r(\"ize\")\n\t\telif self.b[self.k - 1] == 'l':\n\t\t\tif self.ends(\"bli\"):\t self.r(\"ble\") # --DEPARTURE--\n\t\t\t# To match the published algorithm, replace this phrase with\n\t\t\t#\tif self.ends(\"abli\"):\t self.r(\"able\")\n\t\t\telif self.ends(\"alli\"): self.r(\"al\")\n\t\t\telif self.ends(\"entli\"): self.r(\"ent\")\n\t\t\telif self.ends(\"eli\"):\t self.r(\"e\")\n\t\t\telif self.ends(\"ousli\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 'o':\n\t\t\tif self.ends(\"ization\"): self.r(\"ize\")\n\t\t\telif self.ends(\"ation\"): self.r(\"ate\")\n\t\t\telif self.ends(\"ator\"): self.r(\"ate\")\n\t\telif self.b[self.k - 1] == 's':\n\t\t\tif self.ends(\"alism\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iveness\"): self.r(\"ive\")\n\t\t\telif self.ends(\"fulness\"): self.r(\"ful\")\n\t\t\telif self.ends(\"ousness\"): self.r(\"ous\")\n\t\telif self.b[self.k - 1] == 't':\n\t\t\tif self.ends(\"aliti\"):\t self.r(\"al\")\n\t\t\telif self.ends(\"iviti\"): self.r(\"ive\")\n\t\t\telif self.ends(\"biliti\"): self.r(\"ble\")\n\t\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\n\t\t\tif self.ends(\"logi\"):\t self.r(\"log\")\n\t\t# To match the published algorithm, delete this phrase","def _cost_caught_by_police(self):\n if self.fine_frequency != 0:\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\n self.fine_paid_number_of_courses += 1\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\n return fine_value\n else:\n return 0\n else:\n return 0\n else:\n return 0","def _determine_next_eval_point(self):\n anc_data = self._get_ancillary_data_for_acquisition()\n acq_to_use = getattr(acquisitions.asy, self.options.acq.lower())\n next_eval_point = acq_to_use(self.gp, self.acq_optimise, anc_data)\n return next_eval_point","def lab10_q2():\n return \"\"\"\n Make a 'total' to add up the total revenue as while loop plays.\n\titem = qvm.dispense, makes it so item is the juice. \n\tWhile item: because if there is a juice this while loop will continue. If there aren't two fruits, there wont be a juice so while loop stops.\n\ttotal += qvm.collect_money(item). (this should be += not = right?) to add the revenue from that 'item'\n\trevalue item to the next juice.\n\treturn total\n \"\"\"","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def solve_p1_v1(target: int) -> int:\n\n elves = DeliveryService()\n\n house, n_presents = 0, 0\n while n_presents < target:\n house += 1\n n_presents = elves.visit(house)\n print(house, n_presents)\n\n return house","def solve_model(self): \n \n t0 = time.time() #start the clock\n \n # a. benchmark case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(1)\n \n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(self.tau_benchmark) #set tax system\n \n #iii. benchmark equilibrium\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Benchmark Stationary Equilibrium\")\n print(\"-----------------------------------------\")\n print(f\"ss output = {self.Yss_b:.2f}\")\n print(f\"ss capital = {self.Kss_b:.2f}\")\n print(f\"ss tfp = {self.TFPss_b:.2f}\")\n print(f\"ss wage = {self.w_ss_b:.2f}\")\n print(f\"entry mass = {self.E_star_b:.3f}\")\n print(f\"avg. firm size = {self.average_firm_size_b:.2f}\")\n \n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\n \n if self.plott:\n #i. initialize\n employed = [4.99, 49.99]\n firm_size_by_employee = np.zeros(len(employed)+1)\n share_employment = np.zeros(len(employed)+1)\n \n \n #i. percentage of firms that employ employed\n \n for i_e in range(len(employed)):\n summ = np.sum(firm_size_by_employee)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\n firm_size_by_employee[i_e] = interpolate - summ\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\n \n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Size of Firms by Firm Size (Number of Employees)')\n plt.savefig('firm_size_rr08.pdf')\n plt.show()\n \n \n #ii. employment percentage by firm size\n for i_e in range(len(employed)):\n summ = np.sum(share_employment)\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\n share_employment[i_e] = interpolate - summ\n share_employment[-1] = 1 - np.sum(share_employment)\n \n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\"%.1f%%\")\n plt.title('Employment Share by Firm Size (Number of Employees)')\n plt.savefig('employment_by_firm_size_rr08.pdf')\n plt.show()\n \n #iii. productivity cdf and employment cdf\n plt.plot(self.grid_s, self.cdf_stationary_b)\n plt.plot(self.grid_s, self.cdf_emp_b)\n plt.title('Stationary CDF' )\n plt.xlabel('Productivity level')\n plt.ylabel('Cumulative Sum')\n plt.legend(['Firms by Productivity Level','Share of Employment'])\n plt.savefig('cdf_rr08.pdf')\n plt.show()\n \n \n \n #c. distortion case\n \n #i. joint pdf of productivity state and tau \n self.make_joint_pdf(0)\n \n #ii. compute stationary economy for each tau\n \n for idx, tau in enumerate(self.tau_vector):\n \n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\n self.tau_s[idx] = self.find_subsidy_rate(tau)\n \n # set tax system with newly found tau_s and given tau\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \n self.set_tax_system(tauv) #set tax system\n \n #v. distorted stationary equilibrium\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\n _, _ = self.solve_stationary_equilibrium()\n \n print(\"\\n-----------------------------------------\")\n print(\"Distorted Stationary Equilibrium\")\n print(\"-----------------------------------------\\n\")\n if self.distortion_case == 1:\n print(\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\")\n print(\"(low productivity firms recieve subsidy, high productivity taxed)\\n\")\n elif self.distortion_case == 2:\n print(\"Tax/Subidy Positively Correlated with Firm Level Producitivity\")\n print(\"(high productivity firms recieve subsidy, low productivity taxed)\\n\")\n if self.policy_type == 1 :\n print(\"Tax Type: Tax on output\\n\")\n elif self.policy_type == 2 :\n print(\"Tax Type: Tax on capital\\n\")\n elif self.policy_type == 3 :\n print(\"Tax Type: Tax on labor\\n\")\n print(f\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\")\n print(f\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\")\n print(f\"fraction of firms excempt = {self.excempt_frac:.2f}\")\n print(\"-----------------------------------------\\n\")\n \n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\n [], \n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \"Tax = \"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\n \n\n t1 = time.time()\n print(f'\\nTotal Run Time: {t1-t0:.2f} seconds')","def plan_production() -> str:\r\n monthly_forecasts = app.config[\"monthly_sales_forecasts\"]\r\n # True if the dictionary monthly_forecasts is empty.\r\n if not monthly_forecasts:\r\n return (\"No prediction has been made. Please click first on the \"\r\n + \"button 'First: predict sales' on the tracking screen.\")\r\n batches = app.config[\"batches\"]\r\n tanks = app.config[\"tanks\"]\r\n inventory = app.config[\"inventory\"]\r\n # Holds actual number of beers in inventory and actual number of beers that\r\n # will be finished in the next three months on basis of production stage.\r\n three_month_end_inv = {\"dunkers\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"pilsner\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"red_helles\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0}}\r\n # Calculates when product. stage will be finished for 3 consecutive months.\r\n for batch in batches.values():\r\n # True if batch is already finished, continue with next batch.\r\n if batch.bottles_put_in_inventory:\r\n continue\r\n # Implies batch isn't assigned to phase, values are set in next if-else\r\n end_phase4 = \"\"\r\n end_phase3_4 = \"\"\r\n end_phase2_4 = \"\"\r\n end_phase1_4 = \"\"\r\n # Calculates end time of each batch assuming that each batch goes\r\n # directly to the next production phase without any delays.\r\n # True if the batch is in production phase 4 (bottling).\r\n if batch.time_end_phase4 != \"\":\r\n # Phase 4 ends when time_end_phase4 is reached.\r\n end_phase4 = batch.time_end_phase4\r\n # Else True if the batch is in production phase 3 (conditioning).\r\n elif batch.time_end_phase3 != \"\":\r\n # If the product is in phase 3, then the product will be finished\r\n # after the duration of phase 3 + phase 4 ends.\r\n # One minute per bottle (1/60) and each bottle contains 0.5 litres.\r\n duration_p4 = (1 / 60) * batch.volume * 2 # In hours.\r\n end_phase3_4 = batch.time_end_phase3 + timedelta(hours=duration_p4)\r\n # Else True if the batch is in production phase 2 (fermentation).\r\n elif batch.time_end_phase2 != \"\":\r\n # P2 product will be finished after duration p2 + p3 + p4 ends.\r\n duration_p3 = 336 # In hours.\r\n duration_p4 = (1 / 60) * batch.volume * 2\r\n end_phase2_4 = (batch.time_end_phase2\r\n + timedelta(hours=duration_p3)\r\n + timedelta(hours=duration_p4))\r\n # Else True if the batch is in production phase 1 (hot brewing).\r\n elif batch.time_end_phase1 != \"\":\r\n # P1 product will be finished after durat. p1 + p2 + p3 + p4 ends.\r\n duration_p2 = 672 # In hours.\r\n duration_p3 = 336\r\n duration_p4 = (1 / 60) * batch.volume * 2\r\n end_phase1_4 = (batch.time_end_phase1\r\n + timedelta(hours=duration_p2)\r\n + timedelta(hours=duration_p3)\r\n + timedelta(hours=duration_p4))\r\n # Gets current month and is incremented for each iteration of for loop\r\n # to represent month number of this_month, next_month, and third_month.\r\n incre_month = datetime.now().month\r\n months = [\"this_month\", \"next_month\", \"third_month\"]\r\n # Calculates end of month inv. values for this, next, and third month.\r\n for index, _ in enumerate(months):\r\n # * 2 to get the number of bottles, 1 litre equals 2 bottles.\r\n volume = batch.volume * 2\r\n # True if phase4 has been reached and end month matches inc month.\r\n if end_phase4 != \"\" and end_phase4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p3 has been reached and end month matches inc month.\r\n elif end_phase3_4 != \"\" and end_phase3_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p2 has been reached and end month matches inc month.\r\n elif end_phase2_4 != \"\" and end_phase2_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n # Elif True if p1 has been reached and end month matches inc month.\r\n elif end_phase1_4 != \"\" and end_phase1_4.month == incre_month:\r\n three_month_end_inv[batch.beer_type][months[index]] += volume\r\n incre_month += 1\r\n # If month number is incremented to 13, it is set to 1 (January).\r\n if incre_month == 13:\r\n incre_month = 1\r\n # Adds actual inventory quantities to calculated end of month quantities.\r\n for beer_type in three_month_end_inv:\r\n inventory_item_quantity = inventory.get_inv_items_quantity(beer_type)\r\n inventory_quantity = inventory_item_quantity[\"num\"]\r\n # Actual inventory quantities are only added to this_month inventory.\r\n three_month_end_inv[beer_type][\"this_month\"] += inventory_quantity\r\n # Holds three months (end of month) forecasted sales values.\r\n three_month_forecast = {\"dunkers\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"pilsner\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0},\r\n \"red_helles\": {\"this_month\": 0, \"next_month\": 0,\r\n \"third_month\": 0}}\r\n # Builds date-index to access forecast value for this, next, and 3rd month.\r\n # 1. Builds date-index for this month.\r\n # Gets current datetime.\r\n current_datetime = datetime.now()\r\n # Gets current month.\r\n current_month = current_datetime.month\r\n # Gets current year.\r\n current_year = current_datetime.year\r\n # Creates date-index to access forecast value for this month.\r\n dt1st_month = datetime(current_year, current_month, 1) # 1st day of month.\r\n # Gets number of days of the current month.\r\n number_days = monthrange(current_year, current_month)[1]\r\n # 2. Builds date-index for next month.\r\n # Gets next datetime.\r\n next_datetime = current_datetime + timedelta(days=number_days)\r\n # Gets next month.\r\n next_month = next_datetime.month\r\n # Gets year in next month.\r\n next_months_year = next_datetime.year\r\n # Creates date-index to access forecast value for next month.\r\n dt2nd_month = datetime(next_months_year, next_month, 1)\r\n # Gets number of days of the next month.\r\n number_days = monthrange(next_months_year, next_month)[1]\r\n # 3. Builds date-index for 3rd month.\r\n # Gets 3rd datetime.\r\n third_datetime = next_datetime + timedelta(days=number_days)\r\n # Gets 3rd month.\r\n third_month = third_datetime.month\r\n # Gets year in 3rd month.\r\n third_months_year = third_datetime.year\r\n # Creates date-index to access forecast value for 3rd month.\r\n dt3rd_month = datetime(third_months_year, third_month, 1)\r\n # Gets and stores forecast values for three months in three_month_forecast.\r\n for beer_type in monthly_forecasts:\r\n forecast_1st = monthly_forecasts[beer_type].predicted_mean[dt1st_month]\r\n forecast_2nd = monthly_forecasts[beer_type].predicted_mean[dt2nd_month]\r\n forecast_3rd = monthly_forecasts[beer_type].predicted_mean[dt3rd_month]\r\n try:\r\n three_month_forecast[beer_type][\"this_month\"] = int(forecast_1st)\r\n three_month_forecast[beer_type][\"next_month\"] = int(forecast_2nd)\r\n three_month_forecast[beer_type][\"third_month\"] = int(forecast_3rd)\r\n except ValueError as error:\r\n app.config[\"logger\"].error(error)\r\n # Holds 3 months differ. between forecast and finished inv. for each beer.\r\n diff_3months_forecast_actual = {\"dunkers\": 0, \"pilsner\": 0,\r\n \"red_helles\": 0}\r\n # Calculates for each beer differ. between forecast and finished inventory.\r\n for beer_type in three_month_end_inv:\r\n # Holds finished inventory quantity for 3 months per beer type.\r\n fin_inv_beer_3months = 0\r\n # Holds forecasted sales quantity for 3 months per beer type.\r\n forecast_beer_3months = 0\r\n # 2nd for loop to iterate over dict in dict to calculate difference.\r\n for month in three_month_end_inv[beer_type]:\r\n fin_inv_beer_3months += three_month_end_inv[beer_type][month]\r\n forecast_beer_3months += three_month_forecast[beer_type][month]\r\n diff_beer_3months = fin_inv_beer_3months - forecast_beer_3months\r\n diff_3months_forecast_actual[beer_type] = diff_beer_3months\r\n # Determines which beer should be produced next;\r\n # beer type with highest negative difference between finished inventory and\r\n # sales forecast is recommended to be produced if equipment is available.\r\n # Gets beer type with highest negative difference.\r\n produce_beer = min(diff_3months_forecast_actual,\r\n key=lambda beer: diff_3months_forecast_actual[beer])\r\n used_tanks = []\r\n # Adds the names of all used tanks to used_tanks' list.\r\n for batch in batches.values():\r\n # True if tank is used.\r\n if batch.phase_current_tank != \"\":\r\n used_tanks.append(batch.phase_current_tank)\r\n all_tanks = tanks.get_tank_names()\r\n available_tanks = [tank for tank in all_tanks if tank not in used_tanks]\r\n capable_tanks = {}\r\n # Checks if tank with right capability is available.\r\n for tank_name in available_tanks:\r\n # Uses tank_name to get value of Tanks' instance var with same name.\r\n tank_value = tanks.get_tank_value(tank_name)\r\n # True if tank with right capability is available.\r\n if \"ferm\" in tank_value[\"capability\"]:\r\n # Puts tank's volume into capable_tanks dictionary.\r\n capable_tanks[tank_name] = tank_value[\"volume\"]\r\n # Selects tank with highest volume if tank with right capab. is available.\r\n if capable_tanks:\r\n use_tank = max(capable_tanks, key=lambda beer: capable_tanks[beer])\r\n use_tank_volume = capable_tanks[use_tank]\r\n else:\r\n use_tank = \"'currently no tank with right capability available'\"\r\n use_tank_volume = 0\r\n # Creates recommendation for the user.\r\n recommendation = (\"Based on the three-month forecast and production phases\"\r\n + \", available tanks, capabilities and volumes, it is \"\r\n + \"recommended to produce <b>{0}</b> in tank <b>{1}</b> \"\r\n + \"next.\").format(produce_beer, use_tank)\r\n # Creates reasoning for the user.\r\n # Creates HTML table containing three months end inventory.\r\n html_3months_end_inv_table = update_three_months_table(three_month_end_inv)\r\n # Creates HTML table containing three months forecasted sales.\r\n html_3months_foreca_table = update_three_months_table(three_month_forecast)\r\n reason = (\"Actual number of beers in inventory and actual number of beers \"\r\n + \"that will be finished in the next three months are:<br>\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th></th>\r\n <th>This month</th>\r\n <th>Next month</th>\r\n <th>Third month</th>\r\n </tr>\"\"\" + html_3months_end_inv_table + \"</table><br>\"\r\n + \"Three months forecasted sales (in bottles) are:\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th></th>\r\n <th>This month</th>\r\n <th>Next month</th>\r\n <th>Third month</th>\r\n </tr>\"\"\" + html_3months_foreca_table + \"</table><br>\"\r\n + \"Beer type with highest difference between forecast and \"\r\n + \"finished inventory is recommended to be produced if \"\r\n + \"equipment is available. The difference is (in bottles):<br>\"\r\n + \"\"\"<table>\r\n <tr>\r\n <th>Dunkers</th>\r\n <th>Pilsner</th>\r\n <th>Red Helles</th>\r\n </tr>\r\n <tr>\r\n <td>{0}</td>\r\n <td>{1}</td>\r\n <td>{2}</td>\r\n </tr></table><br>\r\n \"\"\".format(diff_3months_forecast_actual[\"dunkers\"],\r\n diff_3months_forecast_actual[\"pilsner\"],\r\n diff_3months_forecast_actual[\"red_helles\"])\r\n + \"Available tank(s) with right capability is/are:<b>\"\r\n + str(capable_tanks) + \"</b>, where the highest available \"\r\n + \"volume is <b>{}</b> litres. \".format(use_tank_volume)\r\n + (\"Thus, it is recommended to produce <b>{0}</b> in tank \"\r\n + \"<b>{1}</b>.\").format(produce_beer, use_tank))\r\n return (\"\"\"<style>\r\n h1, h2, h3 {\r\n font-family: arial, sans-serif;\r\n }\r\n table {\r\n font-family: arial, sans-serif;\r\n border-collapse: collapse;\r\n width: 100%;\r\n }\r\n td, th {\r\n border: 1px solid #dddddd;\r\n text-align: left;\r\n padding: 8px;\r\n }\r\n tr:nth-child(even) {\r\n background-color: #dddddd;\r\n }\r\n </style>\r\n <h2>Plan production</h2>\"\"\"\r\n + recommendation\r\n + \"<br><br><b>Reasoning:</b></br>\"\r\n + reason\r\n + \"\"\"<form action=\"/\" method=\"POST\">\r\n <input type=\"hidden\">\r\n <br>\r\n <input type=\"submit\" value=\"Go back to tracking screen\">\r\n </form>\"\"\")","def ex13():\n\n while True:\n try:\n principal = decimal.Decimal(input('What is the principal amount? '))\n break\n except decimal.InvalidOperation:\n print('Enter a valid principal')\n\n while True:\n try:\n rate = decimal.Decimal(input('What is the rate? '))\n break\n except decimal.InvalidOperation:\n print('Enter a valid rate of interest')\n\n while True:\n try:\n term = int(input('What is the number of years? '))\n term = decimal.Decimal(term)\n break\n except ValueError:\n print('Enter a valid number of years')\n\n while True:\n try:\n frequency = int(input('What is the number of times interest is compounded per year? '))\n frequency = decimal.Decimal(frequency)\n break\n except ValueError:\n print('Enter a valid frequency')\n\n amount = calculate_amount(principal, rate, term, frequency)\n\n print('${} invested at {}% for {} years'.format(principal, rate, term))\n print('compounded {} times per year is ${}'.format(frequency, amount))","def solve(n):\r\n c=0\r\n Ans=0\r\n while c<=n:\r\n if isLychrel(c):\r\n Ans+=1\r\n c+=1\r\n return Ans","def price_change_deviation_2_rule(_m, y):\r\n\r\n if y == m.Y.first():\r\n return m.z_p2[y] >= m.YEAR_AVERAGE_PRICE_0 - m.YEAR_AVERAGE_PRICE[y]\r\n else:\r\n return m.z_p2[y] >= m.YEAR_AVERAGE_PRICE[y - 1] - m.YEAR_AVERAGE_PRICE[y]","def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\n if not self.dates:\n self.dates = ['2010-01-01', '2012-12-31']\n self.load_data()\n\n num_months = len(self.df_all)\n first_purchase = True\n result = {}\n baseline_result = {}\n self.baseline_values = [0]\n self.update_values = [0]\n months = []\n\n # Define dataframe to save output data \n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\n self.opt_results_df = pd.DataFrame(columns=headers)\n row = []\n\n self.price_df = pd.DataFrame(columns=self.stocks)\n\n # Initialize the plot\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\n plt.xticks(list(range(0, num_months, 2)), \n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\n plt.locator_params(axis='x', nbins=num_months/2)\n plt.plot(list(range(0, num_months)), [0]*(num_months), \n color='red', label=\"Break-even\", linewidth=0.5)\n\n for i in range(3, num_months):\n\n # Look at just the data up to the current month\n df = self.df_all.iloc[0:i+1,:].copy()\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\n print(\"\\nDate:\", df.last_valid_index())\n months.append(df.last_valid_index().date()) \n\n if first_purchase:\n budget = self.budget\n initial_budget = self.budget\n baseline_shares = (budget / baseline_df_current.iloc[-1])\n baseline_result = {self.baseline[0]: baseline_shares} \n else:\n # Compute profit of current portfolio\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \n self.update_values.append(budget - initial_budget)\n\n # Compute profit of fund portfolio\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \n for s in self.baseline]) \n self.baseline_values.append(fund_value - initial_budget)\n\n self.budget = budget \n\n self.load_data(df=df)\n\n self.price_df.loc[i-2] = list(self.price.values)\n\n # Output for user on command-line and plot\n update_values = np.array(self.update_values, dtype=object)\n baseline_values = np.array(self.baseline_values, dtype=object)\n plt.plot(range(3, i+1), update_values, \n color='blue', label=\"Optimized portfolio\")\n plt.plot(range(3, i+1), baseline_values, \n color='gray', label=\"Fund portfolio\", linewidth=0.5)\n \n if first_purchase:\n plt.legend(loc=\"lower left\")\n plt.title(\"Start: {start}, End: {end}\".format\\\n (start=self.df_all.first_valid_index().date(), \n end=self.df_all.last_valid_index().date()))\n\n plt.savefig(\"portfolio.png\")\n plt.pause(0.05)\n \n # Making solve run\n if self.model_type == 'DQM':\n print(f\"\\nMulti-Period DQM Run...\")\n \n self.build_dqm()\n self.solution['DQM'] = self.solve_dqm()\n result = self.solution['DQM']\n else:\n print(f\"\\nMulti-Period CQM Run...\")\n\n # Set budget to 0 to enforce that portfolio is self-financing \n if self.t_cost and not first_purchase:\n self.budget = 0 \n\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \n min_return=min_return,\n init_holdings=init_holdings)\n result = self.solution['CQM']\n init_holdings = result['stocks']\n\n # Print results to command-line\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\n returns = result['return']\n variance = result['risk'] \n\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\n [result['stocks'][s] for s in self.stocks] + \\\n [variance, returns] \n self.opt_results_df.loc[i-2] = row \n \n first_purchase = False\n\n print(self.opt_results_df)\n print(f'\\nRun completed.\\n')\n\n plt.savefig(\"portfolio.png\")\n plt.show(block=False)","def curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff):\n\t# price dependent\n\tpdm = curPrice - priceMin\n\tpdp = curPrice - prevPrice\n\tq = demandIntcpt + k1 * pdm + k2 * pdm * pdm - a * shock(plus(pdp)) + b * shock(minus(pdp)) \n\t\n\t# cyclic \n\tq += demCycAmp * math.sin(2.0 * math.pi * coff / demCycPer)\n\t\n\t# random\n\tq += np.random.normal(0, randDemSd)\n\t\n\tq = plus(q)\n\treturn q","def ftcs(_x,_y,_cs,_dx,_dt):\n #todo: in a loop ... think about a more pythonic way to do this\n\n # s = _cs * _dt / (2. * _dx)\n # next_y = np.zeros(np.shape(_y)) #next time step\n # nLen = len(_y)\n # for n in range(nLen):\n # n_next = (n + 1) if n < (nLen-1) else 0\n # n_prev = (n - 1) if n > 0 else nLen-1\n #\n # next_y[n] = _y[n] - s*(_y[n_next] - _y[n_prev])\n #\n # print(n, s, next_y[n], _y[n], _y[n_next], _y[n_prev])\n #\n # next_y = _y[:] - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\n #\n #\n # return next_y\n\n #this can get out of hand fast (overflow), so will limit the max value\n if np.max(_y) > 1e30:\n _y /= 1e30 #rescale, but keep shape (it is a mess anyway, so there is no real harm)\n\n s = _cs * _dt / (2. * _dx)\n next_y = _y[:] - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\n\n\n return next_y","def find_end_year(self, der_list):\n project_start_year = self.start_year\n user_given_end_year = self.end_year\n # (1) User-defined (this should continue to be default)\n if self.horizon_mode == 1:\n self.end_year = user_given_end_year\n # (2) Auto-calculate based on shortest equipment lifetime. (No size optimization)\n if self.horizon_mode == 2:\n shortest_lifetime = 1000 # no technology should last 1000 years -- so this is safe to hardcode\n for der_instance in der_list:\n shortest_lifetime = min(der_instance.expected_lifetime, shortest_lifetime)\n if der_instance.being_sized():\n TellUser.error(\"Analysis horizon mode == 'Auto-calculate based on shortest equipment lifetime', DER-VET will not size any DERs \" +\n f\"when this horizon mode is selected. {der_instance.name} is being sized. Please resolve and rerun.\")\n self.end_year = pd.Period(year=0, freq='y') # cannot preform size optimization with mode==2\n self.end_year = project_start_year + shortest_lifetime-1\n # (3) Auto-calculate based on longest equipment lifetime. (No size optimization)\n if self.horizon_mode == 3:\n longest_lifetime = 0\n for der_instance in der_list:\n if der_instance.technology_type != 'Load':\n longest_lifetime = max(der_instance.expected_lifetime, longest_lifetime)\n if der_instance.being_sized():\n TellUser.error(\"Analysis horizon mode == 'Auto-calculate based on longest equipment lifetime', DER-VET will not size any DERs \" +\n f\"when this horizon mode is selected. {der_instance.name} is being sized. Please resolve and rerun.\")\n self.end_year = pd.Period(year=0, freq='y') # cannot preform size optimization with mode==3\n self.end_year = project_start_year + longest_lifetime-1\n return self.end_year","def dY_dt(self, y, t=0):\n\t\t \n\t\t#variables\n\t\tpSgg = y[0] / float(sum(y))\n\t\tpSgh = y[3] / float(sum(y))\n\t\tpSh = y[3] / float(y[3] + y[4] + y[5])\n\t\t\n\t\t#exit flows\n\t\texit_Sg = y[0] * (1 / time_active) * t \n\t\texit_Pg = y[1] * (1 / time_active) * t\n\t\texit_PPg = y[2] * (1 / time_active) * t\n\t\texit_Sh = y[3] * (1 / time_active) * t\n\t\texit_Ph = y[4] * (1 / time_active) * t\n\t\texit_PPh = y[5] * (1 / time_active) * t\n\t\t#episodic flows\n\t\tSg_to_h = y[0] * (1 / tin_g) * t\n\t\tPg_to_h = y[1] * (1 / tin_g) * t\n\t\tPPg_to_h = y[2] * (1 / tin_g) * t\n\t\tSh_to_g = y[3] * (1 / tin_h) * t\n\t\tPh_to_g = y[4] * (1 / tin_h) * t\n\t\tPPh_to_g = y[5] * (1 / tin_h) * t\n\t\t#entry flows\n\t\tinto_g = new_g * t\n\t\tinto_h = new_h * t\n\t\t#infection flows\n\t\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\n\t\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\n\t\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\n\t\t#stage progression flows\n\t\tPg_to_PPg = y[1] * D1 * t\n\t\tPPg_to_d = y[2] * D2 * t\n\t\tPh_to_PPh = y[4] * D1 * t\n\t\tPPh_to_d = y[5] * D2 * t\n\t\t\t\n\t\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\n\t\t\t\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\n\t\t\t\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\n\t\t\t\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\n\t\t\t\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\n\t\t\t\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\n\t\n\t\treturn state","def solve(num_wizards, num_constraints, wizards, constraints):\n print(\"starting time\")\n start = time.time()\n print(\"hello\")\n end = time.time()\n print(\"time taken\",end - start)\n random.shuffle(wizards)\n assignment = wizards\n loop_counter = 0\n temperature = 10.0\n while not numSat(constraints, assignment) == len(constraints):\n loop_counter += 1\n if loop_counter % 500 == 0:\n print(\"numSat\", numSat(constraints, assignment))\n print(\"loops\",loop_counter)\n print(\"time taken\", time.time()-start)\n a = random.sample([i for i in range(len(wizards))], 1)\n b = random.sample([i for i in range(len(wizards))], 1)\n new_assignment = swap(assignment, a[0], b[0])\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\n if delta < 0:\n print(\"delta negative\")\n assignment = new_assignment\n else: \n # print(\"sample greater than expo\")\n sample = random.uniform(0.0,1.0)\n expo = np.exp(-1*float(delta) / temperature)\n if sample < expo:\n # print(\"sample less than expo\")\n assignment = new_assignment\n temperature -= 0.2\n\n print(\"Solved BITCH! numSat:\", numSat(constraints, assignment))\n return assignment","def capital_allocation_strategy(self, coins_to_invest, available_capital):\n coins_available_capital = 0\n used_capital = 0\n\n # Count positions which capital size is not equal to max capacity of investment\n total_positions_count = len(coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False])\n\n if total_positions_count > 0:\n\n # Divide all available capital equally by all the positions\n coins_available_capital = available_capital / total_positions_count\n\n # Stopping condition: If there are no more position not fully invested or coins_available_capital is smaller then min investment\n if total_positions_count == 0 or coins_available_capital < self.min_investment:\n return coins_to_invest\n\n # Iterate all coins to invest which are not fully invested\n for index, coins_prediction in coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False].copy().iterrows():\n\n coin_symbol = coins_prediction['coin_symbol']\n\n success, coin_current_volume = self.fetch_coins_24h_volumeto(coin_symbol)\n\n # exit if failed to fetch volume\n if not success:\n raise Exception\n\n if coin_current_volume == 0.0:\n logger.debug(\"Volume is zero. Not investing in: {}, at time: {}\".format(coin_symbol,\n TimeHelper.epoch_to_date_time(\n self.time_ticker.current_time)))\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\n continue\n\n # Volume boundary of the specific coin symbol at the specific time\n coins_max_capital_volume_boundary = self.max_percent_out_of_volume * coin_current_volume\n\n # If the volume boundary is smaller then available capital, then there is maximum capital in current position means = fully invested\n if coins_max_capital_volume_boundary < coins_available_capital:\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\n max_amount_to_invest_in_coin = coins_max_capital_volume_boundary\n else:\n max_amount_to_invest_in_coin = coins_available_capital\n\n # Risk indicator which decreases positions size according to probability\n capital_percent = self.percent_capital_according_to_probability(coins_prediction[Consts.PROB_POSITIVE_HEADER],\n coins_prediction[Consts.PROB_NEGATIVE_HEADER],\n coins_prediction['order_type'])\n\n current_capital_to_invest_in_position = capital_percent * max_amount_to_invest_in_coin\n\n # Add to capital to invest for current row\n coins_to_invest.loc[index, Consts.CAPITAL_TO_INVEST] = coins_to_invest.loc[\n index, Consts.CAPITAL_TO_INVEST] + current_capital_to_invest_in_position\n\n used_capital += current_capital_to_invest_in_position\n\n available_capital -= used_capital\n\n return self.capital_allocation_strategy(coins_to_invest, available_capital)","def lax_wen(_x,_y,_cs,_dx,_dt):\n\n s = _cs * _dt / (2. * _dx)\n s2 = (_cs**2.) * (_dt**2.) / (2. * (_dx**2.))\n\n next_y = _y[:] - s*(np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1])) \\\n + s2*(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1]) - 2*_y[:])\n\n return next_y","def AmericanBinomialPricer(pricing_engine, option, data):\r\n\r\n\r\n expiry = option.expiry\r\n strike = option.strike\r\n (spot, rate, volatility, dividend) = data.get_data()\r\n steps = pricing_engine.steps\r\n nodes = steps + 1\r\n dt = expiry / steps \r\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \r\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\r\n pu = (np.exp(rate * dt) - d) / (u - d)\r\n pd = 1 - pu\r\n disc = np.exp(-rate * expiry)\r\n spotT = 0.0\r\n payoffT = 0.0\r\n callT = 0.0\r\n putT= 0.0\r\n #call\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n callT = max(callT, spotT-strike)\r\n price = disc * payoffT\r\n #put\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n putT = max(putT, strike-spot)\r\n price = disc * payoffT\r\n \r\n return price","def test_capital_letters(self):\n for i in range(5):\n price = find_cheapest_price(\"STAR WARS: EPISODE VI - RETURN OF THE JEDI\")\n if price is \"69.5\":\n break\n time.sleep(1)\n self.assertTrue(price == \"69.5\")","def solve(self):","def money_in_bank_given(initial, time_weeks):\n return initial * 2 ** time_weeks","def curProfit(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, unitCost, coff):\n\treturn curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff) * (curPrice - unitCost)","def solution(self):\n return [(\"the\", 1561900)] * 100","def contComp(periods, pr=10, pv=100):\n r = pr / 100 \n return fmtFV(pv * exp(r * periods))","def sl(*x):\r\n cost = float(input(\"Please Enter the Cost Of The Asset: \"))\r\n rv = float(input(\"Please Enter Estimated Residual Value Of The Asset: \"))\r\n life = float(input(\"Please Enter Estimated Useful Life Of The Asset (Years): \"))\r\n r = (float(cost) - float(rv)) / float(life)\r\n dd = float(cost)-float(rv)\r\n fg = float(r)/float(12)\r\n print \">> Your Depreciable Cost is\",dd\r\n print \">> Your Annual Depreciation is \",r\r\n print \">> Your Monthly Depreciation is\",fg\r\n for i in x:\r\n lg = float(fg)*float(i)\r\n print \">> Your Depreciation For\",i,\"Months is\",lg","def backtest(dic_data, long_and_short=True, rebal_freq='M'):\n\n\n if long_and_short == False:\n\n prices = dic_data[0]\n l_wgt = dic_data[1]\n initial_ammount = 100\n returns = prices.pct_change()\n\n # fazemos isso para que o peso do dia anterior vá para o próximo dia.\n # Importante, pois quando pegarmos o primeiro dia de cada mês para rebalancear, os pesos serão do último dia do mês anterior\n l_wgt = l_wgt.shift(1)\n\n # fazemos isso para garantir que as primeiras linhas nao contenham somente NAN's\n # caso isso ocorresse, o backtest nao avancaria\n\n l_wgt.dropna(axis=0, how='all', inplace=True)\n\n long_ini_period = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).nth(0)\n long_ini_period.index = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).head(1).index\n\n qty = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]])\n quota_value = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]]) * prices.loc[\n long_ini_period.index[1]]\n\n dic_qty_long = {}\n dic_quota_value_long = {}\n dic_saldo_long = {}\n\n dic_qty_long[long_ini_period.index[1]] = qty\n dic_quota_value_long[long_ini_period.index[1]] = quota_value\n dic_saldo_long[long_ini_period.index[1]] = qty\n\n list_rebal_dates = long_ini_period.loc[\n long_ini_period.index[long_ini_period.index > quota_value.name][0:]].index\n\n k = 0\n for i in returns.index[returns.index > quota_value.name]:\n\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\n print(str(i) + ' hora de rebalancear')\n list_prices = prices.index.to_list()\n position = list_prices.index(list_rebal_dates[k])\n position_yesterday = position - 1\n prices_in_the_day = prices.iloc[position_yesterday]\n qty_in_the_day = dic_qty_long[list(dic_qty_long.keys())[-1]]\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\n new_pos = long_ini_period.iloc[k]\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\n new_wgt = long_ini_period.iloc[k + 2]\n aum_in_the_day = aum_in_the_day.sum()\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\n new_qty[np.isnan(new_qty)] = 0\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\n saldo = new_qty - qty_in_the_day\n qty = qty_in_the_day + saldo\n dic_qty_long[i] = qty\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_saldo_long[i] = saldo\n print(aum_in_the_day)\n\n # multiplicando pelos retornos do dia\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_qty_long[i] = qty\n soma = quota_value.sum()\n\n k += 1\n\n\n else:\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_qty_long[i] = qty\n soma = quota_value.sum()\n print(soma)\n\n df_quota_long = pd.DataFrame(pd.concat(dic_quota_value_long, axis=0)).reset_index()\n df_quota_long.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\n df_quota_long = df_quota_long.pivot(index='date', columns='ticker', values='quota')\n df_quota_long['total_aum'] = df_quota_long.sum(axis=1)\n\n df_saldo_long = pd.DataFrame(pd.concat(dic_saldo_long, axis=0)).reset_index()\n df_saldo_long.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\n df_saldo_long = df_saldo_long.pivot(index='date', columns='ticker', values='qty')\n df_saldo_long['total_qty'] = df_saldo_long.sum(axis=1)\n\n return (df_quota_long, df_saldo_long)\n\n else:\n\n prices = dic_data[0]\n l_wgt = dic_data[1]\n s_wgt = dic_data[2]\n initial_ammount = 100\n returns = prices.pct_change()\n\n # fazemos isso para que o peso do dia anterior vá para o próximo dia.\n # Importante, pois quando pegarmos o primeiro dia de cada mês para rebalancear, os pesos serão do último dia do mês anterior\n l_wgt = l_wgt.shift(1)\n s_wgt = s_wgt.shift(1)\n\n # fazemos isso para garantir que as primeiras linhas nao contenham somente NAN's\n # caso isso ocorresse, o backtest nao avancaria\n\n l_wgt.dropna(axis=0, how='all', inplace=True)\n s_wgt.dropna(axis=0, how='all', inplace=True)\n\n # Long\n long_ini_period = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).nth(0)\n long_ini_period.index = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).head(1).index\n\n qty = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]])\n quota_value = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]]) * prices.loc[\n long_ini_period.index[1]]\n\n dic_qty_long = {}\n dic_quota_value_long = {}\n dic_saldo_long = {}\n\n dic_qty_long[long_ini_period.index[1]] = qty\n dic_quota_value_long[long_ini_period.index[1]] = quota_value\n dic_saldo_long[long_ini_period.index[1]] = qty\n\n list_rebal_dates = long_ini_period.loc[\n long_ini_period.index[long_ini_period.index > quota_value.name][0:]].index\n\n k = 0\n for i in returns.index[returns.index > quota_value.name]:\n\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\n print(str(i) + ' hora de rebalancear')\n list_prices = prices.index.to_list()\n position = list_prices.index(list_rebal_dates[k])\n position_yesterday = position - 1\n prices_in_the_day = prices.iloc[position_yesterday]\n qty_in_the_day = dic_qty_long[list(dic_qty_long.keys())[-1]]\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\n new_pos = long_ini_period.iloc[k]\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\n new_wgt = long_ini_period.iloc[k + 2]\n aum_in_the_day = aum_in_the_day.sum()\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\n new_qty[np.isnan(new_qty)] = 0\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\n saldo = new_qty - qty_in_the_day\n qty = qty_in_the_day + saldo\n dic_qty_long[i] = qty\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_saldo_long[i] = saldo\n print(aum_in_the_day)\n\n # multiplicando pelos retornos do dia\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_qty_long[i] = qty\n soma = quota_value.sum()\n\n k += 1\n\n\n else:\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_qty_long[i] = qty\n print(i)\n\n # Short\n short_ini_period = s_wgt.groupby(pd.DatetimeIndex(s_wgt.index).to_period(rebal_freq)).nth(0)\n short_ini_period.index = s_wgt.groupby(pd.DatetimeIndex(s_wgt.index).to_period(rebal_freq)).head(1).index\n\n qty = (short_ini_period.iloc[1] * initial_ammount / prices.loc[short_ini_period.index[1]])\n quota_value = (short_ini_period.iloc[1] * initial_ammount / prices.loc[short_ini_period.index[1]]) * prices.loc[\n short_ini_period.index[1]]\n\n dic_qty_short = {}\n dic_quota_value_short = {}\n dic_saldo_short = {}\n\n dic_qty_short[long_ini_period.index[1]] = qty\n dic_quota_value_short[short_ini_period.index[1]] = quota_value\n dic_saldo_short[short_ini_period.index[1]] = qty\n\n list_rebal_dates = short_ini_period.loc[\n short_ini_period.index[short_ini_period.index > quota_value.name][0:]].index\n\n k = 0\n for i in returns.index[returns.index > quota_value.name]:\n\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\n print(str(i) + ' hora de rebalancear')\n list_prices = prices.index.to_list()\n position = list_prices.index(list_rebal_dates[k])\n position_yesterday = position - 1\n prices_in_the_day = prices.iloc[position_yesterday]\n qty_in_the_day = dic_qty_short[list(dic_qty_short.keys())[-1]]\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\n new_pos = short_ini_period.iloc[k]\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\n new_wgt = short_ini_period.iloc[k + 2]\n aum_in_the_day = aum_in_the_day.sum()\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\n new_qty[np.isnan(new_qty)] = 0\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\n saldo = new_qty - qty_in_the_day\n qty = qty_in_the_day + saldo\n dic_qty_short[i] = qty\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_short[i] = quota_value\n dic_saldo_short[i] = saldo\n print(aum_in_the_day)\n\n # multiplicando pelos retornos do dia\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_long[i] = quota_value\n dic_qty_long[i] = qty\n soma = quota_value.sum()\n\n k += 1\n\n\n else:\n quota_value = (1 + returns.loc[i]) * quota_value\n dic_quota_value_short[i] = quota_value\n dic_qty_short[i] = qty\n print(i)\n\n df_quota_long = pd.DataFrame(pd.concat(dic_quota_value_long, axis=0)).reset_index()\n df_quota_long.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\n df_quota_long = df_quota_long.pivot(index='date', columns='ticker', values='quota')\n df_quota_long['total_aum'] = df_quota_long.sum(axis=1)\n\n df_saldo_long = pd.DataFrame(pd.concat(dic_saldo_long, axis=0)).reset_index()\n df_saldo_long.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\n df_saldo_long = df_saldo_long.pivot(index='date', columns='ticker', values='qty')\n df_saldo_long['total_qty'] = df_saldo_long.sum(axis=1)\n\n df_quota_short = pd.DataFrame(pd.concat(dic_quota_value_short, axis=0)).reset_index()\n df_quota_short.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\n df_quota_short = df_quota_short.pivot(index='date', columns='ticker', values='quota')\n df_quota_short['total_aum'] = df_quota_short.sum(axis=1)\n\n df_saldo_short = pd.DataFrame(pd.concat(dic_saldo_short, axis=0)).reset_index()\n df_saldo_short.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\n df_saldo_short = df_saldo_short.pivot(index='date', columns='ticker', values='qty')\n df_saldo_short['total_qty'] = df_saldo_short.sum(axis=1)\n\n return (df_quota_long, df_saldo_long, df_quota_short, df_saldo_short)","def OnEndOfAlgorithm(self):\n\n # liquidate all holdings (all unrealized profits/losses will be realized).\n # long and short positions are closed irrespective of profits/losses.\n self.Liquidate(self.currency)","def P2l_rec(ells, cost):\n P22 = 3 * (1 - cost**2)\n P23 = 15 * cost * (1 - cost**2)\n P2l = np.zeros(len(ells))\n P2l[0] = 0.\n P2l[1] = 0.\n P2l[2] = P22\n P2l[3] = P23\n for ell in ells[4:]:\n # print ell, P2l[ell-1], P2l[ell-2]\n P2l[ell] = ((2 * ell - 1) * cost * P2l[ell - 1] -\n (ell + 2 - 1) * P2l[ell - 2]) / (ell - 2)\n return P2l","def main():\n\n # Hypothesis:\n # The `impact` encapsulates the volatility, stability and overall\n # fluctuation of the market; in particular, movements that would\n # affect one's portfolio, e.g. unexpected (i.e. not predicted)\n # increases or drops in prices.\n # For the StrategyLearner should directly affect the learned\n # policy, particularly, in terms of willingness to take risks by\n # betting on the behavior of the market.\n # This can be translated into three metrics:\n # - Number of entries:\n # These should be reduced as market impact increases which\n # shows the learning agent being more cautious about its bets\n # - Cumulative return:\n # Directly related to the point mentioned above, as market\n # impact increases and the agent's willingness to take risks\n # decreaes, so is the overall performance of the strategy\n # - Training episodes:\n # This applies specifically to the Q-Learning agent, but it\n # is interesting to see how as the market impact increases,\n # the number of complete training episodes (i.e. a complete\n # pass on the trading data) is not affected. One would think\n # that the agent would converge faster when the impact is\n # large as it would quickly realize that the most optimal\n # strategy is to not do anything. However, impact does not\n # affect the rate of convergence, but rather the strategy\n # that the agent converges to\n\n # Set the seed for reproducibility\n random.seed(1481090000)\n\n # Experiment parameters\n symbol = 'JPM'\n # In-sample: January 1, 2008 to December 31 2009\n start_date = dt.datetime(2008, 1, 1)\n end_date = dt.datetime(2009, 12, 31)\n starting_value = 100000\n commission = 0.0\n # Values to use to evaluate the effect of the impact\n impact_values = [0.0, 0.005, 0.01, 0.05, 0.1, 0.25, 0.5, 1.0]\n\n all_entries = []\n all_returns = []\n all_episodes = []\n\n for impact in impact_values:\n log.info(\"Evaluating the effect of impact=%s\", impact)\n strategy_learner = StrategyLearner(verbose=False, impact=impact)\n\n log.info(\"Training StrategyLearner\")\n strategy_learner.addEvidence(\n symbol=symbol,\n sd=start_date,\n ed=end_date,\n sv=starting_value\n )\n\n log.info(\"Querying StrategyLearner to generate trades\")\n trades = strategy_learner.testPolicy(\n symbol=symbol,\n sd=start_date,\n ed=end_date,\n sv=starting_value\n )\n\n log.info(\"Transforming StrategyLearner trades into marketsim orders\")\n orders = _convert_trades_to_marketisim_orders(symbol, trades)\n\n log.info(\"Computing portfolio values for %d orders\", orders.shape[0])\n port_vals = compute_portvals(\n orders,\n start_val=starting_value,\n commission=commission,\n impact=impact\n )\n\n cumulative_return = _compute_cumulative_return(port_vals)\n\n all_entries.append(strategy_learner.metadata['entries'])\n all_returns.append(cumulative_return)\n all_episodes.append(strategy_learner.metadata['training_episodes'])\n\n _plot_and_save_number_of_entries_per_impact_value(impact_values, all_entries)\n _plot_and_save_number_of_episodes_per_impact_value(impact_values, all_episodes)\n _plot_and_save_cumulative_return_per_impact_value(impact_values, all_returns)","def boot_strap_back_ccy( sdate,\r\n ccy,\r\n instruments,\r\n Day_Counter ):\r\n convention = BS_Con[ccy]\r\n years_days_cash = convention[\"Cash_Day\"]\r\n swap_freq = convention[\"Swap_Freq\"]\r\n Day_Counter.set_convention(convention[\"Swap\"])\r\n instruments = BS_TF.check_instruments( instruments )\r\n \r\n sdate = str_2_date( sdate )\r\n \r\n flag = False\r\n if BS_TF.check_if_last_day_of_month( sdate ):\r\n flag = True\r\n \"\"\" Sdate stands for the begin of bootstrapping \r\n Inputs structure instruments contains:\r\n 1\\cash rates list of tuple and number of contracts \r\n 2\\future rates list of tuple and number of contracts\r\n 3\\swap rates list of tuple and number of contracts\r\n Structure of rate list looks like (time,rates)\r\n \"\"\"\r\n Cash_Rate = instruments[\"cash\"][0]\r\n Cash_Num = len(Cash_Rate)\r\n \"\"\" NOTE: inputs of futures rate should have one start row \r\n with date and the discount factor is interpolated from \r\n cash rate\r\n \"\"\"\r\n Swap_Rate = instruments[\"swap\"][0]\r\n units = 100\r\n\r\n discount_curve = []\r\n ans_curve = []\r\n discount_curve.append( [sdate,1] )\r\n ans_curve.append([sdate,1])\r\n \"\"\" Remeber par swap key dates location in discount_curve\r\n \"\"\"\r\n \r\n for i in range( 0, int(Cash_Num) ):\r\n \"\"\" Begin bootstrapping from Cash rates\r\n \"\"\"\r\n yearfrac = (Cash_Rate[i][0]-sdate).days/years_days_cash\r\n DF = 1.0/(1.0+Cash_Rate[i][1]/units*yearfrac)\r\n discount_curve.append([Cash_Rate[i][0],DF])\r\n if (Cash_Rate[i][0]-sdate).days <= 200:\r\n ans_curve.append([Cash_Rate[i][0],DF])\r\n\r\n Swap_Rate = BS_TF.augument_by_frequency( Swap_Rate, int(12/swap_freq) )\r\n \r\n \"\"\" Only do interpolation for \r\n the first three swaps \r\n 0.5y, 1y and 1.5y\r\n \"\"\"\r\n \"\"\" Pre-calculate the sum of discount \r\n factors of 0.5y, 1y and 1.5y based \r\n on the current discount curve we have \r\n \"\"\"\r\n sum_df = 0\r\n swap_frequency = relativedelta( months = int(12/swap_freq) )\r\n \"\"\" Move cur_date back to do bootstrapping\r\n \"\"\"\r\n cur_date = sdate\r\n for i in range( 1, len(discount_curve) ):\r\n while cur_date+swap_frequency < Swap_Rate[0][0] \\\r\n and cur_date >= discount_curve[i-1][0] \\\r\n and cur_date < discount_curve[i][0]:\r\n nxt_date = cur_date+swap_frequency\r\n if flag:\r\n nxt_date = BS_TF.last_day_of_month(cur_date+swap_frequency)\r\n yearfrac = Day_Counter.yearfrac( cur_date, nxt_date )\r\n DF = BS_TF.interpolation_act( nxt_date,\r\n discount_curve[i-1][0],\r\n\t\t\t\t\t\t discount_curve[i-1][1],\r\n\t\t\t\t\t\t\t\t\t discount_curve[i][0],\r\n\t\t\t\t\t\t\t\t\t discount_curve[i][1] )\r\n sum_df += DF*yearfrac\r\n ans_curve.append([nxt_date,DF])\r\n cur_date += swap_frequency\r\n if flag:\r\n cur_date = BS_TF.last_day_of_month(cur_date)\r\n \r\n cur_date = Swap_Rate[0][0]\r\n \r\n for i in range( 0, len(Swap_Rate) ):\r\n# if sum_df == 0:\r\n# print(\"Warning Cannot get correct 0.5y, 1y and 1.5y discount factors...\")\r\n# print(\"Current Date:\"+str(cur_date))\r\n# print(ccy)\r\n# print(ans_curve)\r\n \"\"\" Sum of previous discount \r\n factors stored in \"sum_df\"\r\n \"\"\"\r\n nxt_date = cur_date+swap_frequency\r\n if flag:\r\n nxt_date = BS_TF.last_day_of_month(nxt_date)\r\n yearfrac = Day_Counter.yearfrac( cur_date, nxt_date )\r\n rates = Swap_Rate[i][1]\r\n cur_DF = (100-sum_df*rates)/(100+rates*yearfrac)\r\n discount_curve.append([cur_date,cur_DF])\r\n ans_curve.append([cur_date,cur_DF])\r\n sum_df += cur_DF*yearfrac\r\n cur_date += swap_frequency\r\n if flag:\r\n cur_date = BS_TF.last_day_of_month(cur_date)\r\n \r\n sorted_discount_curve = sorted( ans_curve, key = lambda tup: tup[0] )\r\n return sorted_discount_curve","def part_1(rules: Rules) -> int:\n\n happiness, _ = max(generate_arrangements(rules))\n print(f\"part 1: optimal arrangement brings {happiness} happiness\")\n return happiness","def price_change_deviation_1_rule(_m, y):\r\n\r\n if y == m.Y.first():\r\n return m.z_p1[y] >= m.YEAR_AVERAGE_PRICE[y] - m.YEAR_AVERAGE_PRICE_0\r\n else:\r\n return m.z_p1[y] >= m.YEAR_AVERAGE_PRICE[y] - m.YEAR_AVERAGE_PRICE[y - 1]","def initial_conditions_1(x):\n from math import exp\n u1 = 1\n u2 = 2\n return u1 * exp(- x ** 2 / 2) + u2 * exp(- (x - 1) ** 2 / 2)","def solveBaseline(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\n \"\"\"Contains a dummy target for defenders and attackers\"\"\"\n # Add the dummy target\n _dRewards = copy.deepcopy(dRewards)\n _dPenalties = copy.deepcopy(dPenalties)\n _dCosts = copy.deepcopy(dCosts)\n _aRewards = copy.deepcopy(aRewards)\n _aPenalties = copy.deepcopy(aPenalties)\n for m in defenders:\n _dRewards[m].append(0)\n _dPenalties[m].append(0)\n _dCosts[m].append(0)\n for lam in aTypes:\n _aRewards[lam].append(0)\n _aPenalties[lam].append(0)\n targetNumWithDummies = len(_dRewards[0])\n targetRange = list(range(targetNumWithDummies))\n\n # Generate the placements and keys\n placements = getPlacements(defenders, targetNumWithDummies)\n attackerActions = targetRange\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\n\n # Construct the model for each defender\n utilityPerDefender = 0\n utilityPerAttacker = 0\n attackerUtility = []\n dStrat = {}\n models2 = {}\n for m in defenders:\n model2 = Model(f\"defenderStrategy{m}\")\n x = model2.continuous_var_list(keys=targetNumWithDummies, lb=0, ub=1, name=f\"x{m}\")\n h = model2.binary_var_dict(keys=[(lam, k) for lam in aTypes for k in targetRange], lb=0, ub=1, name=f\"h{m}\")\n ul = model2.continuous_var_dict(keys=aTypes, lb=-model2.infinity, name=f\"ua{m}\")\n ud = model2.continuous_var_dict(keys=[lam for lam in aTypes], lb=-model2.infinity, name=f\"ud{m}\")\n objectiveFunction = sum([q[lam] * ud[lam] for lam in aTypes])\n model2.add_constraints([ud[lam] <= utilityDI(m,x,i,_dRewards,_dPenalties,_dCosts) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\"defender utility for lam {lam}, i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([ul[lam] <= utilityLamI(x,lam,i,_aRewards,_aPenalties) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\"lam {lam} utility leq for i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([ul[lam] >= utilityLamI(x,lam,i,_aRewards,_aPenalties) for i in targetRange for lam in aTypes], names=[f\"lam {lam} utility geq, for i {i}\" for i in targetRange for lam in aTypes])\n model2.add_constraints([sum([h[(lam,i)] for i in targetRange]) == 1 for lam in aTypes], names=[f\"h sum is 1 for lam {lam}\" for lam in aTypes])\n model2.add_constraint(sum([x[i] for i in targetRange]) == 1)\n # Solve the model for each defender\n model2.maximize(objectiveFunction)\n model2.solve()\n dStrat[m] = list([float(xVal) for xVal in x])\n models[m] = model2\n # Attacker best response (for each attacker type)\n aStrat = {}\n protectionOdds = probabilityProtected(dStrat, targetNumWithDummies)\n for lam in aTypes:\n expectedUtilities = []\n for i in targetRange:\n expectedUtilities.append(((1-protectionOdds[i])*_aRewards[lam][i]) + (protectionOdds[i]*_aPenalties[lam][i]))\n aStrat[lam] = argmax(expectedUtilities)\n attackerUtility.append(expectedUtilities[aStrat[lam]])\n utilityPerAttacker = sum(attackerUtility)/len(aTypes)\n\n\n # Calculate defender expected utility for attacker best response\n for m in defenders:\n for lam in aTypes:\n attackedTarget = aStrat[lam] # The target attacked by this attacker\n coveredUtility = protectionOdds[attackedTarget] * (_dRewards[m][attackedTarget]) # The expected utility we catch this attacker\n uncoveredUtility = (1-protectionOdds[attackedTarget]) * (_dPenalties[m][attackedTarget]) # The expected utility we miss this attacker\n utilityPerDefender += q[lam] * (coveredUtility + uncoveredUtility)\n expectedCost = sum([dStrat[m][target] * _dCosts[m][target] for target in targetRange])\n utilityPerDefender += expectedCost\n utilityPerDefender /= len(defenders)\n\n return utilityPerDefender, utilityPerAttacker, None","def year_demand_rule(_m, y):\r\n\r\n return sum(m.SCENARIO_DEMAND[y, s] for s in m.S)","def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] is None:\n pass\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\n self.buys_made += 1\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\n self.shares_own = self.stock_quantity\n self.buys_made += 1\n else:\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\n self.final_capital = self.final_capital % data['Close'].iloc[i]\n #print(self.shares_own)\n\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n pass\n else:\n self.final_capital += self.shares_own * data['Close'].iloc[i]\n self.shares_own = 0\n self.sells_made +=1\n #Checar si es el momento mas alto o bajo de ganancias\n if self.shares_own == 0:\n if (self.highest_point is None\n or self.highest_point < self.final_capital):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > self.final_capital\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n else:\n if (self.highest_point is None\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n self.calcRealFinalCapital()\n self.calcDiferencePercentage()","def conway_polynomial(n=100):\n \n xs = []\n ys = []\n for i in range(n):\n x = (i - n/2) / 50\n xs.append(x)\n\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\n\n ys.append(y)\n\n return xs, ys","def CalculateBestSalePercents():\n bestForSmallCenter = (0.0,0.0,0.0,0.0,0.0)\n bestForLargeCenter = (0.0,0.0,0.0,0.0,0.0)\n\n \n\n numRange = numpy.arange(0.0, 1, Problem2.ITER_AMOUNT)\n print(str(numRange))\n # time.sleep(2)\n print()\n X = []\n Y = []\n Z = []\n for lc_sp in numRange:\n for sc_sp in numRange:\n print(f\"Trying large sale prob {lc_sp:.2f} and small sale prob {sc_sp:.2f}\")\n sc_tbp, lc_tbp, actualRainPercent = Problem2.getTotalBusinessPercentForSalePercents(sc_sp, lc_sp)\n # print(f\"{Problem2.GetBestsString('Item',(sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent))}\")\n if (bestForSmallCenter[2] < sc_tbp):\n bestForSmallCenter = (sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent)\n if (bestForLargeCenter[3] < lc_tbp):\n bestForLargeCenter = (sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent)\n X.append(sc_sp)\n Y.append(lc_sp)\n Z.append(sc_tbp)\n resultStr = (f\"\\nFinal results:\\nWeeks per trial: {Problem2.TOTAL_WEEKS}\\n\" \n + f\"{Problem2.GetBestsString('Small Center',bestForSmallCenter)}\" \n + f\"{Problem2.GetBestsString('Large Center',bestForLargeCenter)}\")\n print(resultStr)\n return X,Y,Z","def main():\n locale.setlocale(locale.LC_MONETARY, 'en_US')\n print('Welcome to the Interest Calculator')\n calcualte_interest = 'y'\n while calcualte_interest == 'y':\n loan_amount = prompt_loan_amount()\n interest_rate = prompt_interest_rate()\n interest_amount = loan_amount * interest_rate\n\n print('-' * 50)\n print(f'Loan Amount: {locale.currency(loan_amount, grouping=True):>15}') #15 characters wide; right justified;\n print(f'Interest Rate: {interest_rate:>15.3%}') #15 characters wide; right justified; % format to 3 decimal places\n print(f'Interest Amount: {locale.currency(interest_amount, grouping=True):>15}') #15 characters wide; right justified;\n print('-' * 50)\n calcualte_interest = input('\\nContinue? (y/n): ')","def year_absolute_price_difference_rule(_m, y):\r\n\r\n return m.z_p1[y] + m.z_p2[y]","def BacktestStrategy2(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n recent_max=0 # recent max = 전고점 가격\n for i in range(total_days):\n if i==0: # 첫날은 일단 풀매수\n recent_max=stock_exchange.GetDayHighestPrice(i)\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n else: # 다른날은 전부 전략대로 수행\n recent_max=max(recent_max, stock_exchange.GetDayHighestPrice(i-1)) # 전고점 갱신 확인\n # 만약 어제 종가가 전고점*threshold 미만이라면: 풀매도 \n if (stock_exchange.GetDayClosePrice(i-1) < \n (start_cond_dict['sell_threshold_percent']/100)*recent_max):\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n # 매도조건을 만족 안 시킨 상황에서 n개월 모멘텀이 (+)면: 풀매수 -- n개월이 안지났으면 스킵\n elif (i > start_cond_dict['buy_momentum_days'] and \n stock_exchange.GetDayHighestPrice(i-start_cond_dict['buy_momentum_days']) <\n stock_exchange.GetDayOpenPrice(i)):\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n # 나머지 상황에선 포지션 홀드\n else:\n pass\n invt_daily_list.append(today_invt_dict)\n #print(today_invt_dict) # for debug :)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Experimental Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Experimental Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()","def single_curtailment_each_day_between_2_and_3_am(\n start: datetime, end: datetime, resolution: timedelta\n) -> DataFrame:\n opportunity_start_time = \"2:00\"\n opportunity_end_time = \"3:00\"\n imbalance_value = 100 # MW\n imbalance_price_between_2_and_3_am = 10 # EUR/MWh\n df = initialize_df(\n columns=[\"Imbalance (in MW)\", \"Price (in EUR/MWh)\"],\n start=start,\n end=end,\n resolution=resolution,\n )\n df[\"Imbalance (in MW)\"].iloc[\n df.index.indexer_between_time(\n start_time=opportunity_start_time,\n end_time=opportunity_end_time,\n include_end=False,\n )\n ] = imbalance_value\n df[\"Price (in EUR/MWh)\"].iloc[\n df.index.indexer_between_time(\n start_time=opportunity_start_time,\n end_time=opportunity_end_time,\n include_end=False,\n )\n ] = imbalance_price_between_2_and_3_am\n return df","def exercise_b2_82():\r\n pass","def testPolicy( \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n self, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n symbol=\"jpm\", \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sd=dt.datetime(2008, 1, 1), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ed=dt.datetime(2009, 12, 31), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sv=10000, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ): \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n dates = pd.date_range(sd,ed)\n df_prices = ind.get_price(symbol, dates)\n\n daily_rets = (df_prices / df_prices.shift(1)) - 1\n daily_rets = daily_rets[1:]\n\n\n sd_older = sd - dt.timedelta(days=365)\n dates_older = pd.date_range(sd_older,ed)\n df_prices_older = ind.get_price(symbol, dates_older)\n sd_key = df_prices.index[0]\n sd_index = df_prices_older.index.get_loc(sd_key)\n\n\n df_holdings = df_prices.copy()\n df_holdings['Holdings'] = np.nan\n del df_holdings[symbol]\n # print(df_holdings)\n\n cum_ret_prev = 0\n iters = 0\n\n\n num_bins = len(self.bins)\n\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\n _,_,ind5 = ind.get_MACD(df_prices_older)\n BB = ind1.iloc[sd_index:].values\n CCI = ind2.iloc[sd_index:].values\n SMA_Cross = ind3.iloc[sd_index:].values\n Momentum = ind4.iloc[sd_index:].values\n MACD = ind5.iloc[sd_index:].values\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\n state = x_0 + x_3*10 + x_4*100\n\n\n\n\n\n self.learner.rar = 0\n\n action = self.learner.querysetstate(state[0])\n\n daily_return = daily_rets.iloc[0][symbol]\n df_holdings.iloc[0]['Holdings'] = 0\n\n\n for day_idx in range(1,daily_rets.shape[0]):\n\n # implement action\n cur_price = df_prices.iloc[day_idx-1][symbol]\n next_price = df_prices.iloc[day_idx][symbol]\n action = self.learner.querysetstate(state[day_idx])\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\n\n\n df_holdings.iloc[-1]['Holdings'] = 0\n df_trades = df_holdings.diff()\n df_trades['Trades'] = df_trades['Holdings']\n del df_trades['Holdings']\n df_trades.iloc[0]['Trades'] = 0\n return df_trades","def compute_cost(AL, Y):\n pass","def solve_p2(target: int) -> int:\n mh = 1 + int(target / 10)\n npresents = [0] * mh\n for elf in range(1, mh):\n for h in range(elf, min(mh, elf*50), elf):\n npresents[h] += 11*elf\n if DEBUG:\n print(target, [(i, n) for i, n in enumerate(npresents)])\n for h, np in enumerate(npresents):\n if np >= target:\n return h\n return -1","def test_consecutive_solving(self):\n\n def count_calls(func):\n count_calls.calls = 0\n\n def wrapper(self, *args):\n count_calls.calls += 1\n return func(self)\n\n return wrapper\n\n Skyscraper._sort_permutations = count_calls(Skyscraper._sort_permutations)\n\n sky1 = Skyscraper((2, 2, 1, 3, 2, 2, 3, 1, 1, 2, 2, 3, 3, 2, 1, 3))\n self.assertEqual(sky1.solve(),\n ((1, 3, 4, 2),\n (4, 2, 1, 3),\n (3, 4, 2, 1),\n (2, 1, 3, 4)))\n\n sky2 = Skyscraper((0, 0, 1, 2, 0, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0))\n self.assertEqual(sky2.solve,\n ((2, 1, 4, 3),\n (3, 4, 1, 2),\n (4, 2, 3, 1),\n (1, 3, 2, 4)))\n\n # TODO check if count of calls works appropriately\n self.assertEqual(Skyscraper._sort_permutations.calls, 1)","def bringTwoC(self):\n endC = self.countCannibalOnEnd()\n if endC < 2:\n return None\n else:\n newStart = self.start[0:2] + str(5-endC) + self.start[3]\n newEnd = self.end[0:2] + str(endC-2) + self.end[3]\n return MissionaryState(newStart,newEnd,\"bringTwoC\")","def incumbant_firm(self, wage):\n \n \n \n # a. demand for capital (capital policy function)\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\n \n # b. demand of labor (labor policy function)\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\n \n # c. incumbant profit\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\n \n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\n W = pi / (1-self.rho)\n \n return pol_k, pol_n, pi, W","def part2():\n\n program = IntCodeProcessor.load_program('day13input.txt')\n program[0] = 2\n cpu = IntCodeProcessor(program)\n result = None\n next_input = None\n ball_pos = None\n paddle_pos = None\n score = None\n while result is None:\n try:\n result = cpu.execute_program(next_input, reset=False)\n except ExecutionError as err:\n assert err.reason == ExecutionCode.NEED_INPUT\n\n ball_pos, paddle_pos, score = process_output(cpu.outputs, ball_pos, paddle_pos, score)\n cpu.outputs = []\n next_input = next_input_for(ball_pos, paddle_pos)\n print(f'Part 2 answer: {score}')","def test_example_day9_pt2():\n assert find_pt2(ex_data, 127) == 62","def proz(): \r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EF() #exponential window multiplication + fourier\r\n APK0() #1. Phase correction 0th Ordnung\r\n APK1() #1. Phase correction 1st Ordnung\r\n ABS() #Baseline correction\r\n APK()\r\n ABS() #Baseline correction\r\n Check_180turn(left_boundary,right_boundary)","def evaluateY(self, time) -> float:\n ...","def fn(i):\n if i == len(startTime): return 0 \n ii = bisect_left(startTime, endTime[i])\n return max(fn(i+1), profit[i] + fn(ii))","def part_2(puzzle_input):\n nr_players, nr_marbles = parse_input(puzzle_input)\n nr_marbles *= 100\n puzzle_string= (f\"{nr_players} players; last marble is worth {nr_marbles}\"\n \" points\")\n return part_1b(puzzle_string)","def single_curtailment_or_shift_each_day_between_12_and_14_pm(\n start: datetime, end: datetime, resolution: timedelta\n) -> DataFrame:\n imbalance_start_time = \"12:00\"\n imbalance_end_time = \"14:00\"\n imbalance_value = -2 # MW\n imbalance_price_between_2_and_3_am = 10 # EUR/MWh\n imbalance_price_otherwise = 5 # EUR/MWh\n df = initialize_df(\n columns=[\"Imbalance (in MW)\", \"Price (in EUR/MWh)\"],\n start=start,\n end=end,\n resolution=resolution,\n )\n df[\"Imbalance (in MW)\"] = 0\n df[\"Imbalance (in MW)\"].iloc[\n df.index.indexer_between_time(\n start_time=imbalance_start_time,\n end_time=imbalance_end_time,\n include_end=False,\n )\n ] = imbalance_value\n df[\"Price (in EUR/MWh)\"] = imbalance_price_otherwise\n df[\"Price (in EUR/MWh)\"].iloc[\n df.index.indexer_between_time(\n start_time=imbalance_start_time,\n end_time=imbalance_end_time,\n include_end=False,\n )\n ] = imbalance_price_between_2_and_3_am\n return df","def integrate_continuous_time_stochastic(self, y):\n\n self.compartments = self.convert_list_to_compartments(y)\n for label in self.compartments:\n self.compartments[label] = int(self.compartments[label])\n\n n_compartment = len(y)\n n_time = len(self.target_times)\n self.soln_array = numpy.zeros((n_time, n_compartment))\n\n time = self.target_times[0]\n self.soln_array[0, :] = y\n n_sample = 0\n for i_time, new_time in enumerate(self.target_times):\n\n if i_time == 0:\n continue\n\n while time < new_time:\n self.time = time\n self.calculate_vars()\n self.calculate_events()\n\n if len(self.events) == 0:\n # equilibrium reached, no more changes, so go\n # to end of interval\n dt = new_time - time\n else:\n event_rates = [event[2] for event in self.events]\n i_event = pick_event(event_rates)\n\n total_rate = sum(event_rates)\n dt = old_div(-math.log(random.random()), total_rate)\n\n from_label, to_label, rate = self.events[i_event]\n if from_label and to_label:\n self.compartments[from_label] -= 1\n self.compartments[to_label] += 1\n elif to_label is None:\n # death\n self.compartments[from_label] -= 1\n elif from_label is None:\n # birth\n self.compartments[to_label] += 1\n\n self.checks()\n time += dt\n n_sample += 1\n\n if i_time < n_time:\n y = self.convert_compartments_to_list(self.compartments)\n self.soln_array[i_time, :] = y","def main():\n S = input()\n ans = editorial(S)\n ans2 = dp_simple(S)\n ans3 = cumsum(S)\n\n assert ans == ans2 == ans3\n if len(S) <= 5:\n ans4 = TLE(S)\n assert ans == ans4\n\n print(ans)","def intuitive_abel_seq(p,n):\n assert n>=2, \"Carleman matrix must at least be of size 2 to retrieve the coefficients.\"\n B=p.carleman_matrix(n)-diagonal_matrix([1]*(n))\n x=B[range(1,n),range(n-1)].solve_left(matrix([[1] + [0]*(n-2)]))\n return [-1]+x[0].list()","def compute_p2(expenses: Set[int]) -> Optional[int]:\n unique_combinations = itertools.combinations(expenses, 2)\n for pair in unique_combinations:\n required = 2020 - sum(pair)\n if required in expenses:\n return np.prod(pair) * required\n return None","def y_constraint(q, xy):\n y = ( self.L[0]*np.sin(q[0]) + self.L[1]*np.sin(q[0]+q[1]) + \n self.L[2]*np.sin(q[0]+q[1]+q[2]) + self.L[3]*np.sin(np.sum(q)) ) - xy[1]\n return y","def testSuccessiveHalving(self):\n stats = self.default_statistics()\n sched, mock_runner = self.schedulerSetup(stats[\"max_trials\"])\n big_bracket = sched._state[\"bracket\"]\n cur_units = stats[str(stats[\"s_max\"])][\"r\"]\n # The last bracket will downscale 4 times\n for x in range(stats[\"brack_count\"] - 1):\n trials = big_bracket.current_trials()\n current_length = len(trials)\n for trl in trials:\n mock_runner._launch_trial(trl)\n\n # Provides results from 0 to 8 in order, keeping last one running\n for i, trl in enumerate(trials):\n action = sched.on_trial_result(\n mock_runner, trl, result(cur_units, i))\n if i < current_length - 1:\n self.assertEqual(action, TrialScheduler.PAUSE)\n mock_runner.process_action(trl, action)\n\n self.assertEqual(action, TrialScheduler.CONTINUE)\n new_length = len(big_bracket.current_trials())\n self.assertEqual(new_length, self.downscale(current_length, sched))\n cur_units += int(cur_units * sched._eta)\n self.assertEqual(len(big_bracket.current_trials()), 1)","def calc_annual_investment(devs, devs_dom, param):\n\n observation_time = param[\"observation_time\"]\n interest_rate = param[\"interest_rate\"]\n q = 1 + param[\"interest_rate\"]\n\n \n\n \n # Calculate capital recovery factor\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\n\n \n # Balancing Unit devices\n \n # Calculate annuity factor for each device\n for device in devs.keys():\n \n # Get device life time\n life_time = devs[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs[device][\"ann_factor\"] = (1 - res_value) * CRF \n else:\n devs[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF \n \n \n # Building devices\n \n for device in devs_dom.keys():\n \n # Get device life time\n life_time = devs_dom[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs_dom[device][\"ann_factor\"] = (1 - res_value) * CRF\n else: \n devs_dom[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF\n \n \n # Distribution devices (pipes, pumps)\n \n for dev in [\"pipe\", \"pump\"]: #PUmpe fehlt noch\n \n # Get device life time\n life_time = param[dev + \"_lifetime\"]\n \n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n param[\"ann_factor_\" + dev] = (1 - res_value) * CRF \n else:\n param[\"ann_factor_\" + dev] = ( 1 + invest_replacements - res_value) * CRF \n\n return devs","def linear_annealing(self, n, total, p_initial, p_final):\n if n == total:\n print \"exploration period over\"\n if n >= total:\n return p_final\n else:\n return p_initial - (n * (p_initial - p_final)) / (total)","def Bootstrap_TS(x, y):\n\n ycrv_swap = ycrv_construct(x,y)\n splf = get_spot_rates(ycrv_swap, Thirty360(), TARGET(), 1+len(y)*12)\n\n return splf","def return_schedule(loan, downpayment, n, rmonth):\n # Prepare arrays:\n principal = np.zeros(n)\n interest = np.zeros(n)\n\n # Calculate monthly payment:\n Pmonth = monthly_payment(loan, downpayment, n, rmonth)\n\n # Fill arrays:\n for i in range(n):\n if i == 0:\n interest[i] = (loan - downpayment)*rmonth\n else:\n interest[i] = (loan - downpayment - np.sum(principal[:i]))*rmonth\n principal[i] = Pmonth - interest[i]\n print('Monthly payment is:',Pmonth,'USD')\n return principal, interest","def efficient_sol(rt=\"O(n)\"):\n def bribe_count(L): # L = line\n bribes = 0\n # from back to front\n for i in range(len(L) - 1, -1, -1):\n\n expected_index = i + 1\n # Case 1: Expected Person already in the right spot.\n if L[i] == expected_index:\n continue\n\n # Case 2: Expected Person is 1 step away. Swap.\n elif L[i - 1] == expected_index:\n L[i], L[i - 1] = L[i - 1], L[i]\n bribes += 1\n\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\n elif L[i - 2] == expected_index:\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\n bribes += 2\n else:\n return \"Too chaotic\" # Expected person is more than 2 steps away.\n return bribes\n\n test_count = int(input())\n for _ in range(test_count):\n input()\n line = list(map(int, input().split()))\n print(bribe_count(line))","def exercise_b2_70():\r\n pass","def test_run():\n for symbol in ['AAPL', 'IBM']:\n print(\"Max close\")\n print(symbol, get_max_close(symbol))","def solveOneStep(self):\n ### Student code goes here\n return True"],"string":"[\n \"def solve_working(\\n assets_this_period,\\n assets_next_period,\\n hc_this_period,\\n hc_next_period,\\n interest_rate,\\n wage_rate,\\n income_tax_rate,\\n beta,\\n gamma,\\n sigma,\\n neg,\\n continuation_value,\\n delta_hc,\\n zeta,\\n psi,\\n n_gridpoints_capital,\\n n_gridpoints_hc,\\n efficiency,\\n survival_rate,\\n):\\n # Initialize objects\\n policy_labor_working_tmp = np.zeros(\\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\\n )\\n\\n # Implied hc effort\\n hc_effort = get_hc_effort(\\n hc_this_period=hc_this_period,\\n hc_next_period=hc_next_period,\\n zeta=zeta,\\n psi=psi,\\n delta_hc=delta_hc,\\n )\\n\\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\\n\\n # Implied labor supply\\n labor_input = 1 - hc_effort\\n\\n # Consumption\\n consumption = get_consumption(\\n assets_this_period=assets_this_period,\\n assets_next_period=assets_next_period,\\n pension_benefit=np.float64(0.0),\\n labor_input=labor_input,\\n interest_rate=interest_rate,\\n wage_rate=wage_rate,\\n income_tax_rate=income_tax_rate,\\n productivity=hc_this_period,\\n efficiency=efficiency,\\n )\\n\\n # Flow utility\\n flow_utility = util(\\n consumption=consumption,\\n labor_input=labor_input,\\n hc_effort=hc_effort,\\n gamma=gamma,\\n sigma=sigma,\\n )\\n\\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\\n\\n # Value function on the complete mesh (i.e. for all possible choices)\\n value_full = flow_utility + beta * survival_rate * continuation_value\\n\\n # Derive optimal policies and store value function given optimal choices\\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\\n for assets_this_period_idx in range(n_gridpoints_capital):\\n for hc_this_period_idx in range(n_gridpoints_hc):\\n assets_next_period_idx = policy_capital_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n hc_next_period_idx = policy_hc_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n policy_labor_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ] = labor_input[\\n assets_this_period_idx,\\n assets_next_period_idx,\\n hc_this_period_idx,\\n hc_next_period_idx,\\n ]\\n\\n return (\\n policy_capital_working_tmp,\\n policy_hc_working_tmp,\\n policy_labor_working_tmp,\\n value_working_tmp,\\n )\",\n \"def solve_retired(\\n assets_this_period,\\n assets_next_period,\\n interest_rate,\\n pension_benefit,\\n beta,\\n gamma,\\n sigma,\\n neg,\\n continuation_value,\\n survival_rate,\\n):\\n # Consumption\\n consumption = get_consumption(\\n assets_this_period=assets_this_period,\\n assets_next_period=assets_next_period,\\n pension_benefit=pension_benefit,\\n labor_input=np.float64(0.0),\\n interest_rate=interest_rate,\\n wage_rate=np.float64(0.0),\\n income_tax_rate=np.float64(0.0),\\n productivity=np.float64(0.0),\\n efficiency=np.float64(0.0),\\n )\\n\\n # Flow utility\\n flow_utility = util(\\n consumption=consumption,\\n labor_input=np.float64(0.0),\\n hc_effort=np.float64(0.0),\\n gamma=gamma,\\n sigma=sigma,\\n )\\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\\n\\n # Calculate value on meshes (i.e. for all choices)\\n value_full = flow_utility + beta * survival_rate * continuation_value\\n\\n # Derive optimal policies and store value function given optimal choices\\n policy_capital_retired_tmp = np.argmax(value_full, axis=1)\\n value_retired_tmp = np.max(value_full, axis=1)\\n\\n return value_retired_tmp, policy_capital_retired_tmp\",\n \"def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\\n\\n \\\"\\\"\\\"\\n This function calculates American Opportunity Credit\\n for up to four eligible students\\n\\n \\\"\\\"\\\"\\n\\n # Expense should not exceed the cap of $4000.\\n if _cmp == 1:\\n\\n c87482 = max(0., min(e87482, 4000.))\\n c87487 = max(0., min(e87487, 4000.))\\n c87492 = max(0., min(e87492, 4000.))\\n c87497 = max(0., min(e87497, 4000.))\\n else:\\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\\n\\n # Credit calculated as 100% of the first $2000 expense plus\\n # 25% of amount exceeding $2000.\\n if max(0, c87482 - 2000) == 0:\\n c87483 = c87482\\n else:\\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\\n\\n if max(0, c87487 - 2000) == 0:\\n c87488 = c87487\\n else:\\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\\n\\n if max(0, c87492 - 2000) == 0:\\n c87493 = c87492\\n else:\\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\\n\\n if max(0, c87497 - 2000) == 0:\\n c87498 = c87497\\n else:\\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\\n\\n # Sum of credits of all four students.\\n c87521 = c87483 + c87488 + c87493 + c87498\\n\\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\\n c87521)\",\n \"def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n\\n for i in range(total_days):\\n if i==0:\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n elif i==total_days-1: # last day\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n invt_daily_list.append(today_invt_dict)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Baseline Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Baseline (1st day buy->hold->last day sell) Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\\n return\",\n \"def _step(self, w1, y1,y1_short):\\n\\n #reajust the return y1 using the sign of w1\\n #if is negative means we shorted so the return is the inverse\\n\\n y1_aux=y1.copy()\\n for i in range(len(w1)):\\n if(w1[i]<0):\\n y1_aux[i]=y1_short[i]\\n y1=y1_aux.copy()\\n\\n\\n\\n\\n #print (\\\"enter step\\\")\\n assert w1.shape == y1.shape, 'w1 and y1 must have the same shape'\\n assert y1[0] == 1.0, 'y1[0] must be 1'\\n\\n p0 = self.p0\\n\\n dw1 = (y1 * w1) / (np.dot(y1, w1) + eps) # (eq7) weights evolve into\\n\\n mu1 = self.cost * (np.abs(dw1 - w1)).sum() # (eq16) cost to change portfolio\\n\\n assert mu1 < 1.0, 'Cost is larger than current holding'\\n\\n p1 = p0 * (1 - mu1) * np.dot(y1, w1) # (eq11) final portfolio value\\n\\n p1 = p1 * (1 - self.time_cost) # we can add a cost to holding\\n\\n rho1 = p1 / p0 - 1 # rate of returns\\n r1 = np.log((p1 + eps) / (p0 + eps)) # log rate of return\\n reward = r1 / self.steps * 1000. # (22) average logarithmic accumulated return\\n # remember for next step\\n self.p0 = p1\\n\\n # if we run out of money, we're done (losing all the money)\\n done = p1 == 0\\n\\n\\n info = {\\n \\\"reward\\\": reward,\\n \\\"log_return\\\": r1,\\n \\\"portfolio_value\\\": p1,\\n \\\"return\\\": y1.mean(),\\n \\\"rate_of_return\\\": rho1,\\n \\\"weights_mean\\\": w1.mean(),\\n \\\"weights_std\\\": w1.std(),\\n \\\"cost\\\": mu1,\\n }\\n\\n #print (info)\\n\\n self.infos.append(info)\\n return reward, info, done\",\n \"def americanprice(self):\\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\\n discount = math.exp( self.r*self.deltatime )\\n for i in range(self.steps,0,-1):\\n for j in range(i):\\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\\n return self.americanpay[0][0]\",\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 getRateFromProjectedAccruedment(from_capital, to_capital, period):\\n \\\"\\\"\\\"\\n vc = 100 * pow(1+50.0/100,2)\\n vc = 1e9\\n print vc\\n period = 500\\n print period\\n \\\"\\\"\\\"\\n return 100 * (pow(float(to_capital)/from_capital, 1.0/period)-1)\",\n \"def calc_savings_needed():\\r\\n annual_salary_real = float(input(\\\"Starting Salary: \\\"))\\r\\n #portion_saved = float(input(\\\"Enter the percent of your salary to save, as a decimal: \\\"))\\r\\n total_cost = 1000000#float(input(\\\"Enter the cost of your dream home: \\\"))\\r\\n semi_annual_raise = .07#float(input(\\\"Enter the semi annual raise as decimal: \\\"))\\r\\n portion_down_payment = .25\\r\\n current_savings = 0\\r\\n r = .04;\\r\\n monthly_salary = annual_salary_real / 12 \\r\\n \\r\\n months = 36\\r\\n epsilon = 100\\r\\n low = 0.0\\r\\n high = 1.0\\r\\n guess = (low + high) / 2.0\\r\\n num_guesses = 0\\r\\n breaked = False\\r\\n \\r\\n while(abs(current_savings - total_cost*portion_down_payment) > epsilon):\\r\\n if(guess == 1.0):\\r\\n breaked = True\\r\\n break\\r\\n #print(\\\"new guess: \\\",guess)\\r\\n annual_salary = annual_salary_real\\r\\n monthly_salary = annual_salary/12\\r\\n num_guesses += 1 \\r\\n \\r\\n month = 0\\r\\n current_savings = 0\\r\\n while( month < months):\\r\\n \\r\\n current_savings += (current_savings * r /12) + (guess * monthly_salary)\\r\\n month += 1\\r\\n if ((month % 6) == 0):\\r\\n annual_salary += annual_salary * semi_annual_raise\\r\\n monthly_salary = annual_salary / 12\\r\\n \\r\\n if(abs(current_savings - (total_cost*portion_down_payment)) > epsilon):\\r\\n #print(\\\"current_savings: \\\",current_savings)\\r\\n if(current_savings < (total_cost*portion_down_payment)):\\r\\n low = guess\\r\\n else:\\r\\n high = guess\\r\\n guess = (low + high) / 2.0\\r\\n \\r\\n if(breaked):\\r\\n print(\\\"It is not possible to pay down payment in 3 years.\\\")\\r\\n else: \\r\\n print(\\\"Best savings rate: \\\", guess)\\r\\n print(\\\"Steps in bisection search: \\\", num_guesses)\",\n \"def advance(self):\\n\\n f, n, rtol, atol, neq = \\\\\\n self.f, self.n, self.rtol, self.atol, self.neq\\n u_n, t_n, t_next = self.u[n], self.t[n], self.t[n+1]\\n dt = t_next - t_n\\n\\n first_step = dt # try one big step to next desired level\\n\\n def middle(x,y,z): # Auxilary function\\n return sorted([x,y,z])[1]\\n\\n # Extract coefficients from Butcher-tableau\\n table = self._butcher_tableau\\n k_len = table.shape[1] - 1 # number of internal stages\\n\\n # coefficients for internal stages\\n factors_u = np.asarray(table[:k_len, 1:])\\n # coefficients for t\\n factors_t = table[:k_len, 0]\\n # coefficients for u_new\\n factors_u_new = table[k_len, 1:]\\n\\n # coefficients for local error between 2 levels\\n factors_error = table[k_len+1, 1:] - factors_u_new\\n\\n u_intermediate = [u_n,]\\n t_intermediate = [t_n,]\\n u, t, h = u_n, t_n, first_step # initial values\\n k = np.zeros((k_len, self.neq), self.dtype) # intern stages\\n\\n if self.verbose > 0:\\n print 'advance solution in [%s, %s], h=%g' % (t_n, t_next, h)\\n\\n # Loop until next time point is reached\\n while (abs(t - t_n) < abs(t_next - t_n)):\\n u, t = u_intermediate[-1], t_intermediate[-1]\\n\\n # Internal steps\\n k[:, :] = 0. # initialization for next step\\n for m in range(k_len):\\n k_factors = (np.dot(factors_u, k))[m]\\n #print u, u+h*k_factors, f(u+h*k_factor, 0.5), self.dtype\\n k[m] = f(u+h*k_factors, t+h*factors_t[m])\\n u_new = u + h*(np.dot(factors_u_new, k))\\n\\n self.info['rejected'] += 1 # reduced below if accepted\\n if self.verbose > 0:\\n print ' u(t=%g)=%g: ' % (t+h, u_new),\\n\\n # local error between 2 levels\\n error = h*np.abs(np.dot(factors_error, k))\\n # Acceptable error tolerance\\n tol = rtol*np.abs(u_new) + atol\\n\\n accurate = (error <= tol).all()\\n\\n if accurate or h <= self.min_step or h >= self.max_step:\\n # Accurate enough,\\n # or the step size exceeds valid range,\\n # must accept this solution\\n u_intermediate.append(u_new)\\n t_intermediate.append(t+h)\\n if not self.disk_storage:\\n self.u_all.append(u_new)\\n self.t_all.append(t+h)\\n self.info['rejected'] -= 1\\n\\n if self.verbose > 0:\\n print 'accepted, ',\\n else:\\n if self.verbose > 0:\\n print 'rejected, ',\\n\\n if self.verbose > 0:\\n print 'err=%s, ' % str(error),\\n if hasattr(self, 'u_exact') and callable(self.u_exact):\\n print 'exact-err=%s, ' % \\\\\\n (np.asarray(self.u_exact(t+h))-u_new),\\n if h <= self.min_step:\\n print 'h=min_step!! ',\\n\\n\\n # Replace 0 values by 1e-16 since we will divide by error\\n error = np.asarray([(1e-16 if x == 0. else x) \\\\\\n for x in error])\\n\\n # Normarized error rate\\n rms = error/tol\\n rms_norm = np.sqrt(np.sum(rms*rms)/self.neq)\\n\\n order = float(self._method_order[0])\\n # factor to adjust the size of next step\\n # Formula is from <Numerical Methods for Engineers,\\n # Chappra & Cannle>\\n s = .8 *((1./rms_norm)**(1/order))\\n # scalar should be in range(0.1, 4.)\\n # for better accuracy and smoothness\\n s = middle(s, 0.1, 4.0)\\n h *= s\\n\\n # step size should be in range [min_step, max_step]\\n h = middle(h, self.min_step, self.max_step)\\n # adjust h to fit the last step\\n h = min(h, t_next - t_intermediate[-1])\\n\\n if self.verbose > 0:\\n print 'new h=%g' % h\\n\\n if h == 0:\\n break\\n\\n return u_new\",\n \"def part_2():\\n input_ = parse_input() + list(range(10, 1_000_001))\\n cups = turn_input_into_cups(input_)\\n cups = solve(cups, first_cup=cups[input_[0]], turns=10_000_000)\\n\\n return cups[1].next.number * cups[1].next.next.number\",\n \"def run():\\n ncases = int(utils.get_input(\\\"Amount of cases: \\\"))\\n cases = []\\n for icase in range(ncases):\\n credit = int(utils.get_input(\\\"Credit for case {}: \\\".format(icase+1)))\\n prices_raw = utils.get_input(\\\"Item prices for case {}: \\\".format(icase+1))\\n prices = [int(price_raw) for price_raw in prices_raw.split()]\\n cases.append((prices, credit))\\n results = [lt.first_sum_pair(pr, cr) for pr, cr in cases]\\n [print(\\\"Case #{}: {} {}\\\".format(icase+1, *result)) for icase, result in enumerate(results)]\",\n \"def part_1():\\n input_ = parse_input()\\n cups = turn_input_into_cups(input_)\\n cups = solve(cups, first_cup=cups[input_[0]], turns=100)\\n\\n answer = []\\n current_cup = cups[1].next\\n while current_cup != cups[1]:\\n answer.append(str(current_cup.number))\\n current_cup = current_cup.next\\n\\n return \\\"\\\".join(answer)\",\n \"def alice(\\n partner1_salary_compound_rate: float,\\n partner1_salary_plateau: float,\\n partner2_salary_compound_rate: float,\\n partner2_salary_plateau: float,\\n base_spending: float,\\n spending_luxury_compound_rate: float,\\n rrsp_interest_rate: float,\\n tfsa_interest_rate: float,\\n):\\n\\n ruleset_func = ruleset.get_couple_ruleset(\\n salary_rules.get_compound_plateau(\\n partner1_salary_compound_rate, partner1_salary_plateau\\n ),\\n salary_rules.get_compound_plateau(\\n partner2_salary_compound_rate, partner2_salary_plateau\\n ),\\n couple_spending_rules.get_luxury_over_basic(\\n base_spending, spending_luxury_compound_rate\\n ),\\n couple_savings_rules.get_equalizing_rrsp_only_split(),\\n rrsp_interest_rate,\\n tfsa_interest_rate,\\n )\\n\\n return ruleset_func\",\n \"def solve(self, state, times):\",\n \"def cvp():\\r\\n c = float(input(\\\"Please Enter Total Fixed Costs Value: \\\"))\\r\\n a = float(input(\\\"Please Enter Sale Price Per Unit: \\\"))\\r\\n b = float(input(\\\"Please Enter Variable Cost Per Unit: \\\"))\\r\\n ccm = float(a)-float(b)\\r\\n cuu = float(c)/float(ccm)\\r\\n ccmr = (float(ccm)/float(a))*float(100)\\r\\n cda = float(c)/(float(ccmr)/float(100))\\r\\n print \\\">> Your Contribution Margin is\\\",ccm\\r\\n print \\\">> Your Breakeven Sales in Units is\\\",round(cuu)\\r\\n print \\\">> Your Contribution Margin Ratio is\\\",ccmr,\\\"%\\\"\\r\\n print \\\">> Your Breakeven Sales in Dollars is\\\",cda,\\\"\\\\n\\\"\\r\\n qq = input(\\\" Press 1 To Compute Target Profit\\\\n Press 2 To Compute Margin of Safety\\\\n Press 3 To Perform Sensitivity Analysis\\\\n Or Press 0 To Exit: \\\")\\r\\n if(qq == 1):\\r\\n dds = float(input(\\\"Please Enter Your Target Profit: \\\"))\\r\\n xxx = (float(c)+float(dds))/float(ccm)\\r\\n xxxx = (float(c)+float(dds))/(float(ccmr)/float(100))\\r\\n print \\\">> Your Target Profit in Units To Earn\\\",dds,\\\"$ is\\\",round(xxx)\\r\\n print \\\">> Your Target Profit in Dollars To Earn\\\",dds,\\\"$ is\\\",xxxx\\r\\n elif(qq == 0):\\r\\n print \\\"Canceled\\\"\\r\\n elif(qq == 2):\\r\\n xc = float(input(\\\"Please Enter Expected Sales in Units: \\\"))\\r\\n zzz = float(xc)-float(cuu)\\r\\n zzzz = float(zzz)*float(a)\\r\\n print \\\">> Your Margin of Safety in Units is\\\",round(zzz)\\r\\n print \\\">> Your Margin of Safety in Dollars is\\\",zzzz\\r\\n elif(qq == 3):\\r\\n i = input(\\\"Please Enter Total Fixed Costs Value: \\\")\\r\\n o = input(\\\"Please Enter Sale Price Per Unit: \\\")\\r\\n p = input(\\\"Please Enter Variable Cost Per Unit: \\\")\\r\\n n = 0\\r\\n for x,y,z in zip(i,o,p):\\r\\n cm = float(y)-float(z)\\r\\n uu = float(x)/float(cm)\\r\\n cmr = (float(cm)/float(y))*float(100)\\r\\n da = float(x)/(float(cmr)/float(100))\\r\\n n += 1\\r\\n print \\\"Your Results in Case\\\",int(n),\\\"is :\\\"\\r\\n print \\\">> Your Contribution Margin is\\\",cm\\r\\n print \\\">> Your Breakeven Sales in Units is\\\",round(uu)\\r\\n print \\\">> Your Contribution Margin Ratio is\\\",cmr,\\\"%\\\"\\r\\n print \\\">> Your Breakeven Sales in Dollars is\\\",da,\\\"\\\\n\\\"\\r\\n if(cm > ccm):\\r\\n a = float(cm)-float(ccm)\\r\\n print \\\">> Your Contribution Margin Increased by\\\",a\\r\\n elif(ccm > cm):\\r\\n a = float(ccm)-float(cm)\\r\\n print \\\">> Your Contribution Margin Decreased by\\\",a\\r\\n if(uu > cuu):\\r\\n b = float(uu)-float(cuu)\\r\\n print \\\">> Your Breakeven Sales in Units Increased by\\\",round(b)\\r\\n elif(cuu > uu):\\r\\n b = float(cuu)-float(uu)\\r\\n print \\\">> Your Breakeven Sales in Units Decreased by\\\",round(b)\\r\\n if(cmr > ccmr):\\r\\n c = float(cmr)-float(ccmr)\\r\\n print \\\">> Your Contribution Margin Ratio Increased by\\\",c,\\\"%\\\"\\r\\n elif(ccmr > cmr):\\r\\n c = float(ccmr)-float(cmr)\\r\\n print \\\">> Your Contribution Margin Ratio Decreased by\\\",c,\\\"%\\\"\\r\\n if(da > cda):\\r\\n d = float(da)-float(cda)\\r\\n print \\\">> Your Breakeven Sales in Dollars Increased by\\\",d\\r\\n elif(cda > da):\\r\\n d = float(cda)-float(da)\\r\\n print \\\">> Your Breakeven Sales in Dollars Decreased by\\\",d,\\\"\\\\n\\\"\",\n \"def budget_problem3(balance, annualInterestRate):\\r\\n remaining = balance\\r\\n\\r\\n # creating the following bounds assists with bisection search\\r\\n lo = balance/12\\r\\n hi = ((balance * (annualInterestRate/12))**12)/12\\r\\n payment = (lo + hi)/2\\r\\n\\r\\n while remaining != 0:\\r\\n for month in range(12):\\r\\n remaining = (remaining - payment) * (1 + (annualInterestRate/12))\\r\\n if remaining > 0:\\r\\n lo = payment\\r\\n elif round(remaining,2) < -0.11:\\r\\n hi = payment\\r\\n else:\\r\\n break\\r\\n payment = (lo + hi)/2\\r\\n remaining = balance\\r\\n print 'Lowest Payment: ' + str(round(payment,2))\\r\\n return round(payment,2)\",\n \"def double_declining_balance():\\r\\n cost = float(input(\\\"Please Enter The Cost Of Asset: \\\"))\\r\\n accdepreciation = float(input(\\\"Please Enter The Value Of Accumulated Depreciation: \\\"))\\r\\n life = float(input(\\\"Please Enter Estimated Useful Life Of Asset(Years): \\\"))\\r\\n rv = float(input(\\\"Please Enter Estimated Residual Value Of Asset: \\\"))\\r\\n n = 0\\r\\n a = (float(cost)-float(accdepreciation)) * (float(2)/float(life))\\r\\n bn = float(a)/float(12)\\r\\n print \\\">> Your Monthly Depreciation For First Year is\\\",bn\\r\\n while(n != (life-1)):\\r\\n bk = float(cost)\\r\\n a = ((float(cost)-float(accdepreciation)) * (float(2)/float(life)))\\r\\n cost -= float(a)\\r\\n bk -= float(a)\\r\\n n += 1\\r\\n vvv = float(bk)-float(rv)\\r\\n print \\\">> Your Depreciation For Year No.\\\",n,\\\"is\\\",a\\r\\n print \\\">> Your Book Value After\\\",n,\\\"Years is\\\",bk,\\\"\\\\n\\\"\\r\\n print \\\">> Your Depreciation For Year No.\\\",int(life),\\\"is\\\",vvv\\r\\n print \\\">> Your Book Value After\\\",int(life),\\\"Years is\\\",rv\",\n \"def find_subsidy_rate(self, tau):\\n \\n #a. find residual with lower and upper guesses\\n tauv_0 = np.array([-self.tau_s_0, 0, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv_0) \\n \\n Kss_d = self.solve_stationary_equilibrium()[1]\\n residual0 = Kss_d / self.Kss_b - 1\\n \\n tauv_1 = np.array([-self.tau_s_1, 0, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv_1) \\n \\n Kss_d = self.solve_stationary_equilibrium()[1]\\n residual1 = Kss_d / self.Kss_b - 1\\n \\n assert residual0*residual1 < 0, 'find_subsidy_rate -- WARNING: No equilibrium tau exists'\\n \\n #b. bisection to find the subsidy rate that genereates the same ss capital as in benchmark case\\n \\n tau_s_0 = self.tau_s_0 \\n tau_s_1 = self.tau_s_1\\n \\n for i_t in range(self.maxit):\\n taus = (tau_s_0 + tau_s_1)/2\\n tauv = np.array([-taus, 0, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv) \\n \\n Kss_d = self.solve_stationary_equilibrium()[1]\\n residual = Kss_d / self.Kss_b - 1\\n \\n if np.abs(residual) < self.tol:\\n \\n taus_star = taus\\n break\\n \\n else:\\n if residual1 * residual>0 :\\n tau_s_1 = taus\\n else :\\n tau_s_0 = taus\\n \\n assert i_t+1 < self.maxit, 'find_subsidy_rate -- taus has not converged'\\n \\n return taus_star\",\n \"def calc_capital_costs (self):\\n self.capital_costs = self.max_boiler_output * \\\\\\n self.comp_specs[\\\"cost per btu/hrs\\\"]\\n #~ print self.capital_costs\",\n \"def y2k_coding(n):\\n if n < 60:\\n return 2000 + n\\n else:\\n return 1900 + n\",\n \"def rhs_fenics(y,t):\\n #print \\\"time: \\\",t\\n uprev.vector()[:]=y\\n f.t = t #dolfin needs to know the current time for cos(t)\\n uprime_solver.solve()\\n return uprime_solution.vector().array()\",\n \"def lax(_x,_y,_cs,_dx,_dt):\\n s = _cs * _dt / (2. * _dx)\\n next_y = 0.5 *(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1])) \\\\\\n - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\\n return next_y\",\n \"def calc_capital_costs (self):\\n powerhouse_control_cost = 0\\n if not self.cd['switchgear suitable for renewables']:\\n powerhouse_control_cost = self.cd['switchgear cost']\\n\\n #~ road_needed = self.comp_specs['road needed for transmission line']\\n\\n\\n if str(self.comp_specs['transmission capital cost'])\\\\\\n != 'UNKNOWN':\\n transmission_line_cost = \\\\\\n int(self.comp_specs['transmission capital cost'])\\n else:\\n if str(self.comp_specs['distance to resource']) \\\\\\n != 'UNKNOWN':\\n distance = \\\\\\n float(self.comp_specs\\\\\\n ['distance to resource'])\\n transmission_line_cost = \\\\\\n distance*self.comp_specs['est. transmission line cost']\\n\\n secondary_load_cost = 0\\n if self.comp_specs['secondary load']:\\n secondary_load_cost = self.comp_specs['secondary load cost']\\n\\n if str(self.comp_specs['generation capital cost']) \\\\\\n != 'UNKNOWN':\\n wind_cost = \\\\\\n int(self.comp_specs['generation capital cost'])\\n self.cost_per_kw = np.nan\\n else:\\n for i in range(len(self.comp_specs['estimated costs'])):\\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\\\\n self.load_offset_proposed:\\n if i == len(self.comp_specs['estimated costs']) - 1:\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n continue\\n\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n\\n wind_cost = self.load_offset_proposed * cost\\n self.cost_per_kw = cost\\n\\n #~ print powerhouse_control_cost\\n #~ print transmission_line_cost\\n #~ print secondary_load_cost\\n #~ print wind_cost\\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\\\\n secondary_load_cost + wind_cost\\n\\n #~ print 'self.capital_costs',self.capital_costs\",\n \"def main():\\r\\n d = CoupleBreaker()\\r\\n d.makeCouples()\\r\\n\\r\\n \\\"\\\"\\\"here k is taken as 2 , any value can be taken\\\"\\\"\\\"\\r\\n t= int(input(\\\"Enter the no. of days :-\\\"))\\r\\n\\r\\n for i in range(0, t):\\r\\n d.breakLeastHappy(2)\\r\\n d.PatchThemUp()\",\n \"def trailing_stop_pct(self, offset=0.33, ts_o_type='market', tschase=False, max_chase=None):\\n\\n\\n # rpnl = float(r) * 0.00000001\\n # bal = float(self.get_balance()) * 0.00000001\\n\\n while True:\\n pos = self.get_position()\\n entry_price = pos['avgEntryPrice']\\n # last_price = self.ws.get_ticker()['last']\\n qty = pos['currentQty']\\n (r, u, b) = self.get_pnl()\\n upnl = float(u) * 0.00000001\\n bal = float(b) * 0.00000001\\n if u > 0.0:\\n self.logger.info(f'Trailing stop triggered: UPNL {upnl} BAL {bal}')\\n break\\n else:\\n self.logger.info('No unrealized PNL, waiting ... ')\\n time.sleep(3)\\n if qty > 0:\\n # long position, so this will be a sell stop\\n sell_price = self.ws.get_ticker()['sell']\\n offset_price = self.rounded_price(sell_price - (float(offset) * (sell_price - entry_price)), self.symbol)\\n text = f'Trailing sell stop for long position, type {ts_o_type}'\\n qty = qty * -1\\n side = 'Sell'\\n self.logger.info(\\n f'Trailing Stop for long position of entry price: {entry_price} triggered: offset price {offset_price}'\\n f' current price: {[sell_price]}')\\n else:\\n # short position, so this will be a buy stop\\n buy_price = self.ws.get_ticker()['buy']\\n offset_price = self.rounded_price(buy_price - float(offset) * (buy_price - entry_price), self.symbol)\\n text = f'Trailing buy stop for short position, type {ts_o_type}'\\n qty = qty * -1\\n side = 'Buy'\\n self.logger.info(\\n f'Trailing Stop for short position of entry price: {entry_price} triggered: offset price {offset_price}'\\n f' current price: {[buy_price]}')\\n\\n iteration = 0\\n while True:\\n\\n if side == \\\"Sell\\\":\\n sell_price = self.ws.get_ticker()['sell']\\n offset_pct = self.rounded_price((sell_price - entry_price) * offset, self.symbol)\\n if (float(sell_price) - float(offset_pct)) > float(offset_price):\\n offset_price = self.rounded_price(sell_price - (float(offset) * (sell_price - entry_price)), self.symbol)\\n self.logger.info(\\\"New high observed: %.8f Updating stop loss to %.8f\\\" % (sell_price, offset_price))\\n\\n elif float(sell_price) < float(offset_price):\\n sell_price = self.ws.get_ticker()['sell']\\n if tschase:\\n self.logger.info(f'Chasing sell order ... max chase: {max_chase}')\\n self.logger.info(\\\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\\\" % (ts_o_type, sell_price,\\n offset_price))\\n chaser = threading.Thread(target=self.limit_chase, args=(qty, max_chase, True))\\n chaser.start()\\n else:\\n self.logger.info(\\\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\\\" % (ts_o_type, sell_price,\\n offset_price))\\n ret = self.send_order(oq=qty, ot=ts_o_type, text=text)\\n self.logger.debug(ret)\\n\\n self.triggered = False\\n break\\n\\n\\n if side == \\\"Buy\\\":\\n buy_price = self.ws.get_ticker()['buy']\\n offset_pct = self.rounded_price((entry_price - buy_price) * offset, self.symbol)\\n if (float(buy_price) + float(offset_pct)) < float(offset_price):\\n offset_price = self.rounded_price(buy_price - float(offset) * (buy_price - entry_price))\\n\\n self.logger.info(\\\"New low observed: %.8f Updating stop loss to %.8f\\\" % (buy_price, offset_price))\\n\\n elif float(buy_price) > float(offset_price):\\n buy_price = self.ws.get_ticker()['buy']\\n if tschase:\\n self.logger.info(f'Chasing buy order ... max chase: {max_chase}')\\n self.logger.info(\\\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\\\" % (ts_o_type, buy_price,\\n offset_price))\\n chaser = threading.Thread(target=self.limit_chase, args=(qty, max_chase, True))\\n chaser.start()\\n else:\\n self.logger.info(\\\"Sell triggered: %s | Price: %.8f | Stop loss: %.8f\\\" % (ts_o_type, buy_price,\\n offset_price))\\n ret = self.send_order(oq=qty, ot=ts_o_type, text=text)\\n self.logger.debug(ret)\\n\\n self.triggered = False\\n break\",\n \"def stage_order(self,tol=1.e-14):\\n from sympy import simplify\\n simp_array = np.vectorize(sympy.simplify)\\n k,B,C=0,0.,0.\\n while np.all(abs(B)<tol) and np.all(abs(C)<tol):\\n k=k+1\\n B=simplify(np.dot(self.b,self.c**(k-1)))-1./k\\n C=simp_array(np.dot(self.A,self.c**(k-1))-self.c**k/k)\\n return k-1\",\n \"def test(test_env, Q):\\n observation = test_env._reset()\\n test_cap = []\\n done = False\\n while not done:\\n # Get action with maximum future expected reward\\n action = action = Q.q_table.loc[str(test_env._get_obs())].idxmax()\\n # Apply action\\n observation_, reward, done = test_env._step(action)\\n # Save current cash to observe over testing period\\n test_cap.append(test_env.current_capital)\\n # Current obs becomes next obs\\n observation = observation_\\n # If completed time frame\\n if done:\\n break\\n\\n plt.scatter(np.arange(len(test_cap)), test_cap, marker='.', c='k' )\\n plt.title('Capital Attained at Each Decision')\\n plt.xlabel('Day')\\n plt.ylabel('Capital Attained')\\n plt.show()\\n return\",\n \"def getY90(inp):\\n\\tinp = sorted(inp, key = lambda x: x[0])\\n\\tfor i in xrange(len(inp)):\\n\\t\\te = inp[i]\\n\\t\\tif e[1]>=0.9:\\n\\t\\t\\tsecond = e\\n\\t\\t\\tfirst = inp[i-1]\\n\\t\\t\\tbreak\\n\\treturn first[0]+(0.9-first[1])/(second[1]-first[1])*(second[0]-first[0])\",\n \"def step2(self):\\n\\t\\tif self.b[self.k - 1] == 'a':\\n\\t\\t\\tif self.ends(\\\"ational\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"tional\\\"): self.r(\\\"tion\\\")\\n\\t\\telif self.b[self.k - 1] == 'c':\\n\\t\\t\\tif self.ends(\\\"enci\\\"):\\t self.r(\\\"ence\\\")\\n\\t\\t\\telif self.ends(\\\"anci\\\"): self.r(\\\"ance\\\")\\n\\t\\telif self.b[self.k - 1] == 'e':\\n\\t\\t\\tif self.ends(\\\"izer\\\"):\\t self.r(\\\"ize\\\")\\n\\t\\telif self.b[self.k - 1] == 'l':\\n\\t\\t\\tif self.ends(\\\"bli\\\"):\\t self.r(\\\"ble\\\") # --DEPARTURE--\\n\\t\\t\\t# To match the published algorithm, replace this phrase with\\n\\t\\t\\t#\\tif self.ends(\\\"abli\\\"):\\t self.r(\\\"able\\\")\\n\\t\\t\\telif self.ends(\\\"alli\\\"): self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"entli\\\"): self.r(\\\"ent\\\")\\n\\t\\t\\telif self.ends(\\\"eli\\\"):\\t self.r(\\\"e\\\")\\n\\t\\t\\telif self.ends(\\\"ousli\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 'o':\\n\\t\\t\\tif self.ends(\\\"ization\\\"): self.r(\\\"ize\\\")\\n\\t\\t\\telif self.ends(\\\"ation\\\"): self.r(\\\"ate\\\")\\n\\t\\t\\telif self.ends(\\\"ator\\\"): self.r(\\\"ate\\\")\\n\\t\\telif self.b[self.k - 1] == 's':\\n\\t\\t\\tif self.ends(\\\"alism\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iveness\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"fulness\\\"): self.r(\\\"ful\\\")\\n\\t\\t\\telif self.ends(\\\"ousness\\\"): self.r(\\\"ous\\\")\\n\\t\\telif self.b[self.k - 1] == 't':\\n\\t\\t\\tif self.ends(\\\"aliti\\\"):\\t self.r(\\\"al\\\")\\n\\t\\t\\telif self.ends(\\\"iviti\\\"): self.r(\\\"ive\\\")\\n\\t\\t\\telif self.ends(\\\"biliti\\\"): self.r(\\\"ble\\\")\\n\\t\\telif self.b[self.k - 1] == 'g': # --DEPARTURE--\\n\\t\\t\\tif self.ends(\\\"logi\\\"):\\t self.r(\\\"log\\\")\\n\\t\\t# To match the published algorithm, delete this phrase\",\n \"def _cost_caught_by_police(self):\\n if self.fine_frequency != 0:\\n if self.number_of_courses % self.fine_frequency == 0 and self.number_of_courses != 0:\\n if self.number_of_courses % self.fine_frequency_paid_by_driver == 0 and self.number_of_courses != 0:\\n self.fine_paid_number_of_courses += 1\\n fine_value = np.random.choice([100, 200, 500], p=[0.25, 0.4, 0.35])\\n self.total_penalty_points += self._add_penalty_points() # adding penalty points\\n return fine_value\\n else:\\n return 0\\n else:\\n return 0\\n else:\\n return 0\",\n \"def _determine_next_eval_point(self):\\n anc_data = self._get_ancillary_data_for_acquisition()\\n acq_to_use = getattr(acquisitions.asy, self.options.acq.lower())\\n next_eval_point = acq_to_use(self.gp, self.acq_optimise, anc_data)\\n return next_eval_point\",\n \"def lab10_q2():\\n return \\\"\\\"\\\"\\n Make a 'total' to add up the total revenue as while loop plays.\\n\\titem = qvm.dispense, makes it so item is the juice. \\n\\tWhile item: because if there is a juice this while loop will continue. If there aren't two fruits, there wont be a juice so while loop stops.\\n\\ttotal += qvm.collect_money(item). (this should be += not = right?) to add the revenue from that 'item'\\n\\trevalue item to the next juice.\\n\\treturn total\\n \\\"\\\"\\\"\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def solve_p1_v1(target: int) -> int:\\n\\n elves = DeliveryService()\\n\\n house, n_presents = 0, 0\\n while n_presents < target:\\n house += 1\\n n_presents = elves.visit(house)\\n print(house, n_presents)\\n\\n return house\",\n \"def solve_model(self): \\n \\n t0 = time.time() #start the clock\\n \\n # a. benchmark case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(1)\\n \\n #ii. set policy. in RR08 the benchmark economy has no taxes nor subsidies\\n self.tau_benchmark = np.array([0, 0, 0]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(self.tau_benchmark) #set tax system\\n \\n #iii. benchmark equilibrium\\n self.Yss_b, self.Kss_b, self.TFPss_b, self.average_firm_size_b, self.E_star_b, _, \\\\\\n _, self.N_ss_b, self.w_ss_b, self.cdf_stationary_b, self.cdf_emp_b = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Benchmark Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\")\\n print(f\\\"ss output = {self.Yss_b:.2f}\\\")\\n print(f\\\"ss capital = {self.Kss_b:.2f}\\\")\\n print(f\\\"ss tfp = {self.TFPss_b:.2f}\\\")\\n print(f\\\"ss wage = {self.w_ss_b:.2f}\\\")\\n print(f\\\"entry mass = {self.E_star_b:.3f}\\\")\\n print(f\\\"avg. firm size = {self.average_firm_size_b:.2f}\\\")\\n \\n #b. plot (note that the distributions plotted here are unaffected by the distortionary policies)\\n \\n if self.plott:\\n #i. initialize\\n employed = [4.99, 49.99]\\n firm_size_by_employee = np.zeros(len(employed)+1)\\n share_employment = np.zeros(len(employed)+1)\\n \\n \\n #i. percentage of firms that employ employed\\n \\n for i_e in range(len(employed)):\\n summ = np.sum(firm_size_by_employee)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_stationary_b, employed[i_e])[0] #labor_demand_rel is labor demand with the lowest value normalized to 1\\n firm_size_by_employee[i_e] = interpolate - summ\\n firm_size_by_employee[-1] = 1 - np.sum(firm_size_by_employee)\\n \\n plt.pie(firm_size_by_employee, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Size of Firms by Firm Size (Number of Employees)')\\n plt.savefig('firm_size_rr08.pdf')\\n plt.show()\\n \\n \\n #ii. employment percentage by firm size\\n for i_e in range(len(employed)):\\n summ = np.sum(share_employment)\\n interpolate = self.interpol(self.labor_demand_rel, self.cdf_emp_b , employed[i_e])[0]\\n share_employment[i_e] = interpolate - summ\\n share_employment[-1] = 1 - np.sum(share_employment)\\n \\n plt.pie(share_employment, labels=['<5','5<50','50 =<'], autopct=\\\"%.1f%%\\\")\\n plt.title('Employment Share by Firm Size (Number of Employees)')\\n plt.savefig('employment_by_firm_size_rr08.pdf')\\n plt.show()\\n \\n #iii. productivity cdf and employment cdf\\n plt.plot(self.grid_s, self.cdf_stationary_b)\\n plt.plot(self.grid_s, self.cdf_emp_b)\\n plt.title('Stationary CDF' )\\n plt.xlabel('Productivity level')\\n plt.ylabel('Cumulative Sum')\\n plt.legend(['Firms by Productivity Level','Share of Employment'])\\n plt.savefig('cdf_rr08.pdf')\\n plt.show()\\n \\n \\n \\n #c. distortion case\\n \\n #i. joint pdf of productivity state and tau \\n self.make_joint_pdf(0)\\n \\n #ii. compute stationary economy for each tau\\n \\n for idx, tau in enumerate(self.tau_vector):\\n \\n #iii. find the subsidy rate that generates the same capital stock as in benchmark economy\\n self.tau_s[idx] = self.find_subsidy_rate(tau)\\n \\n # set tax system with newly found tau_s and given tau\\n tauv = np.array([-self.tau_s[idx], self.excempt_frac, tau]) #subsidy rate, excempt rate, tax rate \\n self.set_tax_system(tauv) #set tax system\\n \\n #v. distorted stationary equilibrium\\n self.Yss_d[idx], self.Kss_d[idx], self.TFPss_d[idx], self.average_firm_size_d[idx], self.E_star_d[idx], \\\\\\n self.Y_set_d[idx,:], self.subsidy_size_d[idx], self.N_ss_d[idx], self.w_ss_d[idx],\\\\\\n _, _ = self.solve_stationary_equilibrium()\\n \\n print(\\\"\\\\n-----------------------------------------\\\")\\n print(\\\"Distorted Stationary Equilibrium\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n if self.distortion_case == 1:\\n print(\\\"Tax/Subidy Uncorrelated with Firm Level Producitivity\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Negatively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(low productivity firms recieve subsidy, high productivity taxed)\\\\n\\\")\\n elif self.distortion_case == 2:\\n print(\\\"Tax/Subidy Positively Correlated with Firm Level Producitivity\\\")\\n print(\\\"(high productivity firms recieve subsidy, low productivity taxed)\\\\n\\\")\\n if self.policy_type == 1 :\\n print(\\\"Tax Type: Tax on output\\\\n\\\")\\n elif self.policy_type == 2 :\\n print(\\\"Tax Type: Tax on capital\\\\n\\\")\\n elif self.policy_type == 3 :\\n print(\\\"Tax Type: Tax on labor\\\\n\\\")\\n print(f\\\"fraction of firms recieving subsidy = {self.subsidy_frac:.2f}\\\")\\n print(f\\\"fraction of firms taxed = {1-self.subsidy_frac-self.excempt_frac:.2f}\\\")\\n print(f\\\"fraction of firms excempt = {self.excempt_frac:.2f}\\\")\\n print(\\\"-----------------------------------------\\\\n\\\")\\n \\n print(tabulate([['relative Yss', round(self.Yss_d[0]/self.Yss_b, 2), round(self.Yss_d[1]/self.Yss_b, 2), round(self.Yss_d[2]/self.Yss_b, 2), round(self.Yss_d[3]/self.Yss_b, 2)],\\n ['relative TFPss', round(self.TFPss_d[0]/self.TFPss_b, 2), round(self.TFPss_d[1]/self.TFPss_b, 2), round(self.TFPss_d[2]/self.TFPss_b, 2), round(self.TFPss_d[3]/self.TFPss_b, 2)], \\n ['relative entry mass', round(self.E_star_d[0]/self.E_star_b, 2), round(self.E_star_d[1]/self.E_star_b, 2), round(self.E_star_d[2]/self.E_star_b, 2), round(self.E_star_d[3]/self.E_star_b, 2)],\\n ['share of subsidized output', round(self.Y_set_d[0,0], 2), round(self.Y_set_d[1,0], 2), round(self.Y_set_d[2,0], 2), round(self.Y_set_d[3,0], 2)],\\n ['total subsidy paid of output', round(self.subsidy_size_d[0], 2), round(self.subsidy_size_d[1], 2), round(self.subsidy_size_d[2], 2), round(self.subsidy_size_d[3], 2)],\\n ['subsidy rate (tau_s)', round(self.tau_s[0], 2), round(self.tau_s[1], 2), round(self.tau_s[2], 2), round(self.tau_s[3], 2)],\\n [], \\n ['relative Kss', round(self.Kss_d[0]/self.Kss_b, 2), round(self.Kss_d[1]/self.Kss_b, 2), round(self.Kss_d[2]/self.Kss_b, 2), round(self.Kss_d[3]/self.Kss_b, 2)], \\n ['relative wss', round(self.w_ss_d[0]/self.w_ss_b, 2), round(self.w_ss_d[1]/self.w_ss_b, 2), round(self.w_ss_d[2]/self.w_ss_b, 2), round(self.w_ss_d[3]/self.w_ss_b, 2)], \\n ['relative Nss', round(self.N_ss_d[0]/self.N_ss_b, 2), round(self.N_ss_d[1]/self.N_ss_b, 2), round(self.N_ss_d[2]/self.N_ss_b, 2), round(self.N_ss_d[3]/self.N_ss_b, 2)], \\n ['relative avg. firm size', round(self.average_firm_size_d[0]/self.average_firm_size_b, 2), round(self.average_firm_size_d[1]/self.average_firm_size_b, 2), round(self.average_firm_size_d[2]/self.average_firm_size_b, 2), round(self.average_firm_size_d[3]/self.average_firm_size_b, 2)]],\\n headers=['Variable', 'Tax = '+str(self.tau_vector[0]), \\\"Tax = \\\"+str(self.tau_vector[1]), 'Tax = '+str(self.tau_vector[2]), 'Tax = '+str(self.tau_vector[3])]))\\n \\n\\n t1 = time.time()\\n print(f'\\\\nTotal Run Time: {t1-t0:.2f} seconds')\",\n \"def plan_production() -> str:\\r\\n monthly_forecasts = app.config[\\\"monthly_sales_forecasts\\\"]\\r\\n # True if the dictionary monthly_forecasts is empty.\\r\\n if not monthly_forecasts:\\r\\n return (\\\"No prediction has been made. Please click first on the \\\"\\r\\n + \\\"button 'First: predict sales' on the tracking screen.\\\")\\r\\n batches = app.config[\\\"batches\\\"]\\r\\n tanks = app.config[\\\"tanks\\\"]\\r\\n inventory = app.config[\\\"inventory\\\"]\\r\\n # Holds actual number of beers in inventory and actual number of beers that\\r\\n # will be finished in the next three months on basis of production stage.\\r\\n three_month_end_inv = {\\\"dunkers\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0},\\r\\n \\\"pilsner\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0},\\r\\n \\\"red_helles\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0}}\\r\\n # Calculates when product. stage will be finished for 3 consecutive months.\\r\\n for batch in batches.values():\\r\\n # True if batch is already finished, continue with next batch.\\r\\n if batch.bottles_put_in_inventory:\\r\\n continue\\r\\n # Implies batch isn't assigned to phase, values are set in next if-else\\r\\n end_phase4 = \\\"\\\"\\r\\n end_phase3_4 = \\\"\\\"\\r\\n end_phase2_4 = \\\"\\\"\\r\\n end_phase1_4 = \\\"\\\"\\r\\n # Calculates end time of each batch assuming that each batch goes\\r\\n # directly to the next production phase without any delays.\\r\\n # True if the batch is in production phase 4 (bottling).\\r\\n if batch.time_end_phase4 != \\\"\\\":\\r\\n # Phase 4 ends when time_end_phase4 is reached.\\r\\n end_phase4 = batch.time_end_phase4\\r\\n # Else True if the batch is in production phase 3 (conditioning).\\r\\n elif batch.time_end_phase3 != \\\"\\\":\\r\\n # If the product is in phase 3, then the product will be finished\\r\\n # after the duration of phase 3 + phase 4 ends.\\r\\n # One minute per bottle (1/60) and each bottle contains 0.5 litres.\\r\\n duration_p4 = (1 / 60) * batch.volume * 2 # In hours.\\r\\n end_phase3_4 = batch.time_end_phase3 + timedelta(hours=duration_p4)\\r\\n # Else True if the batch is in production phase 2 (fermentation).\\r\\n elif batch.time_end_phase2 != \\\"\\\":\\r\\n # P2 product will be finished after duration p2 + p3 + p4 ends.\\r\\n duration_p3 = 336 # In hours.\\r\\n duration_p4 = (1 / 60) * batch.volume * 2\\r\\n end_phase2_4 = (batch.time_end_phase2\\r\\n + timedelta(hours=duration_p3)\\r\\n + timedelta(hours=duration_p4))\\r\\n # Else True if the batch is in production phase 1 (hot brewing).\\r\\n elif batch.time_end_phase1 != \\\"\\\":\\r\\n # P1 product will be finished after durat. p1 + p2 + p3 + p4 ends.\\r\\n duration_p2 = 672 # In hours.\\r\\n duration_p3 = 336\\r\\n duration_p4 = (1 / 60) * batch.volume * 2\\r\\n end_phase1_4 = (batch.time_end_phase1\\r\\n + timedelta(hours=duration_p2)\\r\\n + timedelta(hours=duration_p3)\\r\\n + timedelta(hours=duration_p4))\\r\\n # Gets current month and is incremented for each iteration of for loop\\r\\n # to represent month number of this_month, next_month, and third_month.\\r\\n incre_month = datetime.now().month\\r\\n months = [\\\"this_month\\\", \\\"next_month\\\", \\\"third_month\\\"]\\r\\n # Calculates end of month inv. values for this, next, and third month.\\r\\n for index, _ in enumerate(months):\\r\\n # * 2 to get the number of bottles, 1 litre equals 2 bottles.\\r\\n volume = batch.volume * 2\\r\\n # True if phase4 has been reached and end month matches inc month.\\r\\n if end_phase4 != \\\"\\\" and end_phase4.month == incre_month:\\r\\n three_month_end_inv[batch.beer_type][months[index]] += volume\\r\\n # Elif True if p3 has been reached and end month matches inc month.\\r\\n elif end_phase3_4 != \\\"\\\" and end_phase3_4.month == incre_month:\\r\\n three_month_end_inv[batch.beer_type][months[index]] += volume\\r\\n # Elif True if p2 has been reached and end month matches inc month.\\r\\n elif end_phase2_4 != \\\"\\\" and end_phase2_4.month == incre_month:\\r\\n three_month_end_inv[batch.beer_type][months[index]] += volume\\r\\n # Elif True if p1 has been reached and end month matches inc month.\\r\\n elif end_phase1_4 != \\\"\\\" and end_phase1_4.month == incre_month:\\r\\n three_month_end_inv[batch.beer_type][months[index]] += volume\\r\\n incre_month += 1\\r\\n # If month number is incremented to 13, it is set to 1 (January).\\r\\n if incre_month == 13:\\r\\n incre_month = 1\\r\\n # Adds actual inventory quantities to calculated end of month quantities.\\r\\n for beer_type in three_month_end_inv:\\r\\n inventory_item_quantity = inventory.get_inv_items_quantity(beer_type)\\r\\n inventory_quantity = inventory_item_quantity[\\\"num\\\"]\\r\\n # Actual inventory quantities are only added to this_month inventory.\\r\\n three_month_end_inv[beer_type][\\\"this_month\\\"] += inventory_quantity\\r\\n # Holds three months (end of month) forecasted sales values.\\r\\n three_month_forecast = {\\\"dunkers\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0},\\r\\n \\\"pilsner\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0},\\r\\n \\\"red_helles\\\": {\\\"this_month\\\": 0, \\\"next_month\\\": 0,\\r\\n \\\"third_month\\\": 0}}\\r\\n # Builds date-index to access forecast value for this, next, and 3rd month.\\r\\n # 1. Builds date-index for this month.\\r\\n # Gets current datetime.\\r\\n current_datetime = datetime.now()\\r\\n # Gets current month.\\r\\n current_month = current_datetime.month\\r\\n # Gets current year.\\r\\n current_year = current_datetime.year\\r\\n # Creates date-index to access forecast value for this month.\\r\\n dt1st_month = datetime(current_year, current_month, 1) # 1st day of month.\\r\\n # Gets number of days of the current month.\\r\\n number_days = monthrange(current_year, current_month)[1]\\r\\n # 2. Builds date-index for next month.\\r\\n # Gets next datetime.\\r\\n next_datetime = current_datetime + timedelta(days=number_days)\\r\\n # Gets next month.\\r\\n next_month = next_datetime.month\\r\\n # Gets year in next month.\\r\\n next_months_year = next_datetime.year\\r\\n # Creates date-index to access forecast value for next month.\\r\\n dt2nd_month = datetime(next_months_year, next_month, 1)\\r\\n # Gets number of days of the next month.\\r\\n number_days = monthrange(next_months_year, next_month)[1]\\r\\n # 3. Builds date-index for 3rd month.\\r\\n # Gets 3rd datetime.\\r\\n third_datetime = next_datetime + timedelta(days=number_days)\\r\\n # Gets 3rd month.\\r\\n third_month = third_datetime.month\\r\\n # Gets year in 3rd month.\\r\\n third_months_year = third_datetime.year\\r\\n # Creates date-index to access forecast value for 3rd month.\\r\\n dt3rd_month = datetime(third_months_year, third_month, 1)\\r\\n # Gets and stores forecast values for three months in three_month_forecast.\\r\\n for beer_type in monthly_forecasts:\\r\\n forecast_1st = monthly_forecasts[beer_type].predicted_mean[dt1st_month]\\r\\n forecast_2nd = monthly_forecasts[beer_type].predicted_mean[dt2nd_month]\\r\\n forecast_3rd = monthly_forecasts[beer_type].predicted_mean[dt3rd_month]\\r\\n try:\\r\\n three_month_forecast[beer_type][\\\"this_month\\\"] = int(forecast_1st)\\r\\n three_month_forecast[beer_type][\\\"next_month\\\"] = int(forecast_2nd)\\r\\n three_month_forecast[beer_type][\\\"third_month\\\"] = int(forecast_3rd)\\r\\n except ValueError as error:\\r\\n app.config[\\\"logger\\\"].error(error)\\r\\n # Holds 3 months differ. between forecast and finished inv. for each beer.\\r\\n diff_3months_forecast_actual = {\\\"dunkers\\\": 0, \\\"pilsner\\\": 0,\\r\\n \\\"red_helles\\\": 0}\\r\\n # Calculates for each beer differ. between forecast and finished inventory.\\r\\n for beer_type in three_month_end_inv:\\r\\n # Holds finished inventory quantity for 3 months per beer type.\\r\\n fin_inv_beer_3months = 0\\r\\n # Holds forecasted sales quantity for 3 months per beer type.\\r\\n forecast_beer_3months = 0\\r\\n # 2nd for loop to iterate over dict in dict to calculate difference.\\r\\n for month in three_month_end_inv[beer_type]:\\r\\n fin_inv_beer_3months += three_month_end_inv[beer_type][month]\\r\\n forecast_beer_3months += three_month_forecast[beer_type][month]\\r\\n diff_beer_3months = fin_inv_beer_3months - forecast_beer_3months\\r\\n diff_3months_forecast_actual[beer_type] = diff_beer_3months\\r\\n # Determines which beer should be produced next;\\r\\n # beer type with highest negative difference between finished inventory and\\r\\n # sales forecast is recommended to be produced if equipment is available.\\r\\n # Gets beer type with highest negative difference.\\r\\n produce_beer = min(diff_3months_forecast_actual,\\r\\n key=lambda beer: diff_3months_forecast_actual[beer])\\r\\n used_tanks = []\\r\\n # Adds the names of all used tanks to used_tanks' list.\\r\\n for batch in batches.values():\\r\\n # True if tank is used.\\r\\n if batch.phase_current_tank != \\\"\\\":\\r\\n used_tanks.append(batch.phase_current_tank)\\r\\n all_tanks = tanks.get_tank_names()\\r\\n available_tanks = [tank for tank in all_tanks if tank not in used_tanks]\\r\\n capable_tanks = {}\\r\\n # Checks if tank with right capability is available.\\r\\n for tank_name in available_tanks:\\r\\n # Uses tank_name to get value of Tanks' instance var with same name.\\r\\n tank_value = tanks.get_tank_value(tank_name)\\r\\n # True if tank with right capability is available.\\r\\n if \\\"ferm\\\" in tank_value[\\\"capability\\\"]:\\r\\n # Puts tank's volume into capable_tanks dictionary.\\r\\n capable_tanks[tank_name] = tank_value[\\\"volume\\\"]\\r\\n # Selects tank with highest volume if tank with right capab. is available.\\r\\n if capable_tanks:\\r\\n use_tank = max(capable_tanks, key=lambda beer: capable_tanks[beer])\\r\\n use_tank_volume = capable_tanks[use_tank]\\r\\n else:\\r\\n use_tank = \\\"'currently no tank with right capability available'\\\"\\r\\n use_tank_volume = 0\\r\\n # Creates recommendation for the user.\\r\\n recommendation = (\\\"Based on the three-month forecast and production phases\\\"\\r\\n + \\\", available tanks, capabilities and volumes, it is \\\"\\r\\n + \\\"recommended to produce <b>{0}</b> in tank <b>{1}</b> \\\"\\r\\n + \\\"next.\\\").format(produce_beer, use_tank)\\r\\n # Creates reasoning for the user.\\r\\n # Creates HTML table containing three months end inventory.\\r\\n html_3months_end_inv_table = update_three_months_table(three_month_end_inv)\\r\\n # Creates HTML table containing three months forecasted sales.\\r\\n html_3months_foreca_table = update_three_months_table(three_month_forecast)\\r\\n reason = (\\\"Actual number of beers in inventory and actual number of beers \\\"\\r\\n + \\\"that will be finished in the next three months are:<br>\\\"\\r\\n + \\\"\\\"\\\"<table>\\r\\n <tr>\\r\\n <th></th>\\r\\n <th>This month</th>\\r\\n <th>Next month</th>\\r\\n <th>Third month</th>\\r\\n </tr>\\\"\\\"\\\" + html_3months_end_inv_table + \\\"</table><br>\\\"\\r\\n + \\\"Three months forecasted sales (in bottles) are:\\\"\\r\\n + \\\"\\\"\\\"<table>\\r\\n <tr>\\r\\n <th></th>\\r\\n <th>This month</th>\\r\\n <th>Next month</th>\\r\\n <th>Third month</th>\\r\\n </tr>\\\"\\\"\\\" + html_3months_foreca_table + \\\"</table><br>\\\"\\r\\n + \\\"Beer type with highest difference between forecast and \\\"\\r\\n + \\\"finished inventory is recommended to be produced if \\\"\\r\\n + \\\"equipment is available. The difference is (in bottles):<br>\\\"\\r\\n + \\\"\\\"\\\"<table>\\r\\n <tr>\\r\\n <th>Dunkers</th>\\r\\n <th>Pilsner</th>\\r\\n <th>Red Helles</th>\\r\\n </tr>\\r\\n <tr>\\r\\n <td>{0}</td>\\r\\n <td>{1}</td>\\r\\n <td>{2}</td>\\r\\n </tr></table><br>\\r\\n \\\"\\\"\\\".format(diff_3months_forecast_actual[\\\"dunkers\\\"],\\r\\n diff_3months_forecast_actual[\\\"pilsner\\\"],\\r\\n diff_3months_forecast_actual[\\\"red_helles\\\"])\\r\\n + \\\"Available tank(s) with right capability is/are:<b>\\\"\\r\\n + str(capable_tanks) + \\\"</b>, where the highest available \\\"\\r\\n + \\\"volume is <b>{}</b> litres. \\\".format(use_tank_volume)\\r\\n + (\\\"Thus, it is recommended to produce <b>{0}</b> in tank \\\"\\r\\n + \\\"<b>{1}</b>.\\\").format(produce_beer, use_tank))\\r\\n return (\\\"\\\"\\\"<style>\\r\\n h1, h2, h3 {\\r\\n font-family: arial, sans-serif;\\r\\n }\\r\\n table {\\r\\n font-family: arial, sans-serif;\\r\\n border-collapse: collapse;\\r\\n width: 100%;\\r\\n }\\r\\n td, th {\\r\\n border: 1px solid #dddddd;\\r\\n text-align: left;\\r\\n padding: 8px;\\r\\n }\\r\\n tr:nth-child(even) {\\r\\n background-color: #dddddd;\\r\\n }\\r\\n </style>\\r\\n <h2>Plan production</h2>\\\"\\\"\\\"\\r\\n + recommendation\\r\\n + \\\"<br><br><b>Reasoning:</b></br>\\\"\\r\\n + reason\\r\\n + \\\"\\\"\\\"<form action=\\\"/\\\" method=\\\"POST\\\">\\r\\n <input type=\\\"hidden\\\">\\r\\n <br>\\r\\n <input type=\\\"submit\\\" value=\\\"Go back to tracking screen\\\">\\r\\n </form>\\\"\\\"\\\")\",\n \"def ex13():\\n\\n while True:\\n try:\\n principal = decimal.Decimal(input('What is the principal amount? '))\\n break\\n except decimal.InvalidOperation:\\n print('Enter a valid principal')\\n\\n while True:\\n try:\\n rate = decimal.Decimal(input('What is the rate? '))\\n break\\n except decimal.InvalidOperation:\\n print('Enter a valid rate of interest')\\n\\n while True:\\n try:\\n term = int(input('What is the number of years? '))\\n term = decimal.Decimal(term)\\n break\\n except ValueError:\\n print('Enter a valid number of years')\\n\\n while True:\\n try:\\n frequency = int(input('What is the number of times interest is compounded per year? '))\\n frequency = decimal.Decimal(frequency)\\n break\\n except ValueError:\\n print('Enter a valid frequency')\\n\\n amount = calculate_amount(principal, rate, term, frequency)\\n\\n print('${} invested at {}% for {} years'.format(principal, rate, term))\\n print('compounded {} times per year is ${}'.format(frequency, amount))\",\n \"def solve(n):\\r\\n c=0\\r\\n Ans=0\\r\\n while c<=n:\\r\\n if isLychrel(c):\\r\\n Ans+=1\\r\\n c+=1\\r\\n return Ans\",\n \"def price_change_deviation_2_rule(_m, y):\\r\\n\\r\\n if y == m.Y.first():\\r\\n return m.z_p2[y] >= m.YEAR_AVERAGE_PRICE_0 - m.YEAR_AVERAGE_PRICE[y]\\r\\n else:\\r\\n return m.z_p2[y] >= m.YEAR_AVERAGE_PRICE[y - 1] - m.YEAR_AVERAGE_PRICE[y]\",\n \"def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\\n if not self.dates:\\n self.dates = ['2010-01-01', '2012-12-31']\\n self.load_data()\\n\\n num_months = len(self.df_all)\\n first_purchase = True\\n result = {}\\n baseline_result = {}\\n self.baseline_values = [0]\\n self.update_values = [0]\\n months = []\\n\\n # Define dataframe to save output data \\n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\\n self.opt_results_df = pd.DataFrame(columns=headers)\\n row = []\\n\\n self.price_df = pd.DataFrame(columns=self.stocks)\\n\\n # Initialize the plot\\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\\n plt.xticks(list(range(0, num_months, 2)), \\n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\\n plt.locator_params(axis='x', nbins=num_months/2)\\n plt.plot(list(range(0, num_months)), [0]*(num_months), \\n color='red', label=\\\"Break-even\\\", linewidth=0.5)\\n\\n for i in range(3, num_months):\\n\\n # Look at just the data up to the current month\\n df = self.df_all.iloc[0:i+1,:].copy()\\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\\n print(\\\"\\\\nDate:\\\", df.last_valid_index())\\n months.append(df.last_valid_index().date()) \\n\\n if first_purchase:\\n budget = self.budget\\n initial_budget = self.budget\\n baseline_shares = (budget / baseline_df_current.iloc[-1])\\n baseline_result = {self.baseline[0]: baseline_shares} \\n else:\\n # Compute profit of current portfolio\\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \\n self.update_values.append(budget - initial_budget)\\n\\n # Compute profit of fund portfolio\\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \\n for s in self.baseline]) \\n self.baseline_values.append(fund_value - initial_budget)\\n\\n self.budget = budget \\n\\n self.load_data(df=df)\\n\\n self.price_df.loc[i-2] = list(self.price.values)\\n\\n # Output for user on command-line and plot\\n update_values = np.array(self.update_values, dtype=object)\\n baseline_values = np.array(self.baseline_values, dtype=object)\\n plt.plot(range(3, i+1), update_values, \\n color='blue', label=\\\"Optimized portfolio\\\")\\n plt.plot(range(3, i+1), baseline_values, \\n color='gray', label=\\\"Fund portfolio\\\", linewidth=0.5)\\n \\n if first_purchase:\\n plt.legend(loc=\\\"lower left\\\")\\n plt.title(\\\"Start: {start}, End: {end}\\\".format\\\\\\n (start=self.df_all.first_valid_index().date(), \\n end=self.df_all.last_valid_index().date()))\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.pause(0.05)\\n \\n # Making solve run\\n if self.model_type == 'DQM':\\n print(f\\\"\\\\nMulti-Period DQM Run...\\\")\\n \\n self.build_dqm()\\n self.solution['DQM'] = self.solve_dqm()\\n result = self.solution['DQM']\\n else:\\n print(f\\\"\\\\nMulti-Period CQM Run...\\\")\\n\\n # Set budget to 0 to enforce that portfolio is self-financing \\n if self.t_cost and not first_purchase:\\n self.budget = 0 \\n\\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \\n min_return=min_return,\\n init_holdings=init_holdings)\\n result = self.solution['CQM']\\n init_holdings = result['stocks']\\n\\n # Print results to command-line\\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\\n returns = result['return']\\n variance = result['risk'] \\n\\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\\\\n [result['stocks'][s] for s in self.stocks] + \\\\\\n [variance, returns] \\n self.opt_results_df.loc[i-2] = row \\n \\n first_purchase = False\\n\\n print(self.opt_results_df)\\n print(f'\\\\nRun completed.\\\\n')\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.show(block=False)\",\n \"def curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff):\\n\\t# price dependent\\n\\tpdm = curPrice - priceMin\\n\\tpdp = curPrice - prevPrice\\n\\tq = demandIntcpt + k1 * pdm + k2 * pdm * pdm - a * shock(plus(pdp)) + b * shock(minus(pdp)) \\n\\t\\n\\t# cyclic \\n\\tq += demCycAmp * math.sin(2.0 * math.pi * coff / demCycPer)\\n\\t\\n\\t# random\\n\\tq += np.random.normal(0, randDemSd)\\n\\t\\n\\tq = plus(q)\\n\\treturn q\",\n \"def ftcs(_x,_y,_cs,_dx,_dt):\\n #todo: in a loop ... think about a more pythonic way to do this\\n\\n # s = _cs * _dt / (2. * _dx)\\n # next_y = np.zeros(np.shape(_y)) #next time step\\n # nLen = len(_y)\\n # for n in range(nLen):\\n # n_next = (n + 1) if n < (nLen-1) else 0\\n # n_prev = (n - 1) if n > 0 else nLen-1\\n #\\n # next_y[n] = _y[n] - s*(_y[n_next] - _y[n_prev])\\n #\\n # print(n, s, next_y[n], _y[n], _y[n_next], _y[n_prev])\\n #\\n # next_y = _y[:] - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\\n #\\n #\\n # return next_y\\n\\n #this can get out of hand fast (overflow), so will limit the max value\\n if np.max(_y) > 1e30:\\n _y /= 1e30 #rescale, but keep shape (it is a mess anyway, so there is no real harm)\\n\\n s = _cs * _dt / (2. * _dx)\\n next_y = _y[:] - s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))\\n\\n\\n return next_y\",\n \"def find_end_year(self, der_list):\\n project_start_year = self.start_year\\n user_given_end_year = self.end_year\\n # (1) User-defined (this should continue to be default)\\n if self.horizon_mode == 1:\\n self.end_year = user_given_end_year\\n # (2) Auto-calculate based on shortest equipment lifetime. (No size optimization)\\n if self.horizon_mode == 2:\\n shortest_lifetime = 1000 # no technology should last 1000 years -- so this is safe to hardcode\\n for der_instance in der_list:\\n shortest_lifetime = min(der_instance.expected_lifetime, shortest_lifetime)\\n if der_instance.being_sized():\\n TellUser.error(\\\"Analysis horizon mode == 'Auto-calculate based on shortest equipment lifetime', DER-VET will not size any DERs \\\" +\\n f\\\"when this horizon mode is selected. {der_instance.name} is being sized. Please resolve and rerun.\\\")\\n self.end_year = pd.Period(year=0, freq='y') # cannot preform size optimization with mode==2\\n self.end_year = project_start_year + shortest_lifetime-1\\n # (3) Auto-calculate based on longest equipment lifetime. (No size optimization)\\n if self.horizon_mode == 3:\\n longest_lifetime = 0\\n for der_instance in der_list:\\n if der_instance.technology_type != 'Load':\\n longest_lifetime = max(der_instance.expected_lifetime, longest_lifetime)\\n if der_instance.being_sized():\\n TellUser.error(\\\"Analysis horizon mode == 'Auto-calculate based on longest equipment lifetime', DER-VET will not size any DERs \\\" +\\n f\\\"when this horizon mode is selected. {der_instance.name} is being sized. Please resolve and rerun.\\\")\\n self.end_year = pd.Period(year=0, freq='y') # cannot preform size optimization with mode==3\\n self.end_year = project_start_year + longest_lifetime-1\\n return self.end_year\",\n \"def dY_dt(self, y, t=0):\\n\\t\\t \\n\\t\\t#variables\\n\\t\\tpSgg = y[0] / float(sum(y))\\n\\t\\tpSgh = y[3] / float(sum(y))\\n\\t\\tpSh = y[3] / float(y[3] + y[4] + y[5])\\n\\t\\t\\n\\t\\t#exit flows\\n\\t\\texit_Sg = y[0] * (1 / time_active) * t \\n\\t\\texit_Pg = y[1] * (1 / time_active) * t\\n\\t\\texit_PPg = y[2] * (1 / time_active) * t\\n\\t\\texit_Sh = y[3] * (1 / time_active) * t\\n\\t\\texit_Ph = y[4] * (1 / time_active) * t\\n\\t\\texit_PPh = y[5] * (1 / time_active) * t\\n\\t\\t#episodic flows\\n\\t\\tSg_to_h = y[0] * (1 / tin_g) * t\\n\\t\\tPg_to_h = y[1] * (1 / tin_g) * t\\n\\t\\tPPg_to_h = y[2] * (1 / tin_g) * t\\n\\t\\tSh_to_g = y[3] * (1 / tin_h) * t\\n\\t\\tPh_to_g = y[4] * (1 / tin_h) * t\\n\\t\\tPPh_to_g = y[5] * (1 / tin_h) * t\\n\\t\\t#entry flows\\n\\t\\tinto_g = new_g * t\\n\\t\\tinto_h = new_h * t\\n\\t\\t#infection flows\\n\\t\\tnewinf_gg = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgg * t\\n\\t\\tnewinf_gh = ((y[1] + y[4]) * B1 + (y[2] + y[5]) * B2) * Cg * pSgh * t\\n\\t\\tnewinf_h = (y[4] * B1 + y[5] * B2) * Ch * pSh * t\\n\\t\\t#stage progression flows\\n\\t\\tPg_to_PPg = y[1] * D1 * t\\n\\t\\tPPg_to_d = y[2] * D2 * t\\n\\t\\tPh_to_PPh = y[4] * D1 * t\\n\\t\\tPPh_to_d = y[5] * D2 * t\\n\\t\\t\\t\\n\\t\\tstate = [- exit_Sg - newinf_gg - Sg_to_h + into_g + Sh_to_g,\\n\\t\\t\\t\\t - exit_Pg - Pg_to_PPg - Pg_to_h + newinf_gg + Ph_to_g,\\n\\t\\t\\t\\t - exit_PPg - PPg_to_d - PPg_to_h + Pg_to_PPg + PPh_to_g,\\n\\t\\t\\t\\t - exit_Sh - newinf_gh - newinf_h - Sh_to_g + into_h + Sg_to_h,\\n\\t\\t\\t\\t - exit_Ph - Ph_to_PPh - Ph_to_g + newinf_gh + newinf_h + Pg_to_h,\\n\\t\\t\\t\\t - exit_PPh - PPh_to_d - PPh_to_g + Ph_to_PPh + PPg_to_h]\\n\\t\\n\\t\\treturn state\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n print(\\\"starting time\\\")\\n start = time.time()\\n print(\\\"hello\\\")\\n end = time.time()\\n print(\\\"time taken\\\",end - start)\\n random.shuffle(wizards)\\n assignment = wizards\\n loop_counter = 0\\n temperature = 10.0\\n while not numSat(constraints, assignment) == len(constraints):\\n loop_counter += 1\\n if loop_counter % 500 == 0:\\n print(\\\"numSat\\\", numSat(constraints, assignment))\\n print(\\\"loops\\\",loop_counter)\\n print(\\\"time taken\\\", time.time()-start)\\n a = random.sample([i for i in range(len(wizards))], 1)\\n b = random.sample([i for i in range(len(wizards))], 1)\\n new_assignment = swap(assignment, a[0], b[0])\\n delta = numSat(constraints, assignment) - numSat(constraints, new_assignment)\\n if delta < 0:\\n print(\\\"delta negative\\\")\\n assignment = new_assignment\\n else: \\n # print(\\\"sample greater than expo\\\")\\n sample = random.uniform(0.0,1.0)\\n expo = np.exp(-1*float(delta) / temperature)\\n if sample < expo:\\n # print(\\\"sample less than expo\\\")\\n assignment = new_assignment\\n temperature -= 0.2\\n\\n print(\\\"Solved BITCH! numSat:\\\", numSat(constraints, assignment))\\n return assignment\",\n \"def capital_allocation_strategy(self, coins_to_invest, available_capital):\\n coins_available_capital = 0\\n used_capital = 0\\n\\n # Count positions which capital size is not equal to max capacity of investment\\n total_positions_count = len(coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False])\\n\\n if total_positions_count > 0:\\n\\n # Divide all available capital equally by all the positions\\n coins_available_capital = available_capital / total_positions_count\\n\\n # Stopping condition: If there are no more position not fully invested or coins_available_capital is smaller then min investment\\n if total_positions_count == 0 or coins_available_capital < self.min_investment:\\n return coins_to_invest\\n\\n # Iterate all coins to invest which are not fully invested\\n for index, coins_prediction in coins_to_invest[coins_to_invest[Consts.FULLY_INVESTED] == False].copy().iterrows():\\n\\n coin_symbol = coins_prediction['coin_symbol']\\n\\n success, coin_current_volume = self.fetch_coins_24h_volumeto(coin_symbol)\\n\\n # exit if failed to fetch volume\\n if not success:\\n raise Exception\\n\\n if coin_current_volume == 0.0:\\n logger.debug(\\\"Volume is zero. Not investing in: {}, at time: {}\\\".format(coin_symbol,\\n TimeHelper.epoch_to_date_time(\\n self.time_ticker.current_time)))\\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\\n continue\\n\\n # Volume boundary of the specific coin symbol at the specific time\\n coins_max_capital_volume_boundary = self.max_percent_out_of_volume * coin_current_volume\\n\\n # If the volume boundary is smaller then available capital, then there is maximum capital in current position means = fully invested\\n if coins_max_capital_volume_boundary < coins_available_capital:\\n coins_to_invest.loc[index, Consts.FULLY_INVESTED] = True\\n max_amount_to_invest_in_coin = coins_max_capital_volume_boundary\\n else:\\n max_amount_to_invest_in_coin = coins_available_capital\\n\\n # Risk indicator which decreases positions size according to probability\\n capital_percent = self.percent_capital_according_to_probability(coins_prediction[Consts.PROB_POSITIVE_HEADER],\\n coins_prediction[Consts.PROB_NEGATIVE_HEADER],\\n coins_prediction['order_type'])\\n\\n current_capital_to_invest_in_position = capital_percent * max_amount_to_invest_in_coin\\n\\n # Add to capital to invest for current row\\n coins_to_invest.loc[index, Consts.CAPITAL_TO_INVEST] = coins_to_invest.loc[\\n index, Consts.CAPITAL_TO_INVEST] + current_capital_to_invest_in_position\\n\\n used_capital += current_capital_to_invest_in_position\\n\\n available_capital -= used_capital\\n\\n return self.capital_allocation_strategy(coins_to_invest, available_capital)\",\n \"def lax_wen(_x,_y,_cs,_dx,_dt):\\n\\n s = _cs * _dt / (2. * _dx)\\n s2 = (_cs**2.) * (_dt**2.) / (2. * (_dx**2.))\\n\\n next_y = _y[:] - s*(np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1])) \\\\\\n + s2*(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1]) - 2*_y[:])\\n\\n return next_y\",\n \"def AmericanBinomialPricer(pricing_engine, option, data):\\r\\n\\r\\n\\r\\n expiry = option.expiry\\r\\n strike = option.strike\\r\\n (spot, rate, volatility, dividend) = data.get_data()\\r\\n steps = pricing_engine.steps\\r\\n nodes = steps + 1\\r\\n dt = expiry / steps \\r\\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \\r\\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\\r\\n pu = (np.exp(rate * dt) - d) / (u - d)\\r\\n pd = 1 - pu\\r\\n disc = np.exp(-rate * expiry)\\r\\n spotT = 0.0\\r\\n payoffT = 0.0\\r\\n callT = 0.0\\r\\n putT= 0.0\\r\\n #call\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n callT = max(callT, spotT-strike)\\r\\n price = disc * payoffT\\r\\n #put\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n putT = max(putT, strike-spot)\\r\\n price = disc * payoffT\\r\\n \\r\\n return price\",\n \"def test_capital_letters(self):\\n for i in range(5):\\n price = find_cheapest_price(\\\"STAR WARS: EPISODE VI - RETURN OF THE JEDI\\\")\\n if price is \\\"69.5\\\":\\n break\\n time.sleep(1)\\n self.assertTrue(price == \\\"69.5\\\")\",\n \"def solve(self):\",\n \"def money_in_bank_given(initial, time_weeks):\\n return initial * 2 ** time_weeks\",\n \"def curProfit(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, unitCost, coff):\\n\\treturn curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff) * (curPrice - unitCost)\",\n \"def solution(self):\\n return [(\\\"the\\\", 1561900)] * 100\",\n \"def contComp(periods, pr=10, pv=100):\\n r = pr / 100 \\n return fmtFV(pv * exp(r * periods))\",\n \"def sl(*x):\\r\\n cost = float(input(\\\"Please Enter the Cost Of The Asset: \\\"))\\r\\n rv = float(input(\\\"Please Enter Estimated Residual Value Of The Asset: \\\"))\\r\\n life = float(input(\\\"Please Enter Estimated Useful Life Of The Asset (Years): \\\"))\\r\\n r = (float(cost) - float(rv)) / float(life)\\r\\n dd = float(cost)-float(rv)\\r\\n fg = float(r)/float(12)\\r\\n print \\\">> Your Depreciable Cost is\\\",dd\\r\\n print \\\">> Your Annual Depreciation is \\\",r\\r\\n print \\\">> Your Monthly Depreciation is\\\",fg\\r\\n for i in x:\\r\\n lg = float(fg)*float(i)\\r\\n print \\\">> Your Depreciation For\\\",i,\\\"Months is\\\",lg\",\n \"def backtest(dic_data, long_and_short=True, rebal_freq='M'):\\n\\n\\n if long_and_short == False:\\n\\n prices = dic_data[0]\\n l_wgt = dic_data[1]\\n initial_ammount = 100\\n returns = prices.pct_change()\\n\\n # fazemos isso para que o peso do dia anterior vá para o próximo dia.\\n # Importante, pois quando pegarmos o primeiro dia de cada mês para rebalancear, os pesos serão do último dia do mês anterior\\n l_wgt = l_wgt.shift(1)\\n\\n # fazemos isso para garantir que as primeiras linhas nao contenham somente NAN's\\n # caso isso ocorresse, o backtest nao avancaria\\n\\n l_wgt.dropna(axis=0, how='all', inplace=True)\\n\\n long_ini_period = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).nth(0)\\n long_ini_period.index = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).head(1).index\\n\\n qty = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]])\\n quota_value = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]]) * prices.loc[\\n long_ini_period.index[1]]\\n\\n dic_qty_long = {}\\n dic_quota_value_long = {}\\n dic_saldo_long = {}\\n\\n dic_qty_long[long_ini_period.index[1]] = qty\\n dic_quota_value_long[long_ini_period.index[1]] = quota_value\\n dic_saldo_long[long_ini_period.index[1]] = qty\\n\\n list_rebal_dates = long_ini_period.loc[\\n long_ini_period.index[long_ini_period.index > quota_value.name][0:]].index\\n\\n k = 0\\n for i in returns.index[returns.index > quota_value.name]:\\n\\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\\n print(str(i) + ' hora de rebalancear')\\n list_prices = prices.index.to_list()\\n position = list_prices.index(list_rebal_dates[k])\\n position_yesterday = position - 1\\n prices_in_the_day = prices.iloc[position_yesterday]\\n qty_in_the_day = dic_qty_long[list(dic_qty_long.keys())[-1]]\\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\\n new_pos = long_ini_period.iloc[k]\\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\\n new_wgt = long_ini_period.iloc[k + 2]\\n aum_in_the_day = aum_in_the_day.sum()\\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\\n new_qty[np.isnan(new_qty)] = 0\\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\\n saldo = new_qty - qty_in_the_day\\n qty = qty_in_the_day + saldo\\n dic_qty_long[i] = qty\\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_saldo_long[i] = saldo\\n print(aum_in_the_day)\\n\\n # multiplicando pelos retornos do dia\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_qty_long[i] = qty\\n soma = quota_value.sum()\\n\\n k += 1\\n\\n\\n else:\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_qty_long[i] = qty\\n soma = quota_value.sum()\\n print(soma)\\n\\n df_quota_long = pd.DataFrame(pd.concat(dic_quota_value_long, axis=0)).reset_index()\\n df_quota_long.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\\n df_quota_long = df_quota_long.pivot(index='date', columns='ticker', values='quota')\\n df_quota_long['total_aum'] = df_quota_long.sum(axis=1)\\n\\n df_saldo_long = pd.DataFrame(pd.concat(dic_saldo_long, axis=0)).reset_index()\\n df_saldo_long.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\\n df_saldo_long = df_saldo_long.pivot(index='date', columns='ticker', values='qty')\\n df_saldo_long['total_qty'] = df_saldo_long.sum(axis=1)\\n\\n return (df_quota_long, df_saldo_long)\\n\\n else:\\n\\n prices = dic_data[0]\\n l_wgt = dic_data[1]\\n s_wgt = dic_data[2]\\n initial_ammount = 100\\n returns = prices.pct_change()\\n\\n # fazemos isso para que o peso do dia anterior vá para o próximo dia.\\n # Importante, pois quando pegarmos o primeiro dia de cada mês para rebalancear, os pesos serão do último dia do mês anterior\\n l_wgt = l_wgt.shift(1)\\n s_wgt = s_wgt.shift(1)\\n\\n # fazemos isso para garantir que as primeiras linhas nao contenham somente NAN's\\n # caso isso ocorresse, o backtest nao avancaria\\n\\n l_wgt.dropna(axis=0, how='all', inplace=True)\\n s_wgt.dropna(axis=0, how='all', inplace=True)\\n\\n # Long\\n long_ini_period = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).nth(0)\\n long_ini_period.index = l_wgt.groupby(pd.DatetimeIndex(l_wgt.index).to_period(rebal_freq)).head(1).index\\n\\n qty = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]])\\n quota_value = (long_ini_period.iloc[1] * initial_ammount / prices.loc[long_ini_period.index[1]]) * prices.loc[\\n long_ini_period.index[1]]\\n\\n dic_qty_long = {}\\n dic_quota_value_long = {}\\n dic_saldo_long = {}\\n\\n dic_qty_long[long_ini_period.index[1]] = qty\\n dic_quota_value_long[long_ini_period.index[1]] = quota_value\\n dic_saldo_long[long_ini_period.index[1]] = qty\\n\\n list_rebal_dates = long_ini_period.loc[\\n long_ini_period.index[long_ini_period.index > quota_value.name][0:]].index\\n\\n k = 0\\n for i in returns.index[returns.index > quota_value.name]:\\n\\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\\n print(str(i) + ' hora de rebalancear')\\n list_prices = prices.index.to_list()\\n position = list_prices.index(list_rebal_dates[k])\\n position_yesterday = position - 1\\n prices_in_the_day = prices.iloc[position_yesterday]\\n qty_in_the_day = dic_qty_long[list(dic_qty_long.keys())[-1]]\\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\\n new_pos = long_ini_period.iloc[k]\\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\\n new_wgt = long_ini_period.iloc[k + 2]\\n aum_in_the_day = aum_in_the_day.sum()\\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\\n new_qty[np.isnan(new_qty)] = 0\\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\\n saldo = new_qty - qty_in_the_day\\n qty = qty_in_the_day + saldo\\n dic_qty_long[i] = qty\\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_saldo_long[i] = saldo\\n print(aum_in_the_day)\\n\\n # multiplicando pelos retornos do dia\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_qty_long[i] = qty\\n soma = quota_value.sum()\\n\\n k += 1\\n\\n\\n else:\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_qty_long[i] = qty\\n print(i)\\n\\n # Short\\n short_ini_period = s_wgt.groupby(pd.DatetimeIndex(s_wgt.index).to_period(rebal_freq)).nth(0)\\n short_ini_period.index = s_wgt.groupby(pd.DatetimeIndex(s_wgt.index).to_period(rebal_freq)).head(1).index\\n\\n qty = (short_ini_period.iloc[1] * initial_ammount / prices.loc[short_ini_period.index[1]])\\n quota_value = (short_ini_period.iloc[1] * initial_ammount / prices.loc[short_ini_period.index[1]]) * prices.loc[\\n short_ini_period.index[1]]\\n\\n dic_qty_short = {}\\n dic_quota_value_short = {}\\n dic_saldo_short = {}\\n\\n dic_qty_short[long_ini_period.index[1]] = qty\\n dic_quota_value_short[short_ini_period.index[1]] = quota_value\\n dic_saldo_short[short_ini_period.index[1]] = qty\\n\\n list_rebal_dates = short_ini_period.loc[\\n short_ini_period.index[short_ini_period.index > quota_value.name][0:]].index\\n\\n k = 0\\n for i in returns.index[returns.index > quota_value.name]:\\n\\n if k < len(list_rebal_dates) and i == list_rebal_dates[k]:\\n print(str(i) + ' hora de rebalancear')\\n list_prices = prices.index.to_list()\\n position = list_prices.index(list_rebal_dates[k])\\n position_yesterday = position - 1\\n prices_in_the_day = prices.iloc[position_yesterday]\\n qty_in_the_day = dic_qty_short[list(dic_qty_short.keys())[-1]]\\n aum_in_the_day = (qty_in_the_day * prices_in_the_day)\\n new_pos = short_ini_period.iloc[k]\\n wgt_in_the_day = aum_in_the_day / aum_in_the_day.sum()\\n new_wgt = short_ini_period.iloc[k + 2]\\n aum_in_the_day = aum_in_the_day.sum()\\n new_qty = new_wgt * aum_in_the_day / prices_in_the_day\\n new_qty[np.isnan(new_qty)] = 0\\n qty_in_the_day[np.isnan(qty_in_the_day)] = 0\\n saldo = new_qty - qty_in_the_day\\n qty = qty_in_the_day + saldo\\n dic_qty_short[i] = qty\\n quota_value = qty * prices_in_the_day # verificar se é esse preço msm\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_short[i] = quota_value\\n dic_saldo_short[i] = saldo\\n print(aum_in_the_day)\\n\\n # multiplicando pelos retornos do dia\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_long[i] = quota_value\\n dic_qty_long[i] = qty\\n soma = quota_value.sum()\\n\\n k += 1\\n\\n\\n else:\\n quota_value = (1 + returns.loc[i]) * quota_value\\n dic_quota_value_short[i] = quota_value\\n dic_qty_short[i] = qty\\n print(i)\\n\\n df_quota_long = pd.DataFrame(pd.concat(dic_quota_value_long, axis=0)).reset_index()\\n df_quota_long.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\\n df_quota_long = df_quota_long.pivot(index='date', columns='ticker', values='quota')\\n df_quota_long['total_aum'] = df_quota_long.sum(axis=1)\\n\\n df_saldo_long = pd.DataFrame(pd.concat(dic_saldo_long, axis=0)).reset_index()\\n df_saldo_long.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\\n df_saldo_long = df_saldo_long.pivot(index='date', columns='ticker', values='qty')\\n df_saldo_long['total_qty'] = df_saldo_long.sum(axis=1)\\n\\n df_quota_short = pd.DataFrame(pd.concat(dic_quota_value_short, axis=0)).reset_index()\\n df_quota_short.rename(columns={'level_0': 'date', 0: 'quota'}, inplace=True)\\n df_quota_short = df_quota_short.pivot(index='date', columns='ticker', values='quota')\\n df_quota_short['total_aum'] = df_quota_short.sum(axis=1)\\n\\n df_saldo_short = pd.DataFrame(pd.concat(dic_saldo_short, axis=0)).reset_index()\\n df_saldo_short.rename(columns={'level_0': 'date', 0: 'qty'}, inplace=True)\\n df_saldo_short = df_saldo_short.pivot(index='date', columns='ticker', values='qty')\\n df_saldo_short['total_qty'] = df_saldo_short.sum(axis=1)\\n\\n return (df_quota_long, df_saldo_long, df_quota_short, df_saldo_short)\",\n \"def OnEndOfAlgorithm(self):\\n\\n # liquidate all holdings (all unrealized profits/losses will be realized).\\n # long and short positions are closed irrespective of profits/losses.\\n self.Liquidate(self.currency)\",\n \"def P2l_rec(ells, cost):\\n P22 = 3 * (1 - cost**2)\\n P23 = 15 * cost * (1 - cost**2)\\n P2l = np.zeros(len(ells))\\n P2l[0] = 0.\\n P2l[1] = 0.\\n P2l[2] = P22\\n P2l[3] = P23\\n for ell in ells[4:]:\\n # print ell, P2l[ell-1], P2l[ell-2]\\n P2l[ell] = ((2 * ell - 1) * cost * P2l[ell - 1] -\\n (ell + 2 - 1) * P2l[ell - 2]) / (ell - 2)\\n return P2l\",\n \"def main():\\n\\n # Hypothesis:\\n # The `impact` encapsulates the volatility, stability and overall\\n # fluctuation of the market; in particular, movements that would\\n # affect one's portfolio, e.g. unexpected (i.e. not predicted)\\n # increases or drops in prices.\\n # For the StrategyLearner should directly affect the learned\\n # policy, particularly, in terms of willingness to take risks by\\n # betting on the behavior of the market.\\n # This can be translated into three metrics:\\n # - Number of entries:\\n # These should be reduced as market impact increases which\\n # shows the learning agent being more cautious about its bets\\n # - Cumulative return:\\n # Directly related to the point mentioned above, as market\\n # impact increases and the agent's willingness to take risks\\n # decreaes, so is the overall performance of the strategy\\n # - Training episodes:\\n # This applies specifically to the Q-Learning agent, but it\\n # is interesting to see how as the market impact increases,\\n # the number of complete training episodes (i.e. a complete\\n # pass on the trading data) is not affected. One would think\\n # that the agent would converge faster when the impact is\\n # large as it would quickly realize that the most optimal\\n # strategy is to not do anything. However, impact does not\\n # affect the rate of convergence, but rather the strategy\\n # that the agent converges to\\n\\n # Set the seed for reproducibility\\n random.seed(1481090000)\\n\\n # Experiment parameters\\n symbol = 'JPM'\\n # In-sample: January 1, 2008 to December 31 2009\\n start_date = dt.datetime(2008, 1, 1)\\n end_date = dt.datetime(2009, 12, 31)\\n starting_value = 100000\\n commission = 0.0\\n # Values to use to evaluate the effect of the impact\\n impact_values = [0.0, 0.005, 0.01, 0.05, 0.1, 0.25, 0.5, 1.0]\\n\\n all_entries = []\\n all_returns = []\\n all_episodes = []\\n\\n for impact in impact_values:\\n log.info(\\\"Evaluating the effect of impact=%s\\\", impact)\\n strategy_learner = StrategyLearner(verbose=False, impact=impact)\\n\\n log.info(\\\"Training StrategyLearner\\\")\\n strategy_learner.addEvidence(\\n symbol=symbol,\\n sd=start_date,\\n ed=end_date,\\n sv=starting_value\\n )\\n\\n log.info(\\\"Querying StrategyLearner to generate trades\\\")\\n trades = strategy_learner.testPolicy(\\n symbol=symbol,\\n sd=start_date,\\n ed=end_date,\\n sv=starting_value\\n )\\n\\n log.info(\\\"Transforming StrategyLearner trades into marketsim orders\\\")\\n orders = _convert_trades_to_marketisim_orders(symbol, trades)\\n\\n log.info(\\\"Computing portfolio values for %d orders\\\", orders.shape[0])\\n port_vals = compute_portvals(\\n orders,\\n start_val=starting_value,\\n commission=commission,\\n impact=impact\\n )\\n\\n cumulative_return = _compute_cumulative_return(port_vals)\\n\\n all_entries.append(strategy_learner.metadata['entries'])\\n all_returns.append(cumulative_return)\\n all_episodes.append(strategy_learner.metadata['training_episodes'])\\n\\n _plot_and_save_number_of_entries_per_impact_value(impact_values, all_entries)\\n _plot_and_save_number_of_episodes_per_impact_value(impact_values, all_episodes)\\n _plot_and_save_cumulative_return_per_impact_value(impact_values, all_returns)\",\n \"def boot_strap_back_ccy( sdate,\\r\\n ccy,\\r\\n instruments,\\r\\n Day_Counter ):\\r\\n convention = BS_Con[ccy]\\r\\n years_days_cash = convention[\\\"Cash_Day\\\"]\\r\\n swap_freq = convention[\\\"Swap_Freq\\\"]\\r\\n Day_Counter.set_convention(convention[\\\"Swap\\\"])\\r\\n instruments = BS_TF.check_instruments( instruments )\\r\\n \\r\\n sdate = str_2_date( sdate )\\r\\n \\r\\n flag = False\\r\\n if BS_TF.check_if_last_day_of_month( sdate ):\\r\\n flag = True\\r\\n \\\"\\\"\\\" Sdate stands for the begin of bootstrapping \\r\\n Inputs structure instruments contains:\\r\\n 1\\\\cash rates list of tuple and number of contracts \\r\\n 2\\\\future rates list of tuple and number of contracts\\r\\n 3\\\\swap rates list of tuple and number of contracts\\r\\n Structure of rate list looks like (time,rates)\\r\\n \\\"\\\"\\\"\\r\\n Cash_Rate = instruments[\\\"cash\\\"][0]\\r\\n Cash_Num = len(Cash_Rate)\\r\\n \\\"\\\"\\\" NOTE: inputs of futures rate should have one start row \\r\\n with date and the discount factor is interpolated from \\r\\n cash rate\\r\\n \\\"\\\"\\\"\\r\\n Swap_Rate = instruments[\\\"swap\\\"][0]\\r\\n units = 100\\r\\n\\r\\n discount_curve = []\\r\\n ans_curve = []\\r\\n discount_curve.append( [sdate,1] )\\r\\n ans_curve.append([sdate,1])\\r\\n \\\"\\\"\\\" Remeber par swap key dates location in discount_curve\\r\\n \\\"\\\"\\\"\\r\\n \\r\\n for i in range( 0, int(Cash_Num) ):\\r\\n \\\"\\\"\\\" Begin bootstrapping from Cash rates\\r\\n \\\"\\\"\\\"\\r\\n yearfrac = (Cash_Rate[i][0]-sdate).days/years_days_cash\\r\\n DF = 1.0/(1.0+Cash_Rate[i][1]/units*yearfrac)\\r\\n discount_curve.append([Cash_Rate[i][0],DF])\\r\\n if (Cash_Rate[i][0]-sdate).days <= 200:\\r\\n ans_curve.append([Cash_Rate[i][0],DF])\\r\\n\\r\\n Swap_Rate = BS_TF.augument_by_frequency( Swap_Rate, int(12/swap_freq) )\\r\\n \\r\\n \\\"\\\"\\\" Only do interpolation for \\r\\n the first three swaps \\r\\n 0.5y, 1y and 1.5y\\r\\n \\\"\\\"\\\"\\r\\n \\\"\\\"\\\" Pre-calculate the sum of discount \\r\\n factors of 0.5y, 1y and 1.5y based \\r\\n on the current discount curve we have \\r\\n \\\"\\\"\\\"\\r\\n sum_df = 0\\r\\n swap_frequency = relativedelta( months = int(12/swap_freq) )\\r\\n \\\"\\\"\\\" Move cur_date back to do bootstrapping\\r\\n \\\"\\\"\\\"\\r\\n cur_date = sdate\\r\\n for i in range( 1, len(discount_curve) ):\\r\\n while cur_date+swap_frequency < Swap_Rate[0][0] \\\\\\r\\n and cur_date >= discount_curve[i-1][0] \\\\\\r\\n and cur_date < discount_curve[i][0]:\\r\\n nxt_date = cur_date+swap_frequency\\r\\n if flag:\\r\\n nxt_date = BS_TF.last_day_of_month(cur_date+swap_frequency)\\r\\n yearfrac = Day_Counter.yearfrac( cur_date, nxt_date )\\r\\n DF = BS_TF.interpolation_act( nxt_date,\\r\\n discount_curve[i-1][0],\\r\\n\\t\\t\\t\\t\\t\\t discount_curve[i-1][1],\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t discount_curve[i][0],\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t discount_curve[i][1] )\\r\\n sum_df += DF*yearfrac\\r\\n ans_curve.append([nxt_date,DF])\\r\\n cur_date += swap_frequency\\r\\n if flag:\\r\\n cur_date = BS_TF.last_day_of_month(cur_date)\\r\\n \\r\\n cur_date = Swap_Rate[0][0]\\r\\n \\r\\n for i in range( 0, len(Swap_Rate) ):\\r\\n# if sum_df == 0:\\r\\n# print(\\\"Warning Cannot get correct 0.5y, 1y and 1.5y discount factors...\\\")\\r\\n# print(\\\"Current Date:\\\"+str(cur_date))\\r\\n# print(ccy)\\r\\n# print(ans_curve)\\r\\n \\\"\\\"\\\" Sum of previous discount \\r\\n factors stored in \\\"sum_df\\\"\\r\\n \\\"\\\"\\\"\\r\\n nxt_date = cur_date+swap_frequency\\r\\n if flag:\\r\\n nxt_date = BS_TF.last_day_of_month(nxt_date)\\r\\n yearfrac = Day_Counter.yearfrac( cur_date, nxt_date )\\r\\n rates = Swap_Rate[i][1]\\r\\n cur_DF = (100-sum_df*rates)/(100+rates*yearfrac)\\r\\n discount_curve.append([cur_date,cur_DF])\\r\\n ans_curve.append([cur_date,cur_DF])\\r\\n sum_df += cur_DF*yearfrac\\r\\n cur_date += swap_frequency\\r\\n if flag:\\r\\n cur_date = BS_TF.last_day_of_month(cur_date)\\r\\n \\r\\n sorted_discount_curve = sorted( ans_curve, key = lambda tup: tup[0] )\\r\\n return sorted_discount_curve\",\n \"def part_1(rules: Rules) -> int:\\n\\n happiness, _ = max(generate_arrangements(rules))\\n print(f\\\"part 1: optimal arrangement brings {happiness} happiness\\\")\\n return happiness\",\n \"def price_change_deviation_1_rule(_m, y):\\r\\n\\r\\n if y == m.Y.first():\\r\\n return m.z_p1[y] >= m.YEAR_AVERAGE_PRICE[y] - m.YEAR_AVERAGE_PRICE_0\\r\\n else:\\r\\n return m.z_p1[y] >= m.YEAR_AVERAGE_PRICE[y] - m.YEAR_AVERAGE_PRICE[y - 1]\",\n \"def initial_conditions_1(x):\\n from math import exp\\n u1 = 1\\n u2 = 2\\n return u1 * exp(- x ** 2 / 2) + u2 * exp(- (x - 1) ** 2 / 2)\",\n \"def solveBaseline(targetNum, defenders, dRewards, dPenalties, dCosts, aTypes, aRewards, aPenalties, q):\\n \\\"\\\"\\\"Contains a dummy target for defenders and attackers\\\"\\\"\\\"\\n # Add the dummy target\\n _dRewards = copy.deepcopy(dRewards)\\n _dPenalties = copy.deepcopy(dPenalties)\\n _dCosts = copy.deepcopy(dCosts)\\n _aRewards = copy.deepcopy(aRewards)\\n _aPenalties = copy.deepcopy(aPenalties)\\n for m in defenders:\\n _dRewards[m].append(0)\\n _dPenalties[m].append(0)\\n _dCosts[m].append(0)\\n for lam in aTypes:\\n _aRewards[lam].append(0)\\n _aPenalties[lam].append(0)\\n targetNumWithDummies = len(_dRewards[0])\\n targetRange = list(range(targetNumWithDummies))\\n\\n # Generate the placements and keys\\n placements = getPlacements(defenders, targetNumWithDummies)\\n attackerActions = targetRange\\n omegaKeys = getOmegaKeys(aTypes, placements, attackerActions)\\n\\n # Construct the model for each defender\\n utilityPerDefender = 0\\n utilityPerAttacker = 0\\n attackerUtility = []\\n dStrat = {}\\n models2 = {}\\n for m in defenders:\\n model2 = Model(f\\\"defenderStrategy{m}\\\")\\n x = model2.continuous_var_list(keys=targetNumWithDummies, lb=0, ub=1, name=f\\\"x{m}\\\")\\n h = model2.binary_var_dict(keys=[(lam, k) for lam in aTypes for k in targetRange], lb=0, ub=1, name=f\\\"h{m}\\\")\\n ul = model2.continuous_var_dict(keys=aTypes, lb=-model2.infinity, name=f\\\"ua{m}\\\")\\n ud = model2.continuous_var_dict(keys=[lam for lam in aTypes], lb=-model2.infinity, name=f\\\"ud{m}\\\")\\n objectiveFunction = sum([q[lam] * ud[lam] for lam in aTypes])\\n model2.add_constraints([ud[lam] <= utilityDI(m,x,i,_dRewards,_dPenalties,_dCosts) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\\\"defender utility for lam {lam}, i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([ul[lam] <= utilityLamI(x,lam,i,_aRewards,_aPenalties) + (1-h[(lam,i)]) * M for i in targetRange for lam in aTypes], names=[f\\\"lam {lam} utility leq for i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([ul[lam] >= utilityLamI(x,lam,i,_aRewards,_aPenalties) for i in targetRange for lam in aTypes], names=[f\\\"lam {lam} utility geq, for i {i}\\\" for i in targetRange for lam in aTypes])\\n model2.add_constraints([sum([h[(lam,i)] for i in targetRange]) == 1 for lam in aTypes], names=[f\\\"h sum is 1 for lam {lam}\\\" for lam in aTypes])\\n model2.add_constraint(sum([x[i] for i in targetRange]) == 1)\\n # Solve the model for each defender\\n model2.maximize(objectiveFunction)\\n model2.solve()\\n dStrat[m] = list([float(xVal) for xVal in x])\\n models[m] = model2\\n # Attacker best response (for each attacker type)\\n aStrat = {}\\n protectionOdds = probabilityProtected(dStrat, targetNumWithDummies)\\n for lam in aTypes:\\n expectedUtilities = []\\n for i in targetRange:\\n expectedUtilities.append(((1-protectionOdds[i])*_aRewards[lam][i]) + (protectionOdds[i]*_aPenalties[lam][i]))\\n aStrat[lam] = argmax(expectedUtilities)\\n attackerUtility.append(expectedUtilities[aStrat[lam]])\\n utilityPerAttacker = sum(attackerUtility)/len(aTypes)\\n\\n\\n # Calculate defender expected utility for attacker best response\\n for m in defenders:\\n for lam in aTypes:\\n attackedTarget = aStrat[lam] # The target attacked by this attacker\\n coveredUtility = protectionOdds[attackedTarget] * (_dRewards[m][attackedTarget]) # The expected utility we catch this attacker\\n uncoveredUtility = (1-protectionOdds[attackedTarget]) * (_dPenalties[m][attackedTarget]) # The expected utility we miss this attacker\\n utilityPerDefender += q[lam] * (coveredUtility + uncoveredUtility)\\n expectedCost = sum([dStrat[m][target] * _dCosts[m][target] for target in targetRange])\\n utilityPerDefender += expectedCost\\n utilityPerDefender /= len(defenders)\\n\\n return utilityPerDefender, utilityPerAttacker, None\",\n \"def year_demand_rule(_m, y):\\r\\n\\r\\n return sum(m.SCENARIO_DEMAND[y, s] for s in m.S)\",\n \"def calc_earning(self, data=None):\\n result = Result()\\n if data is None:\\n data = self.security\\n self.calcDecision()\\n first_purchase_method = self.check_first_purchase_method()\\n for i in np.arange(len(data['Close'])):\\n if data['FinalDecision'].iloc[i] is None:\\n pass\\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\\n self.buys_made += 1\\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\\n self.shares_own = self.stock_quantity\\n self.buys_made += 1\\n else:\\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\\n self.final_capital = self.final_capital % data['Close'].iloc[i]\\n #print(self.shares_own)\\n\\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n pass\\n else:\\n self.final_capital += self.shares_own * data['Close'].iloc[i]\\n self.shares_own = 0\\n self.sells_made +=1\\n #Checar si es el momento mas alto o bajo de ganancias\\n if self.shares_own == 0:\\n if (self.highest_point is None\\n or self.highest_point < self.final_capital):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > self.final_capital\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n else:\\n if (self.highest_point is None\\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n self.calcRealFinalCapital()\\n self.calcDiferencePercentage()\",\n \"def conway_polynomial(n=100):\\n \\n xs = []\\n ys = []\\n for i in range(n):\\n x = (i - n/2) / 50\\n xs.append(x)\\n\\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\\n\\n ys.append(y)\\n\\n return xs, ys\",\n \"def CalculateBestSalePercents():\\n bestForSmallCenter = (0.0,0.0,0.0,0.0,0.0)\\n bestForLargeCenter = (0.0,0.0,0.0,0.0,0.0)\\n\\n \\n\\n numRange = numpy.arange(0.0, 1, Problem2.ITER_AMOUNT)\\n print(str(numRange))\\n # time.sleep(2)\\n print()\\n X = []\\n Y = []\\n Z = []\\n for lc_sp in numRange:\\n for sc_sp in numRange:\\n print(f\\\"Trying large sale prob {lc_sp:.2f} and small sale prob {sc_sp:.2f}\\\")\\n sc_tbp, lc_tbp, actualRainPercent = Problem2.getTotalBusinessPercentForSalePercents(sc_sp, lc_sp)\\n # print(f\\\"{Problem2.GetBestsString('Item',(sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent))}\\\")\\n if (bestForSmallCenter[2] < sc_tbp):\\n bestForSmallCenter = (sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent)\\n if (bestForLargeCenter[3] < lc_tbp):\\n bestForLargeCenter = (sc_sp, lc_sp, sc_tbp, lc_tbp, actualRainPercent)\\n X.append(sc_sp)\\n Y.append(lc_sp)\\n Z.append(sc_tbp)\\n resultStr = (f\\\"\\\\nFinal results:\\\\nWeeks per trial: {Problem2.TOTAL_WEEKS}\\\\n\\\" \\n + f\\\"{Problem2.GetBestsString('Small Center',bestForSmallCenter)}\\\" \\n + f\\\"{Problem2.GetBestsString('Large Center',bestForLargeCenter)}\\\")\\n print(resultStr)\\n return X,Y,Z\",\n \"def main():\\n locale.setlocale(locale.LC_MONETARY, 'en_US')\\n print('Welcome to the Interest Calculator')\\n calcualte_interest = 'y'\\n while calcualte_interest == 'y':\\n loan_amount = prompt_loan_amount()\\n interest_rate = prompt_interest_rate()\\n interest_amount = loan_amount * interest_rate\\n\\n print('-' * 50)\\n print(f'Loan Amount: {locale.currency(loan_amount, grouping=True):>15}') #15 characters wide; right justified;\\n print(f'Interest Rate: {interest_rate:>15.3%}') #15 characters wide; right justified; % format to 3 decimal places\\n print(f'Interest Amount: {locale.currency(interest_amount, grouping=True):>15}') #15 characters wide; right justified;\\n print('-' * 50)\\n calcualte_interest = input('\\\\nContinue? (y/n): ')\",\n \"def year_absolute_price_difference_rule(_m, y):\\r\\n\\r\\n return m.z_p1[y] + m.z_p2[y]\",\n \"def BacktestStrategy2(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n recent_max=0 # recent max = 전고점 가격\\n for i in range(total_days):\\n if i==0: # 첫날은 일단 풀매수\\n recent_max=stock_exchange.GetDayHighestPrice(i)\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n else: # 다른날은 전부 전략대로 수행\\n recent_max=max(recent_max, stock_exchange.GetDayHighestPrice(i-1)) # 전고점 갱신 확인\\n # 만약 어제 종가가 전고점*threshold 미만이라면: 풀매도 \\n if (stock_exchange.GetDayClosePrice(i-1) < \\n (start_cond_dict['sell_threshold_percent']/100)*recent_max):\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n # 매도조건을 만족 안 시킨 상황에서 n개월 모멘텀이 (+)면: 풀매수 -- n개월이 안지났으면 스킵\\n elif (i > start_cond_dict['buy_momentum_days'] and \\n stock_exchange.GetDayHighestPrice(i-start_cond_dict['buy_momentum_days']) <\\n stock_exchange.GetDayOpenPrice(i)):\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n # 나머지 상황에선 포지션 홀드\\n else:\\n pass\\n invt_daily_list.append(today_invt_dict)\\n #print(today_invt_dict) # for debug :)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Experimental Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Experimental Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\",\n \"def single_curtailment_each_day_between_2_and_3_am(\\n start: datetime, end: datetime, resolution: timedelta\\n) -> DataFrame:\\n opportunity_start_time = \\\"2:00\\\"\\n opportunity_end_time = \\\"3:00\\\"\\n imbalance_value = 100 # MW\\n imbalance_price_between_2_and_3_am = 10 # EUR/MWh\\n df = initialize_df(\\n columns=[\\\"Imbalance (in MW)\\\", \\\"Price (in EUR/MWh)\\\"],\\n start=start,\\n end=end,\\n resolution=resolution,\\n )\\n df[\\\"Imbalance (in MW)\\\"].iloc[\\n df.index.indexer_between_time(\\n start_time=opportunity_start_time,\\n end_time=opportunity_end_time,\\n include_end=False,\\n )\\n ] = imbalance_value\\n df[\\\"Price (in EUR/MWh)\\\"].iloc[\\n df.index.indexer_between_time(\\n start_time=opportunity_start_time,\\n end_time=opportunity_end_time,\\n include_end=False,\\n )\\n ] = imbalance_price_between_2_and_3_am\\n return df\",\n \"def exercise_b2_82():\\r\\n pass\",\n \"def testPolicy( \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n self, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n symbol=\\\"jpm\\\", \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sd=dt.datetime(2008, 1, 1), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ed=dt.datetime(2009, 12, 31), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sv=10000, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ): \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n dates = pd.date_range(sd,ed)\\n df_prices = ind.get_price(symbol, dates)\\n\\n daily_rets = (df_prices / df_prices.shift(1)) - 1\\n daily_rets = daily_rets[1:]\\n\\n\\n sd_older = sd - dt.timedelta(days=365)\\n dates_older = pd.date_range(sd_older,ed)\\n df_prices_older = ind.get_price(symbol, dates_older)\\n sd_key = df_prices.index[0]\\n sd_index = df_prices_older.index.get_loc(sd_key)\\n\\n\\n df_holdings = df_prices.copy()\\n df_holdings['Holdings'] = np.nan\\n del df_holdings[symbol]\\n # print(df_holdings)\\n\\n cum_ret_prev = 0\\n iters = 0\\n\\n\\n num_bins = len(self.bins)\\n\\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\\n _,_,ind5 = ind.get_MACD(df_prices_older)\\n BB = ind1.iloc[sd_index:].values\\n CCI = ind2.iloc[sd_index:].values\\n SMA_Cross = ind3.iloc[sd_index:].values\\n Momentum = ind4.iloc[sd_index:].values\\n MACD = ind5.iloc[sd_index:].values\\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\\n state = x_0 + x_3*10 + x_4*100\\n\\n\\n\\n\\n\\n self.learner.rar = 0\\n\\n action = self.learner.querysetstate(state[0])\\n\\n daily_return = daily_rets.iloc[0][symbol]\\n df_holdings.iloc[0]['Holdings'] = 0\\n\\n\\n for day_idx in range(1,daily_rets.shape[0]):\\n\\n # implement action\\n cur_price = df_prices.iloc[day_idx-1][symbol]\\n next_price = df_prices.iloc[day_idx][symbol]\\n action = self.learner.querysetstate(state[day_idx])\\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\\n\\n\\n df_holdings.iloc[-1]['Holdings'] = 0\\n df_trades = df_holdings.diff()\\n df_trades['Trades'] = df_trades['Holdings']\\n del df_trades['Holdings']\\n df_trades.iloc[0]['Trades'] = 0\\n return df_trades\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def solve_p2(target: int) -> int:\\n mh = 1 + int(target / 10)\\n npresents = [0] * mh\\n for elf in range(1, mh):\\n for h in range(elf, min(mh, elf*50), elf):\\n npresents[h] += 11*elf\\n if DEBUG:\\n print(target, [(i, n) for i, n in enumerate(npresents)])\\n for h, np in enumerate(npresents):\\n if np >= target:\\n return h\\n return -1\",\n \"def test_consecutive_solving(self):\\n\\n def count_calls(func):\\n count_calls.calls = 0\\n\\n def wrapper(self, *args):\\n count_calls.calls += 1\\n return func(self)\\n\\n return wrapper\\n\\n Skyscraper._sort_permutations = count_calls(Skyscraper._sort_permutations)\\n\\n sky1 = Skyscraper((2, 2, 1, 3, 2, 2, 3, 1, 1, 2, 2, 3, 3, 2, 1, 3))\\n self.assertEqual(sky1.solve(),\\n ((1, 3, 4, 2),\\n (4, 2, 1, 3),\\n (3, 4, 2, 1),\\n (2, 1, 3, 4)))\\n\\n sky2 = Skyscraper((0, 0, 1, 2, 0, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0))\\n self.assertEqual(sky2.solve,\\n ((2, 1, 4, 3),\\n (3, 4, 1, 2),\\n (4, 2, 3, 1),\\n (1, 3, 2, 4)))\\n\\n # TODO check if count of calls works appropriately\\n self.assertEqual(Skyscraper._sort_permutations.calls, 1)\",\n \"def bringTwoC(self):\\n endC = self.countCannibalOnEnd()\\n if endC < 2:\\n return None\\n else:\\n newStart = self.start[0:2] + str(5-endC) + self.start[3]\\n newEnd = self.end[0:2] + str(endC-2) + self.end[3]\\n return MissionaryState(newStart,newEnd,\\\"bringTwoC\\\")\",\n \"def incumbant_firm(self, wage):\\n \\n \\n \\n # a. demand for capital (capital policy function)\\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\\\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\\\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\\n \\n # b. demand of labor (labor policy function)\\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\\n \\n # c. incumbant profit\\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\\\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\\n \\n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\\n W = pi / (1-self.rho)\\n \\n return pol_k, pol_n, pi, W\",\n \"def part2():\\n\\n program = IntCodeProcessor.load_program('day13input.txt')\\n program[0] = 2\\n cpu = IntCodeProcessor(program)\\n result = None\\n next_input = None\\n ball_pos = None\\n paddle_pos = None\\n score = None\\n while result is None:\\n try:\\n result = cpu.execute_program(next_input, reset=False)\\n except ExecutionError as err:\\n assert err.reason == ExecutionCode.NEED_INPUT\\n\\n ball_pos, paddle_pos, score = process_output(cpu.outputs, ball_pos, paddle_pos, score)\\n cpu.outputs = []\\n next_input = next_input_for(ball_pos, paddle_pos)\\n print(f'Part 2 answer: {score}')\",\n \"def test_example_day9_pt2():\\n assert find_pt2(ex_data, 127) == 62\",\n \"def proz(): \\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EF() #exponential window multiplication + fourier\\r\\n APK0() #1. Phase correction 0th Ordnung\\r\\n APK1() #1. Phase correction 1st Ordnung\\r\\n ABS() #Baseline correction\\r\\n APK()\\r\\n ABS() #Baseline correction\\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def evaluateY(self, time) -> float:\\n ...\",\n \"def fn(i):\\n if i == len(startTime): return 0 \\n ii = bisect_left(startTime, endTime[i])\\n return max(fn(i+1), profit[i] + fn(ii))\",\n \"def part_2(puzzle_input):\\n nr_players, nr_marbles = parse_input(puzzle_input)\\n nr_marbles *= 100\\n puzzle_string= (f\\\"{nr_players} players; last marble is worth {nr_marbles}\\\"\\n \\\" points\\\")\\n return part_1b(puzzle_string)\",\n \"def single_curtailment_or_shift_each_day_between_12_and_14_pm(\\n start: datetime, end: datetime, resolution: timedelta\\n) -> DataFrame:\\n imbalance_start_time = \\\"12:00\\\"\\n imbalance_end_time = \\\"14:00\\\"\\n imbalance_value = -2 # MW\\n imbalance_price_between_2_and_3_am = 10 # EUR/MWh\\n imbalance_price_otherwise = 5 # EUR/MWh\\n df = initialize_df(\\n columns=[\\\"Imbalance (in MW)\\\", \\\"Price (in EUR/MWh)\\\"],\\n start=start,\\n end=end,\\n resolution=resolution,\\n )\\n df[\\\"Imbalance (in MW)\\\"] = 0\\n df[\\\"Imbalance (in MW)\\\"].iloc[\\n df.index.indexer_between_time(\\n start_time=imbalance_start_time,\\n end_time=imbalance_end_time,\\n include_end=False,\\n )\\n ] = imbalance_value\\n df[\\\"Price (in EUR/MWh)\\\"] = imbalance_price_otherwise\\n df[\\\"Price (in EUR/MWh)\\\"].iloc[\\n df.index.indexer_between_time(\\n start_time=imbalance_start_time,\\n end_time=imbalance_end_time,\\n include_end=False,\\n )\\n ] = imbalance_price_between_2_and_3_am\\n return df\",\n \"def integrate_continuous_time_stochastic(self, y):\\n\\n self.compartments = self.convert_list_to_compartments(y)\\n for label in self.compartments:\\n self.compartments[label] = int(self.compartments[label])\\n\\n n_compartment = len(y)\\n n_time = len(self.target_times)\\n self.soln_array = numpy.zeros((n_time, n_compartment))\\n\\n time = self.target_times[0]\\n self.soln_array[0, :] = y\\n n_sample = 0\\n for i_time, new_time in enumerate(self.target_times):\\n\\n if i_time == 0:\\n continue\\n\\n while time < new_time:\\n self.time = time\\n self.calculate_vars()\\n self.calculate_events()\\n\\n if len(self.events) == 0:\\n # equilibrium reached, no more changes, so go\\n # to end of interval\\n dt = new_time - time\\n else:\\n event_rates = [event[2] for event in self.events]\\n i_event = pick_event(event_rates)\\n\\n total_rate = sum(event_rates)\\n dt = old_div(-math.log(random.random()), total_rate)\\n\\n from_label, to_label, rate = self.events[i_event]\\n if from_label and to_label:\\n self.compartments[from_label] -= 1\\n self.compartments[to_label] += 1\\n elif to_label is None:\\n # death\\n self.compartments[from_label] -= 1\\n elif from_label is None:\\n # birth\\n self.compartments[to_label] += 1\\n\\n self.checks()\\n time += dt\\n n_sample += 1\\n\\n if i_time < n_time:\\n y = self.convert_compartments_to_list(self.compartments)\\n self.soln_array[i_time, :] = y\",\n \"def main():\\n S = input()\\n ans = editorial(S)\\n ans2 = dp_simple(S)\\n ans3 = cumsum(S)\\n\\n assert ans == ans2 == ans3\\n if len(S) <= 5:\\n ans4 = TLE(S)\\n assert ans == ans4\\n\\n print(ans)\",\n \"def intuitive_abel_seq(p,n):\\n assert n>=2, \\\"Carleman matrix must at least be of size 2 to retrieve the coefficients.\\\"\\n B=p.carleman_matrix(n)-diagonal_matrix([1]*(n))\\n x=B[range(1,n),range(n-1)].solve_left(matrix([[1] + [0]*(n-2)]))\\n return [-1]+x[0].list()\",\n \"def compute_p2(expenses: Set[int]) -> Optional[int]:\\n unique_combinations = itertools.combinations(expenses, 2)\\n for pair in unique_combinations:\\n required = 2020 - sum(pair)\\n if required in expenses:\\n return np.prod(pair) * required\\n return None\",\n \"def y_constraint(q, xy):\\n y = ( self.L[0]*np.sin(q[0]) + self.L[1]*np.sin(q[0]+q[1]) + \\n self.L[2]*np.sin(q[0]+q[1]+q[2]) + self.L[3]*np.sin(np.sum(q)) ) - xy[1]\\n return y\",\n \"def testSuccessiveHalving(self):\\n stats = self.default_statistics()\\n sched, mock_runner = self.schedulerSetup(stats[\\\"max_trials\\\"])\\n big_bracket = sched._state[\\\"bracket\\\"]\\n cur_units = stats[str(stats[\\\"s_max\\\"])][\\\"r\\\"]\\n # The last bracket will downscale 4 times\\n for x in range(stats[\\\"brack_count\\\"] - 1):\\n trials = big_bracket.current_trials()\\n current_length = len(trials)\\n for trl in trials:\\n mock_runner._launch_trial(trl)\\n\\n # Provides results from 0 to 8 in order, keeping last one running\\n for i, trl in enumerate(trials):\\n action = sched.on_trial_result(\\n mock_runner, trl, result(cur_units, i))\\n if i < current_length - 1:\\n self.assertEqual(action, TrialScheduler.PAUSE)\\n mock_runner.process_action(trl, action)\\n\\n self.assertEqual(action, TrialScheduler.CONTINUE)\\n new_length = len(big_bracket.current_trials())\\n self.assertEqual(new_length, self.downscale(current_length, sched))\\n cur_units += int(cur_units * sched._eta)\\n self.assertEqual(len(big_bracket.current_trials()), 1)\",\n \"def calc_annual_investment(devs, devs_dom, param):\\n\\n observation_time = param[\\\"observation_time\\\"]\\n interest_rate = param[\\\"interest_rate\\\"]\\n q = 1 + param[\\\"interest_rate\\\"]\\n\\n \\n\\n \\n # Calculate capital recovery factor\\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\\n\\n \\n # Balancing Unit devices\\n \\n # Calculate annuity factor for each device\\n for device in devs.keys():\\n \\n # Get device life time\\n life_time = devs[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF \\n else:\\n devs[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF \\n \\n \\n # Building devices\\n \\n for device in devs_dom.keys():\\n \\n # Get device life time\\n life_time = devs_dom[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs_dom[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF\\n else: \\n devs_dom[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF\\n \\n \\n # Distribution devices (pipes, pumps)\\n \\n for dev in [\\\"pipe\\\", \\\"pump\\\"]: #PUmpe fehlt noch\\n \\n # Get device life time\\n life_time = param[dev + \\\"_lifetime\\\"]\\n \\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n param[\\\"ann_factor_\\\" + dev] = (1 - res_value) * CRF \\n else:\\n param[\\\"ann_factor_\\\" + dev] = ( 1 + invest_replacements - res_value) * CRF \\n\\n return devs\",\n \"def linear_annealing(self, n, total, p_initial, p_final):\\n if n == total:\\n print \\\"exploration period over\\\"\\n if n >= total:\\n return p_final\\n else:\\n return p_initial - (n * (p_initial - p_final)) / (total)\",\n \"def Bootstrap_TS(x, y):\\n\\n ycrv_swap = ycrv_construct(x,y)\\n splf = get_spot_rates(ycrv_swap, Thirty360(), TARGET(), 1+len(y)*12)\\n\\n return splf\",\n \"def return_schedule(loan, downpayment, n, rmonth):\\n # Prepare arrays:\\n principal = np.zeros(n)\\n interest = np.zeros(n)\\n\\n # Calculate monthly payment:\\n Pmonth = monthly_payment(loan, downpayment, n, rmonth)\\n\\n # Fill arrays:\\n for i in range(n):\\n if i == 0:\\n interest[i] = (loan - downpayment)*rmonth\\n else:\\n interest[i] = (loan - downpayment - np.sum(principal[:i]))*rmonth\\n principal[i] = Pmonth - interest[i]\\n print('Monthly payment is:',Pmonth,'USD')\\n return principal, interest\",\n \"def efficient_sol(rt=\\\"O(n)\\\"):\\n def bribe_count(L): # L = line\\n bribes = 0\\n # from back to front\\n for i in range(len(L) - 1, -1, -1):\\n\\n expected_index = i + 1\\n # Case 1: Expected Person already in the right spot.\\n if L[i] == expected_index:\\n continue\\n\\n # Case 2: Expected Person is 1 step away. Swap.\\n elif L[i - 1] == expected_index:\\n L[i], L[i - 1] = L[i - 1], L[i]\\n bribes += 1\\n\\n # Case 3: Expected person is 2 steps away. Put into proper place and other 2 up.\\n elif L[i - 2] == expected_index:\\n L[i - 2], L[i - 1], L[i] = L[i - 1], L[i], L[i - 2]\\n bribes += 2\\n else:\\n return \\\"Too chaotic\\\" # Expected person is more than 2 steps away.\\n return bribes\\n\\n test_count = int(input())\\n for _ in range(test_count):\\n input()\\n line = list(map(int, input().split()))\\n print(bribe_count(line))\",\n \"def exercise_b2_70():\\r\\n pass\",\n \"def test_run():\\n for symbol in ['AAPL', 'IBM']:\\n print(\\\"Max close\\\")\\n print(symbol, get_max_close(symbol))\",\n \"def solveOneStep(self):\\n ### Student code goes here\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.55686235","0.5486277","0.524329","0.52351224","0.5226248","0.5210025","0.5138276","0.5105185","0.50864774","0.5027095","0.5025979","0.5024181","0.49958742","0.49447542","0.49234024","0.49014944","0.48865473","0.48819074","0.4879534","0.48610735","0.4859504","0.4852766","0.48478216","0.48393583","0.4837062","0.48365512","0.48336682","0.48219922","0.4801332","0.47753623","0.47678152","0.47659713","0.4759692","0.47490138","0.4735495","0.473399","0.47313634","0.47302872","0.4715113","0.47070193","0.47045967","0.4694222","0.46851635","0.46829608","0.46796387","0.46740618","0.46692118","0.4665268","0.46640602","0.4663321","0.4663288","0.4662343","0.46620938","0.46614158","0.4660793","0.46579313","0.465646","0.46559346","0.46544674","0.46517196","0.46481597","0.4645406","0.46433377","0.4639456","0.4639158","0.4638863","0.46368095","0.46335286","0.46304584","0.46241793","0.46227467","0.4622686","0.46224794","0.46199685","0.46166548","0.46154514","0.4605181","0.46048668","0.4603253","0.46006238","0.45952374","0.45948905","0.45948008","0.45947385","0.45930555","0.45925152","0.4592221","0.4583763","0.45831302","0.45793608","0.45759502","0.45752758","0.45748916","0.4574432","0.45711195","0.45710188","0.45627797","0.4558052","0.4554551","0.4552873","0.45493153"],"string":"[\n \"0.55686235\",\n \"0.5486277\",\n \"0.524329\",\n \"0.52351224\",\n \"0.5226248\",\n \"0.5210025\",\n \"0.5138276\",\n \"0.5105185\",\n \"0.50864774\",\n \"0.5027095\",\n \"0.5025979\",\n \"0.5024181\",\n \"0.49958742\",\n \"0.49447542\",\n \"0.49234024\",\n \"0.49014944\",\n \"0.48865473\",\n \"0.48819074\",\n \"0.4879534\",\n \"0.48610735\",\n \"0.4859504\",\n \"0.4852766\",\n \"0.48478216\",\n \"0.48393583\",\n \"0.4837062\",\n \"0.48365512\",\n \"0.48336682\",\n \"0.48219922\",\n \"0.4801332\",\n \"0.47753623\",\n \"0.47678152\",\n \"0.47659713\",\n \"0.4759692\",\n \"0.47490138\",\n \"0.4735495\",\n \"0.473399\",\n \"0.47313634\",\n \"0.47302872\",\n \"0.4715113\",\n \"0.47070193\",\n \"0.47045967\",\n \"0.4694222\",\n \"0.46851635\",\n \"0.46829608\",\n \"0.46796387\",\n \"0.46740618\",\n \"0.46692118\",\n \"0.4665268\",\n \"0.46640602\",\n \"0.4663321\",\n \"0.4663288\",\n \"0.4662343\",\n \"0.46620938\",\n \"0.46614158\",\n \"0.4660793\",\n \"0.46579313\",\n \"0.465646\",\n \"0.46559346\",\n \"0.46544674\",\n \"0.46517196\",\n \"0.46481597\",\n \"0.4645406\",\n \"0.46433377\",\n \"0.4639456\",\n \"0.4639158\",\n \"0.4638863\",\n \"0.46368095\",\n \"0.46335286\",\n \"0.46304584\",\n \"0.46241793\",\n \"0.46227467\",\n \"0.4622686\",\n \"0.46224794\",\n \"0.46199685\",\n \"0.46166548\",\n \"0.46154514\",\n \"0.4605181\",\n \"0.46048668\",\n \"0.4603253\",\n \"0.46006238\",\n \"0.45952374\",\n \"0.45948905\",\n \"0.45948008\",\n \"0.45947385\",\n \"0.45930555\",\n \"0.45925152\",\n \"0.4592221\",\n \"0.4583763\",\n \"0.45831302\",\n \"0.45793608\",\n \"0.45759502\",\n \"0.45752758\",\n \"0.45748916\",\n \"0.4574432\",\n \"0.45711195\",\n \"0.45710188\",\n \"0.45627797\",\n \"0.4558052\",\n \"0.4554551\",\n \"0.4552873\",\n \"0.45493153\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84679,"cells":{"query":{"kind":"string","value":"Return the value at the given generation and asset a0 and corresponding consumption and labor supply when the agent chooses his next period asset a1, current period consumption c and labor n a1 is always within Kmin and Kmax"},"document":{"kind":"string","value":"def value(self, y, a0, a1):\n if y >= -self.R: # y = -2, -3, ..., -60\n c, n = (1+self.r)*a0 + self.b - a1, 0\n else:\n c, n = self.solve(a0,a1)\n\n v = self.util(c,n) + self.beta*self.vtilde[y+1](a1)\n return v if c > 0 else self.neg"},"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_cooling_output_for_supply_air_estimation(\n a_a: float, q: float, mu_c: float, v_vent: np.ndarray,\n theta_ex: np.ndarray, x_ex: np.ndarray, j: np.ndarray,\n hc_period: np.ndarray, n_p: np.ndarray, q_gen: np.ndarray, w_gen: np.ndarray, v_local: np.ndarray,\n theta_set_c: float, x_set_c: float):\n\n # specific heat of air, J/kgK\n c = get_specific_heat()\n\n # air density, kg/m3\n rho = get_air_density()\n\n # latent heat of evaporation, kJ/kg\n l_wtr = get_evaporation_latent_heat()\n\n q_d_hs_cs = np.maximum(\n (((q - 0.35 * 0.5 * 2.4) * a_a + c * rho * (v_local + sum(v_vent)) / 3600) * (\n theta_ex - theta_set_c)\n + mu_c * a_a * j + q_gen + n_p * 51.0) * 3600 * 10 ** (-6),\n 0.0) * (hc_period == 'c')\n\n q_d_hs_cl = np.maximum(\n (((v_local + sum(v_vent)) * rho * (x_ex - x_set_c) * 10 ** 3 + w_gen) * l_wtr\n + n_p * 40.0 * 3600) * 10 ** (-6), 0.0) * (hc_period == 'c')\n\n return q_d_hs_cs + q_d_hs_cl","def max_self_consumption(parameter, ppv, pl, pvmod=True, ideal=False):\r\n # Maximize self consumption for AC-coupled systems\r\n if parameter['Top'] == 'AC':\r\n\r\n # DC power output of the PV generator\r\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp \r\n if ideal:\r\n Ppv = np.maximum(0, ppv ) * parameter['P_PV'] * 1000\r\n else:\r\n Ppv = np.minimum(ppv * parameter['P_PV'], parameter['P_PV2AC_in']) * 1000\r\n else: # ppv: DC power output of the PV generator in W\r\n \r\n if ideal:\r\n Ppv = np.maximum(0, ppv)\r\n else:\r\n Ppv = np.minimum(ppv, parameter['P_PV2AC_in'] * 1000)\r\n\r\n\r\n # Normalized input power of the PV inverter\r\n ppvinvin = Ppv / parameter['P_PV2AC_in'] / 1000\r\n\r\n # AC power output of the PV inverter taking into account the conversion losses and maximum\r\n # output power of the PV inverter\r\n Ppvs = np.minimum(np.maximum(0, Ppv-(parameter['PV2AC_a_in'] * ppvinvin * ppvinvin + parameter['PV2AC_b_in'] * ppvinvin + parameter['PV2AC_c_in'])), parameter['P_PV2AC_out'] * 1000)\r\n\r\n # 3.2 Residual power\r\n\r\n # Additional power consumption of other system components (e.g. AC power meter) in W\r\n Pperi = np.ones_like(ppv) * parameter['P_PERI_AC']\r\n\r\n # Adding the standby consumption of the PV inverter in times without any AC power output of the PV system\r\n # to the additional power consumption\r\n Pperi[Ppvs == 0] += parameter['P_PVINV_AC']\r\n\r\n # Residual power\r\n if ideal:\r\n Pr = Ppv - pl\r\n else:\r\n Pr = Ppvs - pl - Pperi\r\n\r\n return Pr, Ppv, Ppvs, Pperi\r\n\r\n # Maximize self consumption for DC-coupled systems\r\n elif parameter['Top'] == 'DC':\r\n # Initialization and preallocation\r\n Ppv2ac_in_ac = np.zeros_like(ppv)\r\n Ppv = np.empty_like(ppv) # DC power output of the PV generator\r\n\r\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp\r\n Ppv = ppv * parameter['P_PV'] * 1000\r\n else:\r\n Ppv = ppv\r\n\r\n # DC power output of the PV generator taking into account the maximum\r\n # DC input power of the PV2AC conversion pathway\r\n Ppv = np.minimum(Ppv, parameter['P_PV2AC_in'] * 1000)\r\n\r\n # Residual power\r\n\r\n # Power demand on the AC side\r\n Pac = pl + parameter['P_PERI_AC']\r\n\r\n # Normalized AC output power of the PV2AC conversion pathway to cover the AC\r\n # power demand\r\n ppv2ac = np.minimum(\r\n Pac, parameter['P_PV2AC_out'] * 1000) / parameter['P_PV2AC_out'] / 1000\r\n\r\n # Target DC input power of the PV2AC conversion pathway\r\n Ppv2ac_in_ac = np.minimum(Pac, parameter['P_PV2AC_out'] * 1000) + (\r\n parameter['PV2AC_a_out'] * ppv2ac**2 + parameter['PV2AC_b_out'] * ppv2ac + parameter['PV2AC_c_out'])\r\n\r\n # Normalized DC input power of the PV2AC conversion pathway TODO 1\r\n ppv2ac = Ppv / parameter['P_PV2AC_in'] / 1000\r\n\r\n # Target AC output power of the PV2AC conversion pathway\r\n Ppv2ac_out = np.maximum(\r\n 0, Ppv - (parameter['PV2AC_a_in'] * ppv2ac**2 + parameter['PV2AC_b_in'] * ppv2ac + parameter['PV2AC_c_in']))\r\n\r\n # Residual power for battery charging\r\n Prpv = Ppv - Ppv2ac_in_ac\r\n\r\n # Residual power for battery discharging\r\n Pr = Ppv2ac_out - Pac\r\n\r\n return Pr, Prpv, Ppv, ppv2ac, Ppv2ac_out\r\n\r\n # Maximize self consumption for PV-coupled systems\r\n elif parameter['Top'] == 'PV':\r\n # Preallocation\r\n # Pbat = np.zeros_like(ppv) # DC power of the battery in W\r\n # soc = np.zeros_like(ppv) # State of charge of the battery\r\n # Ppv2ac_out = np.zeros_like(ppv) # Output power of the PV2AC conversion pathway in W\r\n # Ppv2bat_in = np.zeros_like(ppv) # Input power of the PV2BAT conversion pathway in W\r\n # Pbat2pv_out = np.zeros_like(ppv) # Output power of the BAT2PV conversion pathway in W\r\n # Ppvbs = np.zeros_like(ppv) # AC power of the PV-battery system in W\r\n Ppv = np.empty_like(ppv) # DC power output of the PV generator\r\n # Additional power consumption of other system components (e.g. AC power meter) in W\r\n Pperi = np.ones_like(ppv) * parameter['P_PERI_AC']\r\n # dt = 1 # Time increment in s\r\n # th = 0 # Start threshold for the recharging of the battery\r\n # soc0 = 0 # State of charge of the battery in the first time step\r\n\r\n # DC power output of the PV generator\r\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp\r\n Ppv = ppv * parameter['P_PV'] * 1000\r\n\r\n else: # ppv: DC power output of the PV generator in W\r\n Ppv = ppv\r\n\r\n # Power demand on the AC side\r\n Pac = pl + Pperi\r\n\r\n return Pac, Ppv, Pperi","def estimate_tr_slot(br_data_df, fab_started_at, leeway, agent_df):\r\n a = br_data_df.loc[0, 'AVG(ca_op_time)']\r\n b = br_data_df.loc[0, 'AVG(tr_op_time)']\r\n # br_data_df.loc[0, 'AVG(ca_op_time)'] == 9:\r\n #if br_data_df.loc[0, 'AVG(tr_op_time)'] == 3.5: # if these 2 conditions are met, with high prob we are in first ever auction.\r\n #fab_started_at = datetime.datetime.now()\r\n #auction_total_time = 2 # auction estimated total time = 2 min\r\n # slot_1_start = datetime.datetime.now() + datetime.timedelta(minutes=int(auction_total_time)) - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - leeway # time when on going fab started + mean ca processing time - mean tr operation time - margin.\r\n # slot_1_end = slot_1_start + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) # time when on going fab started + mean tr operation time\r\n # slot_2_start = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) - leeway # time when on going fab started + mean ca processing time - margin\r\n # slot_2_end = slot_2_start + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) # time when on going fab started + mean ca processing time + mean tr operation time\r\n ca_estimated_end = fab_started_at + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) # time when on going fab started + mean ca processing time.\r\n if br_data_df.loc[0, 'AVG(ca_op_time)'] == 9:\r\n if br_data_df.loc[0, 'AVG(tr_op_time)'] == 3.5:\r\n slot_1_start = ca_estimated_end - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - (leeway / 2)\r\n slot_1_end = ca_estimated_end + (leeway / 2)\r\n\r\n slot_1_start = ca_estimated_end - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - (leeway / 2)\r\n slot_1_end = ca_estimated_end + (leeway / 2)\r\n slot_2_start = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)']/2)) - (leeway / 2)\r\n slot_2_end = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)']/2)) + (leeway / 2) # time when on going fab started + mean ca processing time + mean tr operation time\r\n ca_to_tr_df = pd.DataFrame([], columns=['id', 'agent_type', 'location_1', 'location_2', 'location', 'purpose', 'request_type', 'action', 'time', 'slot_1_start', 'slot_1_end', 'slot_2_start', 'slot_2_end', 'slot'])\r\n ca_to_tr_df.at[0, 'id'] = agent_df.loc[0, 'id']\r\n ca_to_tr_df.at[0, 'agent_type'] = agent_df.loc[0, 'agent_type']\r\n ca_to_tr_df.at[0, 'location_1'] = agent_df.loc[0, 'location_1']\r\n ca_to_tr_df.at[0, 'location_2'] = agent_df.loc[0, 'location_2']\r\n ca_to_tr_df.at[0, 'location'] = agent_df.loc[0, 'location']\r\n ca_to_tr_df.at[0, 'purpose'] = \"request\"\r\n ca_to_tr_df.at[0, 'slot_1_start'] = slot_1_start\r\n ca_to_tr_df.at[0, 'slot_1_end'] = slot_1_end\r\n ca_to_tr_df.at[0, 'slot_2_start'] = slot_2_start\r\n ca_to_tr_df.at[0, 'slot_2_end'] = slot_2_end\r\n this_time = datetime.datetime.now()\r\n ca_to_tr_df.at[0, 'time'] = this_time\r\n ca_to_tr_df.at[0, 'request_type'] = \"request\"\r\n ca_to_tr_df.at[0, 'action'] = \"pre-book\"\r\n return ca_to_tr_df","def get_portfolio_value(prices, allocs, start_val):\n normed = prices/prices.iloc[0]\n alloced = np.multiply(allocs, normed)\n pos_vals = alloced * start_val\n port_val = pos_vals.sum(axis=1)\n return port_val","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def compute(self):\n\t\tdata = self.policy.data\n\t\tCin = xarray.zeros_like(data[self.policy.finalname]).squeeze().compute()\n\t\talphanum = tonumber(self.alpha,1/s) \n\t\tCout = data[self.policy.finalname].squeeze() \n\t\t\n\t\tfor I in range(1,len(self.policy.data[self.policy.datetimename])): \n\t\t\tcurstep = {self.policy.datetimename : I}\n\t\t\tprevstep = {self.policy.datetimename : I-1}\n\t\t\tdt = (pandas.to_timedelta((data.datetime[curstep] - data.datetime[prevstep]).values)).total_seconds()\n\t\t\tCin[curstep] = (Cin[prevstep] + alphanum*dt*Cout[curstep])/(1+alphanum*dt)\n\n\t\tdata[self.name] = Cin\n\n\t\t## Setting the final values as Cout when outside and Cin between begin and end. \n\t\tif \"enter\" in self.params: \n\t\t\tif \"stay\" not in self.params: \n\t\t\t\traise ValueError(\"Must supply both stay and enter (as timedelta str)\")\n\n\t\t\tabegin = data[self.policy.datetimename][0].values + pandas.to_timedelta(self.params[\"enter\"])\n\t\t\taend = abegin + pandas.to_timedelta(self.params[\"stay\"])\n\n\t\telse:\n\t\t\tabegin = self.params.get(\"begin\",None) \n\t\t\taend = self.params.get(\"end\" ,None) \n\n\t\tabegin = data[self.policy.datetimename].to_series()[0] if abegin is None else abegin\n\t\taend = data[self.policy.datetimename].to_series()[-1] if aend is None else aend\n\n\t\tactionTimeList = data.datetime.to_series()[data[self.policy.datetimename].to_series().between(abegin,aend)]\n\t\tdata[self.policy.finalname] = Cin.where(data[self.policy.datetimename].isin(actionTimeList),Cout)\n\t\tdata.attrs[self.actionid] = { \"type\" : self.actiontype,\"actionid\": self.actionid,\"name\" : self.name,\\\n\t\t\t\t\t\t \"params\" : {\n\t\t\t\t\t\t\t\t\"alpha\" : self.alpha,\n\t\t\t\t\t\t\t\t\"turnover\":self.turnover,\n\t\t\t\t\t\t\t\t\"begin\" : abegin,\n\t\t\t\t\t\t\t\t\"end\" : aend \n\t\t\t\t\t\t\t\t},\"outputs\" : [self.name]\n\t\t\t\t\t\t }","def eta2abc(parameter):\r\n # PV2AC conversion pathway TODO\r\n if parameter['Top'] == 'DC' or parameter['Top'] == 'PVINV' or parameter['Top'] == 'PV' and parameter['P_PV2AC_out'] is not None or parameter['Top'] == 'AC' and parameter['P_PV2AC_out'] is not None:\r\n \r\n # Create variables for the sampling points and corresponding efficiencies TODO\r\n p_pv2ac = np.fromiter((value for key, value in parameter.items() if 'p_PV2AC_' in key and value is not None), float)\r\n eta_pv2ac = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_PV2AC_' in key and value is not None), float)\r\n\r\n # Absolute input and output power in W\r\n p_pv2ac_out = parameter['P_PV2AC_out'] * p_pv2ac * 1000\r\n p_pv2ac_in = p_pv2ac_out / eta_pv2ac\r\n\r\n # Absolute power loss in W\r\n P_l_pv2ac_in = (1 - eta_pv2ac) * p_pv2ac_in\r\n P_l_pv2ac_out = (1 / eta_pv2ac - 1) * p_pv2ac_out\r\n\r\n # Polynomial curve fitting parameters of the power loss functions in W\r\n \r\n # Based on input power\r\n p = np.polyfit(p_pv2ac_in / parameter['P_PV2AC_in'] / 1000, P_l_pv2ac_in, 2)\r\n parameter['PV2AC_a_in'] = p[0]\r\n parameter['PV2AC_b_in'] = p[1]\r\n parameter['PV2AC_c_in'] = p[2]\r\n\r\n # Based on output power\r\n p = np.polyfit(p_pv2ac, P_l_pv2ac_out, 2)\r\n parameter['PV2AC_a_out'] = p[0]\r\n parameter['PV2AC_b_out'] = p[1]\r\n parameter['PV2AC_c_out'] = p[2]\r\n \r\n # PV2BAT conversion pathway\r\n if parameter['Top'] == 'DC' or parameter['Top'] == 'PV':\r\n\r\n # Create variables for the sampling points and corresponding efficiencies\r\n p_pv2bat = np.array([value for key, value in parameter.items() if 'p_PV2BAT_' in key])\r\n eta_pv2bat = np.array([value / 100 for key, value in parameter.items() if 'eta_PV2BAT_' in key])\r\n\r\n # Create missing variables\r\n\r\n # Nominal input power of the PV2BAT conversion pathway of DC-coupled systems\r\n if parameter['P_PV2BAT_in'] is None:\r\n parameter['P_PV2BAT_in'] = parameter['P_PV2BAT_out'] / (parameter['eta_PV2BAT_100'] / 100)\r\n\r\n # Absolute input and output power in W\r\n p_pv2bat_out = parameter['P_PV2BAT_out'] * p_pv2bat * 1000\r\n p_pv2bat_in = p_pv2bat_out / eta_pv2bat\r\n\r\n # Absolute power loss in W\r\n P_l_pv2bat_in = (1 - eta_pv2bat) * p_pv2bat_in\r\n P_l_pv2bat_out = (1 / eta_pv2bat - 1) * p_pv2bat_out\r\n \r\n # Polynomial curve fitting parameters of the power loss functions in W\r\n \r\n # Based on input power\r\n p = np.polyfit(p_pv2bat_in / parameter['P_PV2BAT_in'] / 1000, P_l_pv2bat_in, 2)\r\n parameter['PV2BAT_a_in'] = p[0]\r\n parameter['PV2BAT_b_in'] = p[1]\r\n parameter['PV2BAT_c_in'] = p[2]\r\n\r\n # Based on output power\r\n p = np.polyfit(p_pv2bat, P_l_pv2bat_out, 2)\r\n parameter['PV2BAT_a_out'] = p[0]\r\n parameter['PV2BAT_b_out'] = p[1]\r\n parameter['PV2BAT_c_out'] = p[2]\r\n \r\n # AC2BAT conversion pathway\r\n if parameter['Top'] == 'AC' or parameter['Top'] == 'DC' and parameter['P_AC2BAT_in'] is not None:\r\n\r\n # Create variables for the sampling points and corresponding efficiencies TODO\r\n p_ac2bat = np.fromiter((value for key, value in parameter.items() if 'p_AC2BAT_' in key), float)\r\n eta_ac2bat = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_AC2BAT_' in key), float)\r\n\r\n # Absolute input and output power in W\r\n p_ac2bat_out = parameter['P_PV2BAT_out'] * p_ac2bat * 1000\r\n p_ac2bat_in = p_ac2bat_out / eta_ac2bat\r\n\r\n # Absolute power loss in W\r\n P_l_ac2bat_in = (1 - eta_ac2bat) * p_ac2bat_in\r\n P_l_ac2bat_out = (1 / eta_ac2bat - 1) * p_ac2bat_out\r\n\r\n # Polynomial curve fitting parameters of the power loss functions in W\r\n \r\n # Based on input power\r\n p = np.polyfit(p_ac2bat_in / parameter['P_AC2BAT_in'] / 1000, P_l_ac2bat_in, 2)\r\n parameter['AC2BAT_a_in'] = p[0]\r\n parameter['AC2BAT_b_in'] = p[1]\r\n parameter['AC2BAT_c_in'] = p[2]\r\n\r\n # Based on output power\r\n p = np.polyfit(p_ac2bat, P_l_ac2bat_out, 2)\r\n parameter['AC2BAT_a_out'] = p[0]\r\n parameter['AC2BAT_b_out'] = p[1]\r\n parameter['AC2BAT_c_out'] = p[2]\r\n \r\n # BAT2AC conversion pathway\r\n if parameter['Top'] =='AC' or parameter['Top'] =='DC' or parameter['Top'] =='PV' and parameter['P_BAT2AC_out'] is not None:\r\n\r\n # Create variables for the sampling points and corresponding efficiencies TODO\r\n p_bat2ac = np.fromiter((value for key, value in parameter.items() if 'p_BAT2AC_' in key), float)\r\n eta_bat2ac = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_BAT2AC_' in key), float)\r\n\r\n # Absolute input and output power in W\r\n p_bat2ac_out = parameter['P_BAT2AC_out'] * p_bat2ac * 1000\r\n p_bat2ac_in = p_bat2ac_out / eta_bat2ac\r\n\r\n # Absolute power loss in W\r\n P_l_bat2ac_in = (1 - eta_bat2ac) * p_bat2ac_in\r\n P_l_bat2ac_out = (1 / eta_bat2ac - 1) * p_bat2ac_out\r\n\r\n # Polynomial curve fitting parameters of the power loss functions in W\r\n \r\n # Based on input power\r\n p = np.polyfit(p_bat2ac_in / parameter['P_BAT2AC_in'] / 1000, P_l_bat2ac_in, 2)\r\n parameter['BAT2AC_a_in'] = p[0]\r\n parameter['BAT2AC_b_in'] = p[1]\r\n parameter['BAT2AC_c_in'] = p[2]\r\n\r\n # Based on output power\r\n p = np.polyfit(p_bat2ac, P_l_bat2ac_out, 2)\r\n parameter['BAT2AC_a_out'] = p[0]\r\n parameter['BAT2AC_b_out'] = p[1]\r\n parameter['BAT2AC_c_out'] = p[2]\r\n \r\n # BAT2PV conversion pathway\r\n if parameter['Top'] =='PV':\r\n\r\n # Create variables for the sampling points and corresponding efficiencies TODO\r\n p_bat2pv = np.fromiter((value for key, value in parameter.items() if 'p_BAT2PV_' in key), float)\r\n eta_bat2pv = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_BAT2PV_' in key), float)\r\n\r\n # Absolute input and output power in W\r\n p_bat2pv_out = parameter['P_BAT2PV_out'] * p_bat2pv * 1000\r\n p_bat2pv_in = p_bat2pv_out / eta_bat2pv\r\n\r\n # Absolute power loss in W\r\n P_l_bat2pv_in = (1 - eta_bat2pv) * p_bat2pv_in\r\n P_l_bat2pv_out = (1 / eta_bat2pv - 1) * p_bat2pv_out\r\n\r\n # Polynomial curve fitting parameters of the power loss functions in W\r\n \r\n # Based on input power TODO\r\n p = np.polyfit(p_bat2pv_in / parameter['P_BAT2AC_in'] / 1000, P_l_bat2pv_in, 2)\r\n parameter['BAT2PV_a_in'] = p[0]\r\n parameter['BAT2PV_b_in'] = p[1]\r\n parameter['BAT2PV_c_in'] = p[2]\r\n\r\n # Based on output power\r\n p = np.polyfit(p_bat2pv, P_l_bat2pv_out, 2)\r\n parameter['BAT2PV_a_out'] = p[0]\r\n parameter['BAT2PV_b_out'] = p[1]\r\n parameter['BAT2PV_c_out'] = p[2]\r\n \r\n # Additional parameters\r\n\r\n # Mean battery capacity in kWh\r\n try:\r\n parameter['E_BAT'] = (parameter['E_BAT_usable'] / parameter['eta_BAT'] * 100 + parameter['E_BAT_usable']) / 2\r\n except:\r\n parameter['E_BAT'] = None\r\n\r\n # Mean stationary deviation of the charging power in W\r\n try:\r\n parameter['P_PV2BAT_DEV'] = parameter['P_PV2BAT_DEV_IMPORT'] - parameter['P_PV2BAT_DEV_EXPORT']\r\n except:\r\n parameter['P_PV2BAT_DEV'] = None\r\n\r\n if parameter['Top'] == 'AC':\r\n parameter['P_AC2BAT_DEV'] = parameter['P_PV2BAT_DEV'] \r\n \r\n # Mean stationary deviation of the discharging power in W\r\n try:\r\n parameter['P_BAT2AC_DEV'] = parameter['P_BAT2AC_DEV_EXPORT'] - parameter['P_BAT2AC_DEV_IMPORT']\r\n except:\r\n parameter['P_BAT2AC_DEV'] = None\r\n \r\n # Time constant for the first-order time delay element in s\r\n try:\r\n parameter['t_CONSTANT'] = (parameter['t_SETTLING'] - round(parameter['t_DEAD'])) / 3\r\n except:\r\n parameter['t_CONSTANT'] = None\r\n\r\n # Hysteresis threshold for the recharging of the battery\r\n parameter['SOC_h'] = 0.98\r\n\r\n # Feed-in power limit in kW/kWp\r\n parameter['p_ac2g_max'] = 0.7\r\n\r\n return parameter","def value(self,pt,eta,mode):\n\n self._range= get_etaFiner_key(eta)\n\n if mode == '0' :\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['efficiency_ratio']\n elif mode == '+1' :\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['err_hi'] \n elif mode == '-1' :\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['err_low']\n else: \n print 'ERROR: wrong \\'mode\\' specified: try \\'0\\',\\'+1\\' or \\'-1\\''\n return 0","def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\n if not self.dates:\n self.dates = ['2010-01-01', '2012-12-31']\n self.load_data()\n\n num_months = len(self.df_all)\n first_purchase = True\n result = {}\n baseline_result = {}\n self.baseline_values = [0]\n self.update_values = [0]\n months = []\n\n # Define dataframe to save output data \n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\n self.opt_results_df = pd.DataFrame(columns=headers)\n row = []\n\n self.price_df = pd.DataFrame(columns=self.stocks)\n\n # Initialize the plot\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\n plt.xticks(list(range(0, num_months, 2)), \n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\n plt.locator_params(axis='x', nbins=num_months/2)\n plt.plot(list(range(0, num_months)), [0]*(num_months), \n color='red', label=\"Break-even\", linewidth=0.5)\n\n for i in range(3, num_months):\n\n # Look at just the data up to the current month\n df = self.df_all.iloc[0:i+1,:].copy()\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\n print(\"\\nDate:\", df.last_valid_index())\n months.append(df.last_valid_index().date()) \n\n if first_purchase:\n budget = self.budget\n initial_budget = self.budget\n baseline_shares = (budget / baseline_df_current.iloc[-1])\n baseline_result = {self.baseline[0]: baseline_shares} \n else:\n # Compute profit of current portfolio\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \n self.update_values.append(budget - initial_budget)\n\n # Compute profit of fund portfolio\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \n for s in self.baseline]) \n self.baseline_values.append(fund_value - initial_budget)\n\n self.budget = budget \n\n self.load_data(df=df)\n\n self.price_df.loc[i-2] = list(self.price.values)\n\n # Output for user on command-line and plot\n update_values = np.array(self.update_values, dtype=object)\n baseline_values = np.array(self.baseline_values, dtype=object)\n plt.plot(range(3, i+1), update_values, \n color='blue', label=\"Optimized portfolio\")\n plt.plot(range(3, i+1), baseline_values, \n color='gray', label=\"Fund portfolio\", linewidth=0.5)\n \n if first_purchase:\n plt.legend(loc=\"lower left\")\n plt.title(\"Start: {start}, End: {end}\".format\\\n (start=self.df_all.first_valid_index().date(), \n end=self.df_all.last_valid_index().date()))\n\n plt.savefig(\"portfolio.png\")\n plt.pause(0.05)\n \n # Making solve run\n if self.model_type == 'DQM':\n print(f\"\\nMulti-Period DQM Run...\")\n \n self.build_dqm()\n self.solution['DQM'] = self.solve_dqm()\n result = self.solution['DQM']\n else:\n print(f\"\\nMulti-Period CQM Run...\")\n\n # Set budget to 0 to enforce that portfolio is self-financing \n if self.t_cost and not first_purchase:\n self.budget = 0 \n\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \n min_return=min_return,\n init_holdings=init_holdings)\n result = self.solution['CQM']\n init_holdings = result['stocks']\n\n # Print results to command-line\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\n returns = result['return']\n variance = result['risk'] \n\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\n [result['stocks'][s] for s in self.stocks] + \\\n [variance, returns] \n self.opt_results_df.loc[i-2] = row \n \n first_purchase = False\n\n print(self.opt_results_df)\n print(f'\\nRun completed.\\n')\n\n plt.savefig(\"portfolio.png\")\n plt.show(block=False)","def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\n\n # number of periods in samples\n T = df_train.shape[0]\n T_test = df_test.shape[0]\n\n # number of agents\n K = df_test.shape[1]\n\n # individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # outcomes\n outcomes = df_train.iloc[:, 0].values\n\n # initialize matrices containing all predictions and bets\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\n\n # budget initialization\n budgets = np.full(K, 1, dtype=float)\n\n # training the market\n for i in range(T):\n\n # first round betting\n pred_mat[0, :] = F[i, :]\n bet_mat[0, :] = budgets * MaxRPT_r1\n budgets = budgets * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F[i, :]\n bet_mat[j, :] = budgets * MaxRPT\n budgets = budgets * (1-MaxRPT)\n\n # use IQR to determine outlier error threshold\n abs_errors = np.abs(outcomes[i] - pred_mat)\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\n IQR = Q3 - Q1\n oet = Q3 + (IQR*1.5)\n\n # reward the agents based on accuracy of their predictions\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\n score = np.log(accuracy)\n revenue = np.multiply(score, bet_mat)\n budgets = budgets + np.sum(revenue, axis=0)\n\n # rescaling the budget (only for computational reasons)\n budgets = budgets/np.sum(budgets)\n\n # using the market for the out-of-sample predictions\n pred = np.full(T_test, np.nan, dtype=float)\n for i in range(T_test):\n\n # reset test budget\n budgets_test = np.copy(budgets)\n\n # first round betting\n pred_mat[0, :] = F_test[i, :]\n bet_mat[0, :] = budgets_test * MaxRPT_r1\n budgets_test = budgets_test * (1-MaxRPT_r1)\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F_test[i, :]\n bet_mat[j, :] = budgets_test * MaxRPT\n budgets_test = budgets_test * (1-MaxRPT)\n\n # final round market prediction is the c-APM prediction\n pred[i] = np.dot(\n pred_mat[no_rounds-1, :],\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\n\n # output\n df_pred = pd.DataFrame(\n {\"c-APM (Constant)\": pred},\n index=df_test.index\n )\n\n return df_pred","def test_best_allocation():\n\n # symbols = ['BRCM', 'TXN', 'IBM', 'HNZ'] \n symbols = ['AAPL', 'GOOG', 'IBM', 'MSFT']\n # ['GOOG','AAPL','GLD','XOM']\n basic_portfolio = BasicPortfolio(symbols, dt.datetime(2014, 1, 1), dt.datetime(2014, 12, 31))\n\n alloc = range(4)\n\n sharpe_max = 0\n alloc_max = alloc[:]\n\n for i in range(11):\n alloc[0] = i * 0.1\n for j in range(11 - i):\n alloc[1] = j * 0.1\n for k in range(11 - i - j):\n alloc[2] = k * 0.1\n alloc[3] = (10 - i - j - k) * 0.1\n\n vol, daily_ret, sharpe, cum_ret = \\\n basic_portfolio.analyze(alloc)\n\n if sharpe > sharpe_max:\n sharpe_max = sharpe\n alloc_max = alloc[:]\n\n print 'Best sharpe ratio is ', sharpe_max\n print 'Best allocation is', alloc_max\n\n ref_symbol = '$SPX'\n\n basic_portfolio.plot_with_reference(alloc_max, ref_symbol, source='local')","def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\n\n \"\"\"\n This function calculates American Opportunity Credit\n for up to four eligible students\n\n \"\"\"\n\n # Expense should not exceed the cap of $4000.\n if _cmp == 1:\n\n c87482 = max(0., min(e87482, 4000.))\n c87487 = max(0., min(e87487, 4000.))\n c87492 = max(0., min(e87492, 4000.))\n c87497 = max(0., min(e87497, 4000.))\n else:\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\n\n # Credit calculated as 100% of the first $2000 expense plus\n # 25% of amount exceeding $2000.\n if max(0, c87482 - 2000) == 0:\n c87483 = c87482\n else:\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\n\n if max(0, c87487 - 2000) == 0:\n c87488 = c87487\n else:\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\n\n if max(0, c87492 - 2000) == 0:\n c87493 = c87492\n else:\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\n\n if max(0, c87497 - 2000) == 0:\n c87498 = c87497\n else:\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\n\n # Sum of credits of all four students.\n c87521 = c87483 + c87488 + c87493 + c87498\n\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\n c87521)","def value(self,pt,eta,mode):\n\n self._eta_range= get_eta_key(eta)+'_2012B'\n self._pt_range= get_pt_key(pt)\n\n if mode == '0' :\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['efficiency'] \n elif mode == '+1' :\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['err_hi']\n elif mode == '-1' : \n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['err_low']\n else: \n print 'ERROR: wrong \\'mode\\' specified: try \\'0\\',\\'+1\\' or \\'-1\\'' \n return 0","def dispatch_max_sc(pv, demand, inv_size,param, return_series=False):\n bat_size_e_adj = param['BatteryCapacity']\n bat_size_p_adj = param['MaxPower']\n n_bat = param['BatteryEfficiency']\n n_inv = param['InverterEfficiency']\n timestep = param['timestep']\n # We work with np.ndarrays as they are much faster than pd.Series\n Nsteps = len(pv)\n LevelOfCharge = np.zeros(Nsteps)\n #inv2grid = np.zeros(Nsteps)\n inv_array=np.tile(inv_size/n_inv,len(pv))\n pv2store = np.zeros(Nsteps)\n store2inv = np.zeros(Nsteps)\n inv2curt = np.zeros(Nsteps)\n flagsell = np.zeros(Nsteps)\n flag_12h = np.zeros(Nsteps)\n store2grid = np.zeros(Nsteps)\n store2load = np.zeros(Nsteps)\n #grid2store = np.zeros(Nsteps) # TODO Always zero for now.\n\n #Load served by PV\n pv2load_dc = np.array([pv, demand / n_inv,inv_array]).min(axis=0) # DC direct self-consumption, with inverter limitation\n\n #Residual load\n res_load = demand - (pv2load_dc * n_inv) # AC\n inv2load = pv2load_dc * n_inv # AC\n\n #Excess PV\n res_pv = pv-pv2load_dc # DC\n\n #PV to storage after eff losses\n pv2inv = pv2load_dc*n_inv # AC\n\n #first timestep = 0\n LevelOfCharge[0] = 0 # bat_size_e_adj / 2 # DC\n\n\n for i in range(1,Nsteps):\n #PV to storage\n if LevelOfCharge[i-1] >= bat_size_e_adj: # if battery is full\n pv2store[i] = 0\n else: #if battery is not full\n\n if LevelOfCharge[i-1] + res_pv[i] * n_bat * timestep > bat_size_e_adj: # if battery will be full after putting excess\n pv2store[i] = min((bat_size_e_adj - LevelOfCharge[i-1]) / timestep, bat_size_p_adj)\n else:\n # pv2store[i] = min(res_pv[i], bat_size_p_adj)\n pv2store[i] = min(res_pv[i] * n_bat, bat_size_p_adj)\n #Storage to load\n if pv2store[i]==0:# modification to original algorithm (The battery cannot charge and discharge at the same time)\n store2inv[i] = min(bat_size_p_adj,(inv_size/n_inv-pv2load_dc[i]), # DC\n res_load[i] / n_inv,\n LevelOfCharge[i-1] / timestep) #modif to original, store2inv=pv2store*n_bat\n\n #SOC\n LevelOfCharge[i] = min(LevelOfCharge[i-1] - (store2inv[i] - pv2store[i]*n_bat ) * timestep, # DC\n bat_size_e_adj)#modif to original, store2inv=pv2store*n_bat\n\n pv2grid_dc=np.array([pv-pv2store,inv_array]).min(axis=0)-pv2load_dc # DC\n pv2inv= (pv2grid_dc+pv2load_dc)*n_inv # AC\n inv2curt=pv-pv2grid_dc-pv2load_dc-pv2store # DC\n\n inv2load = (pv2load_dc + store2inv) * n_inv # AC\n inv2grid = pv2grid_dc * n_inv # AC\n grid2load = demand - inv2load # AC\n #MaxDischarge = np.minimum(LevelOfCharge[i-1]*BatteryEfficiency/timestep,MaxPower)\n batt_losses=pv2store*(1-n_bat)\n inv_losses=(pv2grid_dc+pv2load_dc+store2inv)*(1-n_inv)\n #Potential Grid to storage # TODO: not an option for now in this strategy\n # GridPurchase = False\n \n out = { 'pv2inv': pv2inv, # AC\n 'res_pv':res_pv, # DC\n 'pv2store': pv2store, # DC\n 'inv2load': inv2load, # AC\n 'grid2load': grid2load, # AC\n 'store2inv': store2inv, # DC\n 'inv2curt':inv2curt, # DC\n 'LevelOfCharge': LevelOfCharge, # kWh\n 'inv2grid': inv2grid, #AC \n 'inv_losses':inv_losses,\n 'batt_losses':batt_losses,\n 'flag_sell':flagsell,\n 'flag_12h':flag_12h, \n 'store2grid':store2grid,\n 'store2load':store2inv*n_inv\n }\n if not return_series:\n out_pd = {}\n for k, v in out.items(): # Create dictionary of pandas series with same index as the input pv\n out_pd[k] = pd.Series(v, index=pv.index)\n out = out_pd\n return out","def americanprice(self):\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\n discount = math.exp( self.r*self.deltatime )\n for i in range(self.steps,0,-1):\n for j in range(i):\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\n return self.americanpay[0][0]","def value(self,pt,eta,mode):\n \n self._eta_range= get_eta_key(eta)+'_2012B'\n self._pt_range= get_pt_key(pt)\n\n if mode == '0' :\n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['efficiency'] \n elif mode == '+1' :\n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['err_hi']\n elif mode == '-1' : \n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['err_low']\n else: \n print 'ERROR: wrong \\'mode\\' specified: try \\'0\\',\\'+1\\' or \\'-1\\''\n return 0","def kA_func(self):\n\n i1 = self.inl[0].to_flow()\n i2 = self.inl[1].to_flow()\n o1 = self.outl[0].to_flow()\n o2 = self.outl[1].to_flow()\n\n T_i1 = T_bp_p(i1)\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\n\n if T_i1 <= T_o2 and not self.inl[0].T.val_set:\n T_i1 = T_o2 + 0.5\n if T_i1 <= T_o2 and not self.outl[1].T.val_set:\n T_o2 = T_i1 - 0.5\n\n if T_o1 <= T_i2 and not self.outl[0].T.val_set:\n T_o1 = T_i2 + 1\n if T_o1 <= T_i2 and not self.inl[1].T.val_set:\n T_i2 = T_o1 - 1\n\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\n\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log","def compute_actual_value(solution, actual_shows,id_to_group,group_to_ids, wtc,otc,itc,gapc, n_slots):\n \n # first convert to schedule format\n schedule = [[] for i in range(n_slots)]\n tot_shows = 0\n for p in range(len(solution)):\n if actual_shows[p] == 0:\n continue\n slot_p = solution[p]\n tot_shows+=1\n schedule[slot_p].append(p)\n #print(schedule)\n\n # if tot_shows == 0:\n # return 0, 0, 0,0,[np.nan for i in range(len(solution))]\n\n # then, for each slot, calculate the queue, etc\n tot_w = 0 # total waiting time over all slots and patients\n tot_it = 0 # total idle time\n queue = []\n wts = [0 for i in range(len(solution))]\n for i in range(n_slots):\n if len(queue) + len(schedule[i]) < 0.001:\n tot_it += 1 * itc\n # patients arrive\n queue.extend(schedule[i])\n # one patient is seen\n if len(queue) > 0:\n queue.pop(0)\n # whoever is in queue, pays wt\n for p in queue:\n wts[p] += 1 \n tot_w += len(queue) * wtc\n tot_ot = len(queue) * otc\n remaining_patients = len(queue)\n for i in range(0,remaining_patients):\n queue.pop(0)\n for p in queue:\n wts[p] += 1 \n tot_w += len(queue) * wtc\n #print(f'wtc = {tot_w}, otc = {tot_ot}')\n\n for p in range(len(solution)):\n if actual_shows[p] == 0:\n wts[p] = np.nan\n # for each group of patient in the same slot, divide their waiting time\n for slot in range(len(schedule)):\n sum_wt_in_slot = 0\n shows_in_slot = 0\n for p in schedule[slot]:\n if actual_shows[p]:\n sum_wt_in_slot += wts[p]\n shows_in_slot += 1\n for p in schedule[slot]:\n if actual_shows[p]:\n wts[p] = sum_wt_in_slot / shows_in_slot\n \n tot_cost = tot_ot + tot_w + tot_it\n return tot_cost, tot_w ,tot_ot, tot_it, wts","def calc_annual_investment(devs, devs_dom, param):\n\n observation_time = param[\"observation_time\"]\n interest_rate = param[\"interest_rate\"]\n q = 1 + param[\"interest_rate\"]\n\n \n\n \n # Calculate capital recovery factor\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\n\n \n # Balancing Unit devices\n \n # Calculate annuity factor for each device\n for device in devs.keys():\n \n # Get device life time\n life_time = devs[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs[device][\"ann_factor\"] = (1 - res_value) * CRF \n else:\n devs[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF \n \n \n # Building devices\n \n for device in devs_dom.keys():\n \n # Get device life time\n life_time = devs_dom[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs_dom[device][\"ann_factor\"] = (1 - res_value) * CRF\n else: \n devs_dom[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF\n \n \n # Distribution devices (pipes, pumps)\n \n for dev in [\"pipe\", \"pump\"]: #PUmpe fehlt noch\n \n # Get device life time\n life_time = param[dev + \"_lifetime\"]\n \n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n param[\"ann_factor_\" + dev] = (1 - res_value) * CRF \n else:\n param[\"ann_factor_\" + dev] = ( 1 + invest_replacements - res_value) * CRF \n\n return devs","def LA_contribution(self):\n pr=paraxial(self.entrance_pupil,0)\n #hnu=-u*self.entrance_pupil #n=1\n pr.propagate(self.surfaces)\n #print('hnu',hnu,1/hnu)\n #print('paraxial y ',pr.y[1:])\n #print('paraxial nu',pr.nu[:-1])\n #print('paraxial u ',pr.nu[:-1]/self.get_n()[:-1])\n #print('paraxial u ',pr.nu[:-1]/self.get_n()[:-1]/hnu/5.715023)\n #print('paraxial i ',pr.i[1:])\n ni=self.get_n()[:-1]*pr.i[1:]\n #print('ni',ni)\n marginal=beam_field()\n marginal.single_beam_from_Kingslake_Q(self.entrance_pupil,0) #marginal beam\n marginal.propagate(self.surfaces)\n Q=marginal.Kingslake_Qabs(self.surfaces)[:,0]\n Q_=marginal.Kingslake_Q_abs(self.surfaces)[:,0]\n #print('marginal Q ',marginal.Kingslake_Qabs(ls.surfaces)[:,0])\n #print('marginal Q\\'',marginal.Kingslake_Q_abs(ls.surfaces)[:,0])\n #print(Q-Q_)\n #print('paraxial nu\\'',pr.nu[1:])\n #print('sin Uk\\'',marginal.U)\n target_surface=len(self.surfaces)-1\n #print(marginal.U[3,0,1]*pr.nu[target_surface])\n nusinU=marginal.U[3,0,1]*pr.nu[target_surface] #n'u'sinU'_k all values at end focus\n LA=-(Q-Q_)*ni/nusinU\n #print('spherical LA contribution',LA)\n #print('sum',sum(LA))\n return LA","def cal_ja(Y,t,voltage_clamp_func,voltage_clamp_params):\n v = voltage_clamp_func(t,voltage_clamp_params)\n m = Y[0]\n \n tfa = 1.\n ki = 0.001 # (mM)\n \n cao = 2.5 # Davidson (mM)\n \" To do: make cai variable as an input like voltage \"\n cai = 1.e-4 # (mM) Roughly values (100 nM) from Intracellular calcium regulation among subpopulations of rat dorsal root ganglion neurons by Lu, Zhang, Gold 2007\n \n celsius = 37.\n \n def alpha(v):\n return 15.69*(81.5 - v)/(np.exp((-1.0*v+81.5)/10.0)-1.0)\n def beta(v):\n return 0.29*np.exp(-v/10.86)\n def KTF(celsius):\n return ((25./293.15)*(celsius + 273.15))\n def efun(z):\n return np.array([1 - i/2 if i < 1e-4 else i/(np.exp(i)-1) for i in z])\n def calc_ghk(v, cai, cao): \n f = KTF(celsius)/2\n nu = v/f\n return -f*(1. - (cai/cao)*np.exp(nu))*efun(nu)\n\n a = alpha(v)\n b = beta(v)\n tau = 1./(tfa*(a + b))\n minf = a/(a+b)\n dm = (minf - m)/tau\n \n \"\"\" Calculating the current \n # h gate\n h2 = ki/(ki+cai)\n gcalbar = 0.003\n ghk = calc_ghk(v,cai,cao)\n ical = gcalbar*m*m*h2*ghk\n \"\"\"\n return [dm]","def calcBeamplot(PALC_config, gamma_n, plt_ranges, f, dire_meas_LSA, dire_meas_deg):\n # general\n N = PALC_config.N\n \n########################## SIMULATION SETUP ###############################\n # maximum of discrete mapping points:\n max_points = 10000\n # mesh\n x_range = plt_ranges.p_x\n y_range = plt_ranges.p_y\n pts_x = max_points / (y_range[1]-y_range[0])\n pts_y = max_points / (x_range[1]-x_range[0])\n\n x = np.linspace(x_range[0], x_range[1], num=int(pts_x+1))\n y = np.linspace(y_range[0], y_range[1], num=int(pts_y+1))\n\n X, Y = np.meshgrid(x,y)\n # get vertically array\n x_vert = np.reshape(X, np.size(X))\n y_vert = np.reshape(Y, np.size(Y))\n z_vert = np.array([0])\n\n # reference pressure\n p0 = 2 * 10**(-5)\n # considered frequency\n omega = 2 * np.pi * f\n # initialize driving fct. and output array\n D_opt_LSA = np.ones([N, 1])\n P_LSA = np.zeros([np.shape(x_vert)[0],1], dtype=complex) \n\n # air attenuation\n T = 293.15\n p = 101.325 * 10**(3)\n h = 50\n alpha, c = AirAbsorptionCoefficient(f, T, p, h)\n\n # directivity\n if PALC_config.directivity not in ['Measured Loudspeaker Data']:\n dire_meas_LSA = np.ones([1,1])\n dire_meas_deg = np.ones([1,1])\n \n ######################### SPL CALCULATION #################################\n x_start, y_start, x_stop, y_stop, x_c_n, y_c_n, x_S, y_S = source_pos(gamma_n, PALC_config)\n\n G_LSA_vert = CalcGreenFunctions(x_vert, y_vert, z_vert, x_c_n, y_c_n, 0.82,\\\n PALC_config.directivity, PALC_config.Lambda_y, \\\n gamma_n, c, omega, 1, dire_meas_LSA, \\\n dire_meas_deg, alpha, f, 0 )\n\n P_LSA[:,0] = G_LSA_vert @ D_opt_LSA[:,0]\n\n p_SPL = 20 * np.log10(np.abs(P_LSA) / p0)\n \n p_SPL = np.reshape(p_SPL, np.shape(X))\n\n return p_SPL, X, Y","def minimum_remaining_values_with_degree(csp, ac_3=False):\n assigned = list()\n result = mrv_rec_backtracking(csp, assigned, csp.variables[:],True) \n if result is False:\n print \"fuck\"\n return csp, assigned","def calc_Cinv_CCGT(CC_size_W, CCGT_cost_data):\n\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\n # capacity for the corresponding technology from the database\n if CC_size_W < CCGT_cost_data['cap_min'][0]:\n CC_size_W = CCGT_cost_data['cap_min'][0]\n CCGT_cost_data = CCGT_cost_data[\n (CCGT_cost_data['cap_min'] <= CC_size_W) & (CCGT_cost_data['cap_max'] > CC_size_W)]\n\n\n #costs of connection\n connection_costs = ngas.calc_Cinv_gas(CC_size_W)\n\n Inv_a = CCGT_cost_data.iloc[0]['a']\n Inv_b = CCGT_cost_data.iloc[0]['b']\n Inv_c = CCGT_cost_data.iloc[0]['c']\n Inv_d = CCGT_cost_data.iloc[0]['d']\n Inv_e = CCGT_cost_data.iloc[0]['e']\n Inv_IR = CCGT_cost_data.iloc[0]['IR_%']\n Inv_LT = CCGT_cost_data.iloc[0]['LT_yr']\n Inv_OM = CCGT_cost_data.iloc[0]['O&M_%'] / 100\n\n InvC = Inv_a + Inv_b * (CC_size_W) ** Inv_c + (Inv_d + Inv_e * CC_size_W) * log(CC_size_W)\n\n Capex_a_CCGT_USD = calc_capex_annualized((InvC+connection_costs), Inv_IR, Inv_LT)\n Opex_fixed_CCGT_USD = InvC * Inv_OM\n Capex_CCGT_USD = InvC\n\n return Capex_a_CCGT_USD, Opex_fixed_CCGT_USD, Capex_CCGT_USD","def dispatch_max_sc_bhv(pv, demand, bhv,prices_binned,inv_size,param , return_series=False, bins_soc=[0,33,66,100],bins_price=[0.04,0.12,0.20,0.28],kW_dis=4):\n \n bat_size_e_adj = param['BatteryCapacity']\n bat_size_p_adj = param['MaxPower']\n n_bat = param['BatteryEfficiency']\n n_inv = param['InverterEfficiency']\n timestep = param['timestep']\n # We work with np.ndarrays as they are much faster than pd.Series\n Nsteps = len(pv)\n LevelOfCharge = np.zeros(Nsteps)\n inv2grid = np.zeros(Nsteps)\n inv_array=np.tile(inv_size/n_inv,len(pv))\n pv2store = np.zeros(Nsteps)\n store2inv = np.zeros(Nsteps)\n inv2curt = np.zeros(Nsteps)\n \n flagsell = np.zeros(Nsteps)\n store2load = np.zeros(Nsteps)\n store2grid = np.zeros(Nsteps)\n flag_12h=np.full((Nsteps), False)\n #grid2store = np.zeros(Nsteps) # TODO Always zero for now.\n \n #Load served by PV\n pv2load_dc = np.array([pv, demand / n_inv,inv_array]).min(axis=0) # DC direct self-consumption, with inverter limitation\n\n #Residual load\n res_load = demand - (pv2load_dc * n_inv) # AC\n inv2load = pv2load_dc * n_inv # AC\n\n #Excess PV\n res_pv = pv-pv2load_dc # DC\n\n #PV to storage after eff losses\n pv2inv = pv2load_dc*n_inv # AC\n\n #first timestep = 0\n LevelOfCharge[0] = 0 # bat_size_e_adj / 2 # DC\n\n #get the sp hours\n delta=dt.timedelta(hours=12)\n sp_hour=res_pv.ne(0).groupby([res_pv.index.month,res_pv.index.day]).idxmax().droplevel(1).reset_index(drop=True)\n twelve_bf=sp_hour-delta\n\n for i in range(1,Nsteps): \n #PV to storage\n if LevelOfCharge[i-1] >= bat_size_e_adj: # if battery is full\n pv2store[i] = 0\n else: #if battery is not full\n if LevelOfCharge[i-1] + res_pv[i] * n_bat * timestep > bat_size_e_adj: # if battery will be full after putting excess\n pv2store[i] = min((bat_size_e_adj - LevelOfCharge[i-1]) / timestep, bat_size_p_adj)\n else:\n# pv2store[i] = min(res_pv[i], bat_size_p_adj)\n pv2store[i] = min(res_pv[i] * n_bat, bat_size_p_adj)\n #Storage to load\n if (pv2store[i]==0)&(res_pv[i]==0): \n #According to prosumer behaviour the battery will inject into the community or not only if there is not PV suplus\n store2load[i] = min(bat_size_p_adj,(inv_size/n_inv-pv2load_dc[i]), #Power\n res_load[i] / n_inv, #Power\n LevelOfCharge[i-1] / timestep) # Power; all in DC\n if (pv.index[i]<=sp_hour[int(np.floor((i)/96))]) & (pv.index[i]>twelve_bf[int(np.floor((i)/96))]):\n #if timestep is between twelve hours before and the surplus hour\n try:\n flag_12h[i]=True\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\n (bhv.SOC_binned==np.digitize(LevelOfCharge[i-1],bins=bins_soc))&\n (bhv.surplus_time=='12h'),'sell'].values):#if sell\n #surplus_time==12h\n # sell 1 kWh of energy to the community and cover residual load if excess\n #print('12hsell')\n flagsell[i]=1\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\n kW_dis / n_inv, #Power\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\n\n # here should take into account whether the prosumer desires to sell or not according to his preferences (SOC,price)\n else: # no sell then cover only res_load\n #print('out12h')\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\n except Exception as e:\n # Ugly but provisional SOC bin from 0 to 1\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\n (bhv.SOC_binned==1)&\n (bhv.surplus_time=='12h'),'sell'].values):#if sell\n #surplus_time==12h\n # sell 1 kWh of energy to the community and cover residual load if excess\n #print('12hsell')\n flagsell[i]=1\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\n kW_dis / n_inv, #Power\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\n else: # no sell then cover only res_load\n #print('out12h')\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\n \n else: \n try:\n \n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\n (bhv.SOC_binned==np.digitize(LevelOfCharge[i-1],bins=bins_soc))&\n (bhv.surplus_time=='12h+'),'sell'].values):#if sell\n #surplus_time==12h+\n # sell 1 kWh of energy to the community and cover residual load if excess \n flagsell[i]=2\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\n kW_dis / n_inv, #Power\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\n\n # here should take into account whether the prosumer desires to sell or not according to his preferences (SOC,price)\n else: # no sell then cover only res_load\n #print('out12h+')\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\n except Exception as e:\n # Ugly but provisional SOC bin from 0 to 1\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\n (bhv.SOC_binned==1)&\n (bhv.surplus_time=='12h+'),'sell'].values):#if sell\n #surplus_time==12h\n # sell 1 kWh of energy to the community and cover residual load if excess\n #print('12hsell')\n flagsell[i]=1\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\n kW_dis / n_inv, #Power\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\n else: # no sell then cover only res_load\n #print('out12h')\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\n #SOC\n LevelOfCharge[i] = min(LevelOfCharge[i-1] - (store2inv[i] - pv2store[i]*n_bat ) * timestep, # DC\n bat_size_e_adj)#modif to original, store2inv=pv2store*n_bat\n\n pv2grid_dc=np.array([pv-pv2store,inv_array]).min(axis=0)-pv2load_dc # DC\n pv2inv= (pv2grid_dc+pv2load_dc)*n_inv # AC\n inv2curt=pv-pv2grid_dc-pv2load_dc-pv2store # DC\n\n inv2load = (pv2load_dc + store2load) * n_inv # AC\n inv2grid = (pv2grid_dc+store2grid) * n_inv # AC\n grid2load = demand - inv2load # AC\n #MaxDischarge = np.minimum(LevelOfCharge[i-1]*BatteryEfficiency/timestep,MaxPower)\n batt_losses=pv2store*(1-n_bat)\n inv_losses=(pv2grid_dc+pv2load_dc+store2inv)*(1-n_inv)\n \n out = {'pv2inv': pv2inv, # AC\n 'res_pv':res_pv, # DC\n 'pv2store': pv2store, # DC\n 'inv2load': inv2load, # AC\n 'grid2load': grid2load, # AC\n 'store2inv': store2inv, # DC\n 'inv2curt':inv2curt, # DC\n 'LevelOfCharge': LevelOfCharge, # kWh\n 'inv2grid': inv2grid, # AC\n 'inv_losses':inv_losses,\n 'batt_losses':batt_losses,\n 'flag_sell':flagsell,\n 'flag_12h':flag_12h, \n 'store2grid':store2grid*n_inv, # AC\n 'store2load':store2load*n_inv # AC\n \n }\n if not return_series:\n out_pd = {}\n for k, v in out.items(): # Create dictionary of pandas series with same index as the input pv\n out_pd[k] = pd.Series(v, index=pv.index)\n out = out_pd\n \n return out","def _determine_next_eval_point(self):\n anc_data = self._get_ancillary_data_for_acquisition()\n acq_to_use = getattr(acquisitions.asy, self.options.acq.lower())\n next_eval_point = acq_to_use(self.gp, self.acq_optimise, anc_data)\n return next_eval_point","def eta_details(self):\n\t\t# Experimentation gives you 72pts to a random science every production\n\t\t# Stupid brute force implementation for now\n\t\trequired = self.required\n\t\trate = self.player.science\n\t\tdef combine(base, add, add_time, chance):\n\t\t\t# add given add into base with +add_time tick and modified by chance\n\t\t\tfor time, p in add.items():\n\t\t\t\ttime += add_time\n\t\t\t\tp *= chance\n\t\t\t\tbase[time] = base.get(time, 0) + p\n\t\tdef _eta_details(value, time_to_prod=self.galaxy.production_rate):\n\t\t\tnaive_eta = max(0, int(math.ceil((required - value)/rate)))\n\t\t\tif naive_eta <= time_to_prod: return {naive_eta: 1}\n\t\t\tbase = {}\n\t\t\twithout_extra = _eta_details(value + rate*time_to_prod)\n\t\t\twith_extra = _eta_details(value + rate*time_to_prod + 72)\n\t\t\tcombine(base, without_extra, time_to_prod, 6/7.)\n\t\t\tcombine(base, with_extra, time_to_prod, 1/7.)\n\t\t\treturn base\n\t\treturn _eta_details(self.current, self.galaxy.production_rate - self.galaxy.production_counter)","def solve_retired(\n assets_this_period,\n assets_next_period,\n interest_rate,\n pension_benefit,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n survival_rate,\n):\n # Consumption\n consumption = get_consumption(\n assets_this_period=assets_this_period,\n assets_next_period=assets_next_period,\n pension_benefit=pension_benefit,\n labor_input=np.float64(0.0),\n interest_rate=interest_rate,\n wage_rate=np.float64(0.0),\n income_tax_rate=np.float64(0.0),\n productivity=np.float64(0.0),\n efficiency=np.float64(0.0),\n )\n\n # Flow utility\n flow_utility = util(\n consumption=consumption,\n labor_input=np.float64(0.0),\n hc_effort=np.float64(0.0),\n gamma=gamma,\n sigma=sigma,\n )\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\n\n # Calculate value on meshes (i.e. for all choices)\n value_full = flow_utility + beta * survival_rate * continuation_value\n\n # Derive optimal policies and store value function given optimal choices\n policy_capital_retired_tmp = np.argmax(value_full, axis=1)\n value_retired_tmp = np.max(value_full, axis=1)\n\n return value_retired_tmp, policy_capital_retired_tmp","def compute_port_val(allocs, prices):\n # normalized price\n # normalized prices\n normed = prices/prices.iloc[0]\n prices.head()\n alloced = normed * allocs\n\n # position values\n start_val = 1 # included to simplify adding ability to calc as $\n pos_vals = alloced * start_val\n\n # portfolio value\n port_val = pos_vals.sum(axis=1)\n\n return port_val","def solve_working(\n assets_this_period,\n assets_next_period,\n hc_this_period,\n hc_next_period,\n interest_rate,\n wage_rate,\n income_tax_rate,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n delta_hc,\n zeta,\n psi,\n n_gridpoints_capital,\n n_gridpoints_hc,\n efficiency,\n survival_rate,\n):\n # Initialize objects\n policy_labor_working_tmp = np.zeros(\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\n )\n\n # Implied hc effort\n hc_effort = get_hc_effort(\n hc_this_period=hc_this_period,\n hc_next_period=hc_next_period,\n zeta=zeta,\n psi=psi,\n delta_hc=delta_hc,\n )\n\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\n\n # Implied labor supply\n labor_input = 1 - hc_effort\n\n # Consumption\n consumption = get_consumption(\n assets_this_period=assets_this_period,\n assets_next_period=assets_next_period,\n pension_benefit=np.float64(0.0),\n labor_input=labor_input,\n interest_rate=interest_rate,\n wage_rate=wage_rate,\n income_tax_rate=income_tax_rate,\n productivity=hc_this_period,\n efficiency=efficiency,\n )\n\n # Flow utility\n flow_utility = util(\n consumption=consumption,\n labor_input=labor_input,\n hc_effort=hc_effort,\n gamma=gamma,\n sigma=sigma,\n )\n\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\n\n # Value function on the complete mesh (i.e. for all possible choices)\n value_full = flow_utility + beta * survival_rate * continuation_value\n\n # Derive optimal policies and store value function given optimal choices\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\n for assets_this_period_idx in range(n_gridpoints_capital):\n for hc_this_period_idx in range(n_gridpoints_hc):\n assets_next_period_idx = policy_capital_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n hc_next_period_idx = policy_hc_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ]\n policy_labor_working_tmp[\n assets_this_period_idx, hc_this_period_idx\n ] = labor_input[\n assets_this_period_idx,\n assets_next_period_idx,\n hc_this_period_idx,\n hc_next_period_idx,\n ]\n\n return (\n policy_capital_working_tmp,\n policy_hc_working_tmp,\n policy_labor_working_tmp,\n value_working_tmp,\n )","def obj(k_next) : \n \n if method==1 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\n elif method==2 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\n elif method==3 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\n \n return value_vec","def call_option_value(x_s, x_y, tau_y, x_sigma, m_moneyness, tau_implvol,\n k_strk, t_end, t_hor):\n\n x_sigma = x_sigma.reshape(-1)\n\n # Step 1: Compute time to expiry of the call option at thor\n\n tau = np.busday_count(t_hor, t_end)/252\n\n # Step 2: Compute value of the underlying\n\n s = np.exp(x_s)\n\n # Step 3: Compute m moneyness\n\n m = np.log(s/k_strk)/np.sqrt(tau)\n\n # Step 4: Compute shadow yield\n\n if x_y.shape[0] == 1:\n x_y_interp = x_y\n else:\n interp = sp.interpolate.interp1d(tau_y.flatten(), x_y, axis=1,\n fill_value='extrapolate')\n x_y_interp = interp(tau)\n\n # Step 5: Compute discount rate\n\n y = shadowrates_ytm(x_y_interp)\n\n # Step 6: Compute log-implied volatility in point (m, tau)\n\n points = list(zip(*[grid.flatten() for grid in\n np.meshgrid(*[tau_implvol, m_moneyness])]))\n m_e = min(max(m, min(m_moneyness)), max(m_moneyness)) # extrapolation\n tau_e = min(max(tau, tau_implvol[0]), tau_implvol[-1]) # extrapolation\n x_sigma_interp = \\\n interpolate.LinearNDInterpolator(points, x_sigma)(*np.r_[tau_e, m_e])\n\n # Step 7: Compute implied volatility\n\n sigma_interp = np.exp(x_sigma_interp)\n\n # Step 8: Compute call option value\n\n v = bsm_function(s, y, sigma_interp, m, tau)\n\n return v","def find_allocation_for_graph(self,consumption_graph : ConsumptionGraph):\n mat = cvxpy.Variable((self.num_of_agents, self.num_of_items))\n constraints = []\n # every var >=0 and if there is no edge the var is zero\n # and proportional condition\n for i in range(self.num_of_agents):\n count = 0\n for j in range(self.num_of_items):\n if (consumption_graph.get_graph()[i][j] == 0):\n constraints.append(mat[i][j] == 0)\n else:\n constraints.append(mat[i][j] >= 0)\n count += mat[i][j] * self.valuation[i][j]\n constraints.append(count >= sum(self.valuation[i]) / len(self.valuation))\n # the sum of each column is 1 (the property on each object is 100%)\n for i in range(self.num_of_items):\n constraints.append(sum(mat[:, i]) == 1)\n \"\"\"\n # the proportional condition\n count = 0\n for i in range(len(consumption_graph)):\n count = 0\n for j in range(len(consumption_graph[i])):\n count += mat[i][j] * matv[i][j]\n constraints.append(count >= sum(matv[i]) / len(matv[i]))\n \"\"\"\n objective = cvxpy.Maximize(1)\n prob = cvxpy.Problem(objective, constraints)\n prob.solve() # Returns the optimal value.\n if not (prob.status == 'infeasible'):\n alloc = Allocation(mat.value)\n alloc.round()\n if(alloc.num_of_shering() < self.min_sharing_number):\n self.min_sharing_number = alloc.num_of_shering()\n self.min_sharing_allocation = alloc.get_allocation()\n # only for doctet:\n return (mat.value)","def ecg_diagnose(apn):\n # Total minutes of apnea\n apnea_total = sum(apn)\n\n # Maximum hourly Apnea Index\n total_hour = int(len(apn) / 60)\n y_pred_hourly = np.reshape(apn[: total_hour * 60], (total_hour, 60))\n AI_hourly = y_pred_hourly.sum(axis=1)\n # If data in the last hour exceed 30 minutes, then convert to hourly result\n y_pred_left = apn[total_hour * 60 :]\n # if len(y_pred_left) >= 30:\n # AI_hourly = np.append(AI_hourly, sum(y_pred_left) * 60 / len(y_pred_left))\n # total_hour += 1\n AI_max = AI_hourly.max()\n\n if AI_max >= 10 and apnea_total >= 100:\n return \"A\"\n elif AI_max >= 5 and apnea_total >= 5:\n return \"B\"\n else:\n return \"C\"","def hrc_gain_fit_gaus(c_input):\n#\n#--- if an obsid is provided, analyize that, else get new obsids from databases\n#\n\n if mcf.chkNumeric(c_input):\n candidate_list = [c_input]\n else:\n candidate_list = arlist.hrc_gain_find_ar_lac()\n\n if len(candidate_list) > 0:\n for obsid in candidate_list:\n file = extract_hrc_evt2(obsid)\n if file == 'na':\n continue\n#\n#--- get a file name header for the later use\n#\n temp = re.split('N', file)\n hname = temp[0]\n#\n#--- extract information from the fits file header\n#\n [obsid, detnam, date_obs, date_end, tstart, tstop, ra_pnt, dec_pnt, ra_nom, dec_nom, roll_pnt, foc_len, defocus, sim_x, sim_y, sim_z] = find_header_info(file)\n#\n#--- find the diffrence between real AR Lac position and nominal postion so that we can determin how much area we should include \n#\n ra_diff = abs(ra - ra_nom) * 60.0\n dec_diff = abs(dec - dec_nom) * 60.0\n rad_diff = math.sqrt(ra_diff * ra_diff + dec_diff * dec_diff)\n\n if rad_diff < 10.0:\n fit_rad = 60.0\n else:\n fit_rad = 200.0\n#\n#--- find a location of the brightest object (assume it is AR Lac) in sky coordinates\n#\n [x, y] = find_center(file)\n#\n#--- extract pha values in the given area\n#\n pha = extract_pha(file, x, y, fit_rad)\n#\n#--- create pha count distribution\n#\n pmax = max(pha) + 1\n pha_bin = [x for x in range(0, pmax)]\n pha_hist = [0 for x in range(0, pmax)]\n\n for ent in pha:\n pha_hist[ent] += 1\n#\n#--- print out the distirbution results\n#\n outfile = data_dir + hname + '_pha.dat'\n fo = open(outfile, 'w')\n for i in range(0, pmax):\n line = str(pha_bin[i]) + '\\t' + str(pha_hist[i]) + '\\n'\n fo.write(line)\n fo.close()\n#\n#--- find median point\n#\n med = find_med(pha_hist)\n#\n#--- fit a normal distribution on the data\n#\n [amp, center, width] = fit_gauss(pha_bin, pha_hist)\n#\n#--- print out the fitting result\n#\n outfile = house_keeping + 'fitting_results'\n\n copied_file = outfile + '~'\n cmd = 'cp ' + outfile + ' ' + copied_file\n os.system(cmd)\n\n fo = open(outfile, 'a')\n line = str(obsid) + '\\t' + date_obs + '\\t' + str(tstart) + '\\t' + detnam + '\\t' + str(ra_pnt) + '\\t' + str(dec_pnt) + '\\t\\t'\n line = line + str(round(ra_diff,3)) + '\\t' + str(round(dec_diff, 3)) + '\\t' + str(round(rad_diff,3)) + '\\t' + str(med) + '\\t\\t'\n line = line + str(round(center, 3)) + '\\t' + str(round(amp, 3)) + '\\t' + str(round(width, 3)) + '\\t'\n line = line + str(roll_pnt) + '\\t' + str(foc_len) + '\\t' + str(defocus) + '\\t'\n line = line + str(sim_x) + '\\t' + str(sim_y) + '\\t' + str(sim_z) + '\\n'\n fo.write(line)\n fo.close()\n#\n#--- plot the data\n#\n outfile = plot_dir + hname + '_gfit.png'\n plot_gauss(pha_bin, pha_hist, amp, center, width, file, outfile)\n#\n#--- remove the evt2 file\n#\n mcf.rm_file(file)","def calc_annual_electric_savings (self):\n costs = self.comp_specs['diesel generator o&m']\n\n for kW in costs.keys():\n try:\n if self.average_load < int(kW):\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n break\n except ValueError:\n maintenance = self.comp_specs['diesel generator o&m'][kW]\n\n self.baseline_generation_cost = maintenance + \\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\n\n maintenance = self.capital_costs * \\\n (self.comp_specs['percent o&m'] / 100.0)\n self.proposed_generation_cost = maintenance + \\\n self.intertie_offset_generation_fuel_used * \\\n self.intertie_diesel_prices\n self.annual_electric_savings = self.baseline_generation_cost -\\\n self.proposed_generation_cost\n #~ print len(self.annual_electric_savings)\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def _calculate(self):\n source = self.source\n res = {}\n l_cols = [[], [], [], []]\n r_lines = {}\n dateline=None\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\n if source[t.ror].min() > -99.0:\n pass\n else:\n source[t.ror] = np.where(\n source[t.ror] > -99.0, source[t.ror], -99.0)\n ###\n for account in self.accounts:\n source_account = source[source[t.account] == account]\n source_account = source_account.reset_index(drop=True)\n dateline=source_account[t.effective_date]\n ror=source_account[t.ror]/100\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\n # double_return_cum=round(double_return_cum,2)+1\n returns_cum = returns_cum + 1\n growth_amounts = returns_cum * self.starting_value\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\n round(growth_amounts, 2)\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\n 'series': l_cols}\n res['growth_of_unit'] = {'xAxis': list(dateline),\n 'series': r_lines}\n return res\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\n # return ret_dict","def get_a(a_low=1.0e1, a_high=4.41e7, num_sys=1, alpha=-1.6, prob='log_flat'):\n\n if prob == 'log_flat':\n C_a = 1.0 / (np.log(a_high) - np.log(a_low))\n tmp_y = uniform(size=num_sys)\n return a_low*np.exp(tmp_y/C_a)\n\n elif prob == 'raghavan':\n mu_P_orb = 5.03\n sigma_P_orb = 2.28\n # Assume a system mass of 2 Msun\n P_orb_low = np.log10(a_to_P(1.0, 1.0, a_low))\n P_orb_high = np.log10(a_to_P(1.0, 1.0, a_high))\n # Set limits for truncnorm\n a, b = (P_orb_low - mu_P_orb) / sigma_P_orb, (P_orb_high - mu_P_orb) / sigma_P_orb\n P_orb = 10.0**(truncnorm.rvs(a, b, loc=mu_P_orb, scale=sigma_P_orb, size=num_sys))\n return P_to_a(1.0, 1.0, P_orb)\n\n elif prob == 'power_law':\n if alpha == -1:\n return get_a(a_low=a_low, a_high=a_high, num_sys=num_sys, prob='log_flat')\n\n # Scale so 50% of binaries have a > 100 AU\n a_low, a_high = 100.0 * c.AU_to_cm / c.Rsun_to_cm, 4.41e7\n C_a = 0.5 / (a_high**(alpha + 1.0) - a_low**(alpha + 1.0))\n\n a_low = ((4.41e7)**(alpha + 1.0) - 1.0 / C_a) ** (1.0 / (alpha + 1.0))\n tmp_y = uniform(size=num_sys)\n return (tmp_y/C_a + a_low**(alpha + 1.0))**(1.0/(alpha + 1.0))\n\n else:\n print(\"You must provide a valid probability distribution\")\n print(\"Options are 'log_flat', 'raghavan', or 'power_law'\")\n return","def get_ramp(x0,x1,vmax,a,dt, output='ramp only'):\n # Insure we are dealing with floating point numbers\n x0, x1 = float(x0), float(x1)\n vmax, a = float(vmax), float(a)\n dt = float(dt)\n vmax, a = abs(vmax), abs(a) # Make sure that v_max and a are positive\n\n # Check to see if there is anything to do\n if x0==x1:\n return scipy.array([x0])\n\n # Get distance and sign indicating direction\n dist = abs(x1-x0)\n sign = scipy.sign(x1-x0)\n\n # Determine if we will reach v_max\n t2vmax = vmax/a\n t2halfdist = scipy.sqrt(0.5*dist/a)\n \n if t2vmax > t2halfdist:\n # Trajectory w/o constant velocity segment \n T = scipy.sqrt(dist/a)\n n = int(scipy.round_((1.0/dt)*T))\n \n # Adjust accel and duration for rounding of n (discrete time steps)\n a = dist/(n*dt)**2\n T = scipy.sqrt(dist/a)\n \n # Generate trajectory\n t = scipy.linspace(0.0,2.0*T,2*n+1)\n def f1(t):\n return 0.5*sign*a*(t**2)\n def f2(t):\n s = t-T\n return f1(T)+ sign*a*T*s - 0.5*sign*a*s**2\n func_list = [f1,f2]\n cond_list = [t<=T, t>T]\n ramp = x0+scipy.piecewise(t,cond_list,func_list)\n \n else:\n # Trajectory w/ constant velocity segment\n # Compute acceleration time and adjust acceleration\n T1 = vmax/a \n n = int(scipy.round_(T1/dt))\n a = vmax/(n*dt) # Adjusted acceleration \n T1 = vmax/a # Adjusted acceleration time \n\n # Compute and adjust constant velocity time\n T2 = dist/vmax - T1 \n m = int(scipy.round_(T2/dt))\n vmax = dist/(dt*(n+m)) # Adjusted max velocity \n T2 = dist/vmax - T1 # Adjusted constant velocity time\n\n # Generate trajectory\n t = scipy.linspace(0.0,2.0*T1+T2,2*n+m+1)\n def f1(t):\n return 0.5*sign*a*(t**2)\n def f2(t):\n s = t-T1\n return f1(T1) + sign*vmax*s\n def f3(t):\n s = t-T1-T2\n return f2(T1+T2)+sign*vmax*s-0.5*sign*a*s**2 \n func_list = [f1,f2,f3]\n cond_list = [t<=T1, scipy.logical_and(t>T1,t<=T1+T2), t>T1+T2]\n ramp = x0+scipy.piecewise(t,cond_list,func_list)\n\n if output=='ramp only':\n return ramp\n elif output=='full':\n return ramp, vmax, a\n else:\n raise(ValueError, 'unknown keyword option output=%s'%(output,))","def calculatedResults(meanReturns, covMatrix, riskFreeRate=0, constraintSet=(0,1)):\n # Max Sharpe Ratio Portfolio\n maxSR_Portfolio = maxSR(meanReturns, covMatrix)\n maxSR_returns, maxSR_std = portfolioPerformance(maxSR_Portfolio['x'], meanReturns, covMatrix)\n \n maxSR_allocation = pd.DataFrame(maxSR_Portfolio['x'], index=meanReturns.index, columns=['allocation'])\n maxSR_allocation.allocation = [round(i*100,0) for i in maxSR_allocation.allocation]\n \n # Min Volatility Portfolio\n minVol_Portfolio = minimizeVariance(meanReturns, covMatrix)\n minVol_returns, minVol_std = portfolioPerformance(minVol_Portfolio['x'], meanReturns, covMatrix)\n \n minVol_allocation = pd.DataFrame(minVol_Portfolio['x'], index=meanReturns.index, columns=['allocation'])\n minVol_allocation.allocation = [round(i*100,0) for i in minVol_allocation.allocation]\n\n # Efficient Frontier\n efficientList = []\n targetReturns = np.linspace(minVol_returns, maxSR_returns, 20)\n for target in targetReturns:\n efficientList.append(efficientOpt(meanReturns, covMatrix, target)['fun'])\n \n maxSR_returns, maxSR_std = round(maxSR_returns*100,2), round(maxSR_std*100,2)\n minVol_returns, minVol_std = round(minVol_returns*100,2), round(minVol_std*100,2)\n \n return maxSR_returns, maxSR_std, maxSR_allocation, minVol_returns, minVol_std, minVol_allocation, efficientList, targetReturns","def calc_Cinv_boiler(Q_design_W, technology_type, boiler_cost_data):\n Capex_a_Boiler_USD = 0.0\n Opex_a_fix_Boiler_USD = 0.0\n Capex_Boiler_USD = 0.0\n\n if Q_design_W > 0.0:\n boiler_cost_data = boiler_cost_data[boiler_cost_data['code'] == technology_type]\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\n # capacity for the corresponding technology from the database\n if Q_design_W < boiler_cost_data.iloc[0]['cap_min']:\n Q_design_W = boiler_cost_data.iloc[0]['cap_min']\n max_boiler_size = boiler_cost_data.iloc[0]['cap_max']\n\n if Q_design_W <= max_boiler_size:\n\n boiler_cost_data = boiler_cost_data[\n (boiler_cost_data['cap_min'] <= Q_design_W) & (boiler_cost_data['cap_max'] > Q_design_W)]\n\n Inv_a = boiler_cost_data.iloc[0]['a']\n Inv_b = boiler_cost_data.iloc[0]['b']\n Inv_c = boiler_cost_data.iloc[0]['c']\n Inv_d = boiler_cost_data.iloc[0]['d']\n Inv_e = boiler_cost_data.iloc[0]['e']\n Inv_IR = boiler_cost_data.iloc[0]['IR_%']\n Inv_LT = boiler_cost_data.iloc[0]['LT_yr']\n Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0\n\n InvC = Inv_a + Inv_b * (Q_design_W) ** Inv_c + (Inv_d + Inv_e * Q_design_W) * log(Q_design_W)\n\n Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\n Opex_a_fix_Boiler_USD = InvC * Inv_OM\n Capex_Boiler_USD = InvC\n\n else:\n number_of_boilers = int(ceil(Q_design_W / max_boiler_size))\n Q_nom_W = Q_design_W / number_of_boilers\n\n boiler_cost_data = boiler_cost_data[\n (boiler_cost_data['cap_min'] <= Q_nom_W) & (boiler_cost_data['cap_max'] > Q_nom_W)]\n\n Inv_a = boiler_cost_data.iloc[0]['a']\n Inv_b = boiler_cost_data.iloc[0]['b']\n Inv_c = boiler_cost_data.iloc[0]['c']\n Inv_d = boiler_cost_data.iloc[0]['d']\n Inv_e = boiler_cost_data.iloc[0]['e']\n Inv_IR = boiler_cost_data.iloc[0]['IR_%']\n Inv_LT = boiler_cost_data.iloc[0]['LT_yr']\n Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0\n\n InvC = (Inv_a + Inv_b * (Q_nom_W) ** Inv_c + (Inv_d + Inv_e * Q_nom_W) * log(Q_nom_W)) * number_of_boilers\n\n Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\n Opex_a_fix_Boiler_USD = InvC * Inv_OM\n Capex_Boiler_USD = InvC\n\n return Capex_a_Boiler_USD, Opex_a_fix_Boiler_USD, Capex_Boiler_USD","def kA_func(self):\n i1 = self.inl[0].to_flow()\n i2 = self.inl[1].to_flow()\n o1 = self.outl[0].to_flow()\n o2 = self.outl[1].to_flow()\n\n T_i1 = T_mix_ph(i1, T0=self.inl[0].T.val_SI)\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\n\n if T_i1 <= T_o2:\n T_i1 = T_o2 + 0.01\n if T_i1 <= T_o2:\n T_o2 = T_i1 - 0.01\n if T_i1 <= T_o2:\n T_o1 = T_i2 + 0.02\n if T_o1 <= T_i2:\n T_i2 = T_o1 - 0.02\n\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\n\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log","def _compute_from_table_values(\n name=\"plant\", color=(0/255, 128/255, 0/255),\n germination_time=(3, 1), \n r_max=(1.0,1.0),\n maturation_time=(10, 1),\n stopping_color=(0, 0, 1),\n color_step=(10/255, 0, 0),\n c1=0.1,\n r_0=0.04\n ):\n\n c2 = 1\n k1, k2 = 0.3, 0.7\n unoccluded_c1 = c1 / k2\n h_0 = 0.1\n r_max = max(1, np.random.normal(MAX_RADIUS[name][0], MAX_RADIUS[name][1]))\n # r_max = MAX_RADIUS[name][0] + MAX_RADIUS[name][1]\n growth_time = generate_growth_time(germination_time, maturation_time, r_max, r_0, k2, c2)\n\n return {\n \"germination_time\": germination_time,\n \"maturation_time\": maturation_time,\n \"k1\": k1,\n \"k2\": k2,\n \"c1\": unoccluded_c1,\n \"c2\": c2,\n \"start_radius\": r_0,\n \"start_height\": h_0,\n \"r_max\": r_max,\n \"growth_time\": growth_time,\n \"plant_type\": name,\n \"color\": color,\n \"stopping_color\": stopping_color,\n \"color_step\": color_step\n }","def __init__(self, Asset_File, N, K, epsilon=0.01, delta=1.0):\n self.Asset_File = Asset_File\n self.N = N # Total number of assets in a dataset\n self.K = K\n self.epsilon = epsilon # Min investment\n self.delta = delta # Max investment\n self.number_of_stocks = 0\n self.returns_deviations = []\n self.correlations = []\n self.covariance = np.nan\n temp_li_1 = []\n temp_li_2 = []\n\n # Splitting rows based on what they contain\n with open('Datasets/{}'.format(Asset_File), newline='') as datafile:\n for row in datafile:\n if len(row.split()) == 1: # if row is len of 1 it will be number of assets\n for x in row.split(' '):\n if x == '':\n continue\n self.number_of_stocks = (int(x))\n elif len(row.split()) == 2: # if row is len of 2 it will be the assets return and standard deviation\n for x in row.split(' '):\n if x == '':\n continue\n self.returns_deviations.append(float(x))\n elif len(row.split()) == 3: # if row is len of 3 it will be the correlation between assets\n for x in row.split(' '):\n if x == '':\n continue\n self.correlations.append(float(x))\n\n # Variable for storing standard deviations of returns\n for i, z in zip(self.returns_deviations[0::2], self.returns_deviations[1::2]):\n temp_li_1.append([i, z])\n self.returns_deviations = temp_li_1\n\n # Variable for storing correlations between assets\n zeros = np.zeros((int(self.number_of_stocks), int(self.number_of_stocks)))\n for x, y, z in zip(self.correlations[0::3], self.correlations[1::3], self.correlations[2::3]):\n temp_li_2.append([x, y, z])\n zeros[int(x)-1][int(y)-1] = z\n self.correlations = temp_li_2\n\n # Creates a matrix of returns and deviations\n self.returns_deviations = np.array(self.returns_deviations)\n\n # Splitting the data into variables needed for calculation\n self.deviations = self.returns_deviations[:, 1]\n self.mu = self.returns_deviations[:, 0]\n self.covariance = zeros * self.deviations * self.deviations.reshape((self.deviations.shape[0], 1))\n self.sigma = self.covariance + self.covariance.T - np.diag(self.covariance.diagonal()) #Fills in the second part of the covariance matrix\n\n # Making sure constraints on minimum and maximum investments are met\n if K * epsilon > 1.0:\n print(\"Minimum investment is too large\")\n raise ValueError\n if K * delta < 1.0:\n print(\"Maximum investment is too small\")\n raise ValueError\n\n self.F = 1.0 - K * epsilon","def prada(self):\n scale_factor = 1.0 / (1.0 + self.snapshot.header.redshift)\n r200c_physical = self.r200c * scale_factor / 1000.0 # units Mpc\n\n v200 = (\n (self.snapshot.const.G * self.m200c)\n / r200c_physical\n * self.snapshot.const.Mpc ** 2\n / 1000.0 ** 2\n ) ** 0.5 # units km/s\n\n def y(x, vmax, v200):\n func = np.log(1 + x) - (x / (1 + x))\n return ((0.216 * x) / func) ** 0.5 - (vmax / v200)\n\n concentration = np.zeros((len(self.vmax)))\n for halo in range(self.N_halos):\n if v200[halo] > self.vmax[halo]:\n concentration[halo] = -9999.0\n else:\n try:\n concentration[halo] = newton(\n y, x0=5.0, args=(self.vmax[halo], v200[halo])\n )\n except:\n concentration[halo] = -9999.0\n\n return concentration","def alpha(SA, CT, p):\n\n SA = np.maximum(SA, 0)\n\n xs = np.sqrt(sfac * SA + soffset)\n ys = CT * 0.025\n z = p * 1e-4\n\n v_CT_part = (a000\n + xs * (a100 + xs * (a200 + xs * (a300 + xs * (a400 + a500 * xs))))\n + ys * (a010 + xs * (a110 + xs * (a210 + xs * (a310 + a410 * xs)))\n + ys * (a020 + xs * (a120 + xs * (a220 + a320 * xs))\n + ys * (a030 + xs * (a130 + a230 * xs)\n + ys * (a040 + a140 * xs + a050 * ys))))\n + z * (a001 + xs * (a101 + xs * (a201 + xs * (a301 + a401 * xs)))\n + ys * (a011 + xs * (a111 + xs * (a211 + a311 * xs))\n + ys * (a021 + xs * (a121 + a221 * xs)\n + ys * (a031 + a131 * xs + a041 * ys)))\n + z * (a002 + xs * (a102 + xs * (a202 + a302 * xs))\n + ys * (a012 + xs * (a112 + a212 * xs)\n + ys * (a022 + a122 * xs + a032 * ys))\n + z * (a003 + a103 * xs + a013 * ys + a004 * z))))\n\n specific_volume = (v000\n + xs * (v100 + xs * (v200 + xs * (v300 + xs * (v400 + xs * (v500\n + xs * v600)))))\n + ys * (v010\n + xs * (v110 + xs * (v210 + xs * (v310 + xs * (v410 + xs * v510))))\n + ys * (v020 + xs * (v120 + xs * (v220 + xs * (v320 + xs * v420)))\n + ys * (v030 + xs * (v130 + xs * (v230 + xs * v330))\n + ys * (v040 + xs * (v140 + xs * v240)\n + ys * (v050 + xs * v150 + ys * v060)))))\n + z * (v001\n + xs * (v101 + xs * (v201 + xs * (v301 + xs * (v401 + xs * v501))))\n + ys * (v011 + xs * (v111 + xs * (v211 + xs * (v311 + xs * v411)))\n + ys * (v021 + xs * (v121 + xs * (v221 + xs * v321))\n + ys * (v031 + xs * (v131 + xs * v231)\n + ys * (v041 + xs * v141 + ys * v051))))\n + z * (v002\n + xs * (v102 + xs * (v202 + xs * (v302 + xs * v402)))\n + ys * (v012 + xs * (v112 + xs * (v212 + xs * v312))\n + ys * (v022 + xs * (v122 + xs * v222)\n + ys * (v032 + xs * v132 + ys * v042)))\n + z * (v003\n + xs * (v103 + xs * v203)\n + ys * (v013 + xs * v113 + ys * v023)\n + z * (v004 + xs * v104 + ys * v014\n + z * (v005 + z * v006))))))\n\n return 0.025 * v_CT_part / specific_volume","def calAng(self, dates, values, angle_type):\n print(\"Defining points running...\")\n #Determining the type of extrema value to be calculated\n if angle_type == \"max\":\n type_k = \"max_k\"\n elif angle_type == \"min\":\n type_k = \"min_k\"\n else:\n raise NameError('Incorrect type as angle type')\n return\n\n #Initial values\n k, k_dates, k_points = self.calcDir(dates, values)\n\n #While there is a maximum left\n while len(k_points) > 3:\n idx, minima = self.extrema(k, type_k)\n #When the function is done we need the most defining points \n if len(idx) < 3:\n k_points = [dir_points[0], dir_points[-1]]\n k_dates = [dir_dates[0], dir_dates[-1]]\n k, k_d, k_p = self.calcDir(k_dates, k_points)\n break\n dir_dates = [k_dates[i] for i in idx]\n dir_points = [k_points[i] for i in idx]\n k, k_dates, k_points = self.calcDir(dir_dates, dir_points)\n print(\"Defining points done!\")\n return k_dates, k_points, k[0]","def penalty_calc(self):\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\n\n # fiber attenuation,\n self.p_atten = self.alpha*self.length # column B\n\n # calculate bandwidth for RIN test (exclude transmitter)\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\n rin_bw = 1.0 / rin_inverse_bw\n\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\n k_rin = 0.7\n\n # v_rin,\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\n math.pow(10.0,0.1*self.rin)) # column AK\n\n # Prin,\n print('v_rin: ', self.v_rin)\n print('Q: ',self.Q)\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\n print(\"P_rin : \", self.p_rin)\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\n print(\"isi_center : \", self.isi_center)\n\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\n\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\n\n\n # calculate the \"cross\" penalty contribution, column S\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\n self.p_cross_center = ( # column S\n arg3\n - self.p_blw # cell T13\n - self.p_isi_center # column J\n - self.p_isi_dj_center # column L\n - self.p_mpn # column Q\n - self.p_reflection # column N\n - self.p_rin # column R\n - self.pmn*self.l_1) # cell G13\n print('p_isi_center: ', self.p_isi_center)\n\n # calculate the total power budget evaluated at the center of the eye\n self.p_total_center = ( # column T\n self.p_isi_center # column J\n + self.p_isi_dj_center # column L\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1) # cell G13\n # calculate the total power budget evaluated at the corner of the eye\n self.p_total_corners = (\n self.p_isi_center # column J\n + self.p_isi_corners # column K\n + self.p_atten # column B\n + self.p_mpn # column Q\n + self.p_reflection # column N\n + self.p_rin # column R\n + self.p_cross_center # column S\n + self.pmn*self.l_1 # cell G13\n + self.p_isi_dj_corners)# column M\n\n # receiver stressed sensitivity\n self.margin = ( self.p_budget\n - self.p_total_center) # column W\n\n self.rx_stressed_sensitivity = (\n self.tx_oma_min*self.l_1\n - self.chil\n - self.p_mpn\n - self.p_reflection\n - self.p_rin\n - 0.5*self.p_cross_center\n - self.pmn*self.l_1\n - self.margin[self.lnum//2]*self.l_1)\n\n\n # end of GbE10.penalty_calc\n #======================================================================+","def mc_main(self, end_plant_tuple, h2_demand, year=2021, centralised=True, pipeline=True, max_pipeline_dist=2000,\r\n iterations=1000, elec_type='alkaline'):\r\n\r\n df = pd.read_csv(filepath_or_buffer=\"Data/renewables.csv\", index_col=0)\r\n\r\n total_cost_per_kg_h2 = np.zeros((iterations, len(df)))\r\n generation_cost_per_kg = np.zeros((iterations, len(df)))\r\n solar_cost = np.zeros((iterations, len(df)))\r\n wind_cost = np.zeros((iterations, len(df)))\r\n\r\n cost_end_nh3 = np.zeros(iterations)\r\n cost_end_lohc = np.zeros(iterations)\r\n cost_end_h2_liq = np.zeros(iterations)\r\n\r\n # Define parameters for generation costs\r\n year_diff, capex_extra, capex_h2, lifetime_hours, electrolyser_efficiency, elec_opex, other_capex_elec, water_cost, \\\r\n capex_wind, opex_wind, capex_solar, opex_factor_solar = define_gen_parameters(year, iterations, elec_type)\r\n\r\n for i in range(iterations):\r\n df, cost_end_nh3[i], cost_end_lohc[i], cost_end_h2_liq[i] = initial_geo_calcs(df, end_plant_tuple,\r\n centralised=centralised,\r\n pipeline=pipeline,\r\n max_pipeline_dist=max_pipeline_dist)\r\n\r\n for i in range(iterations):\r\n df = mc_generation_costs(df, h2_demand, year_diff, capex_extra[i], capex_h2[i], lifetime_hours,\r\n electrolyser_efficiency[i], elec_opex[i],\r\n other_capex_elec[i], water_cost[i],\r\n capex_wind[i], opex_wind[i], capex_solar[i], opex_factor_solar[i],\r\n interest=0.08, full_load_hours=2000)\r\n\r\n df = mc_transport_costs(df, end_plant_tuple, h2_demand, cost_end_nh3[i], cost_end_lohc[i], cost_end_h2_liq[i],\r\n centralised=centralised, pipeline=pipeline,\r\n max_pipeline_dist=max_pipeline_dist)\r\n\r\n df['Total Yearly Cost'] = df['Yearly gen. cost'] + df['Yearly Transport Cost']\r\n df['Total Cost per kg H2'] = df['Gen. cost per kg H2'] + df['Transport Cost per kg H2']\r\n\r\n total_cost_per_kg_h2[i, :] = df['Total Cost per kg H2'].to_numpy()\r\n generation_cost_per_kg[i, :] = df['Gen. cost per kg H2'].to_numpy()\r\n solar_cost[i, :] = df['Elec Cost Solar'].to_numpy()\r\n wind_cost[i, :] = df['Elec Cost Wind'].to_numpy()\r\n\r\n return df, total_cost_per_kg_h2, generation_cost_per_kg, solar_cost, wind_cost","def E_Dynamic_MavkoEtAl2009(rhob,DTS,PR):\n E = (2*(rhob*1000)*((304800/DTS)**2)*(1+PR))/1000000\n return E","def get_effective_mass():\n\n H_BAR = 6.582119514e-16 # eV*s\n M_0 = 9.10938356e-31 # kg\n N_KPTS = 6 # Number of k-points included in the parabola.\n\n spin_up = Spin(1)\n\n band_structure = Vasprun('vasprun.xml').get_band_structure()\n\n # Locations of CBM and VBM in band_structure.bands\n cbm_band_index = band_structure.get_cbm()['band_index'][spin_up][0]\n cbm_kpoint_index = band_structure.get_cbm()['kpoint_index'][0]\n\n vbm_band_index = band_structure.get_vbm()['band_index'][spin_up][0]\n vbm_kpoint_index = band_structure.get_vbm()['kpoint_index'][0]\n\n k = {'electron': {'left': [], 'right': []},\n 'hole': {'left': [], 'right': []}}\n E = {'electron': {'left': [], 'right': []},\n 'hole': {'left': [], 'right': []}}\n\n e_ref_coords = band_structure.kpoints[cbm_kpoint_index]._ccoords\n h_ref_coords = band_structure.kpoints[vbm_kpoint_index]._ccoords\n\n for n in range(-N_KPTS, 1):\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\n\n k['electron']['left'].append(\n ((e_coords[0] - e_ref_coords[0])**2 +\n (e_coords[1] - e_ref_coords[1])**2 +\n (e_coords[2] - e_ref_coords[2])**2)**0.5\n )\n k['hole']['left'].append(\n ((h_coords[0] - h_ref_coords[0])**2 +\n (h_coords[1] - h_ref_coords[1])**2 +\n (h_coords[2] - h_ref_coords[2])**2)**0.5\n )\n\n e_energy = band_structure.bands[\n spin_up][cbm_band_index][cbm_kpoint_index + n]\n h_energy = band_structure.bands[\n spin_up][vbm_band_index][vbm_kpoint_index + n]\n\n E['electron']['left'].append(e_energy)\n E['hole']['left'].append(h_energy)\n\n for n in range(1, 1 + N_KPTS):\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\n\n k['electron']['right'].append(\n ((e_coords[0] - e_ref_coords[0])**2 +\n (e_coords[1] - e_ref_coords[1])**2 +\n (e_coords[2] - e_ref_coords[2])**2)**0.5\n )\n k['hole']['right'].append(\n ((h_coords[0] - h_ref_coords[0])**2 +\n (h_coords[1] - h_ref_coords[1])**2 +\n (h_coords[2] - h_ref_coords[2])**2)**0.5\n )\n\n e_energy = band_structure.bands[\n spin_up][cbm_band_index][cbm_kpoint_index + n]\n h_energy = band_structure.bands[\n spin_up][vbm_band_index][vbm_kpoint_index + n]\n\n E['electron']['right'].append(e_energy)\n E['hole']['right'].append(h_energy)\n\n # 2nd order fits\n e_l_fit = np.poly1d(\n np.polyfit(k['electron']['left'], E['electron']['left'], 2))\n e_r_fit = np.poly1d(\n np.polyfit(k['electron']['right'], E['electron']['right'], 2))\n h_l_fit = np.poly1d(\n np.polyfit(k['hole']['left'], E['hole']['left'], 2))\n h_r_fit = np.poly1d(\n np.polyfit(k['hole']['right'], E['hole']['right'], 2))\n\n # Curvatures\n e_l_curvature = e_l_fit.deriv().deriv()[0]\n e_r_curvature = e_r_fit.deriv().deriv()[0]\n h_l_curvature = h_l_fit.deriv().deriv()[0]\n h_r_curvature = h_r_fit.deriv().deriv()[0]\n\n # Unit conversion\n e_m_eff_l = 10 * ((H_BAR ** 2) / e_l_curvature) / M_0\n e_m_eff_r = 10 * ((H_BAR ** 2) / e_r_curvature) / M_0\n h_m_eff_l = -10 * ((H_BAR ** 2) / h_l_curvature) / M_0\n h_m_eff_r = -10 * ((H_BAR ** 2) / h_r_curvature) / M_0\n\n return {'electron': {'left': e_m_eff_l, 'right': e_m_eff_r},\n 'hole': {'left': h_m_eff_l, 'right': h_m_eff_r}}","def _get_ancillary_data_for_acquisition(self):\n max_num_acq_opt_evals = self.get_acq_opt_max_evals(self.step_idx)\n return Namespace(max_evals=max_num_acq_opt_evals,\n t=self.step_idx,\n curr_max_val=self.curr_opt_val,\n evals_in_progress=self.eval_points_in_progress)","def bat_res_mod(_parameter, _Pl, _Ppv, _Pbat, _dt, *args):\r\n _E = dict()\r\n\r\n if _parameter['Top'] == 'AC': # AC-coupled systems\r\n\r\n _Ppvs = args[0] # AC output power of the PV system\r\n _Pbs = args[1] # AC power of the battery system\r\n # Additional power consumption of the other system components\r\n _Pperi = args[2]\r\n\r\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\r\n\r\n _Ppv2ac = args[0] # AC output power of the PV2AC conversion pathway\r\n _Ppv2bat_in = args[1] # Input power of the PV2BAT conversion pathway\r\n _Ppvbs = args[2] # AC power of the PV-battery system\r\n # Additional power consumption of the other system components\r\n _Pperi = args[3]\r\n\r\n _Ppv2ac_in = _Ppv - _Ppv2bat_in # Input power of the PV2AC conversion pathway\r\n\r\n # Total load including the power consumption of the other system components\r\n _Plt = _Pl + _Pperi\r\n # DC input power of the battery (charged)\r\n _Pbatin = np.maximum(0, _Pbat)\r\n # DC output power of the battery (discharged)\r\n _Pbatout = np.minimum(0, _Pbat)\r\n # Maximum PV feed-in power\r\n _P_ac2g_max = _parameter['p_ac2g_max'] * _parameter['P_PV'] * 1000\r\n\r\n if _parameter['Top'] == 'AC': # AC-coupled systems\r\n\r\n # Residual power without curtailment\r\n _Pr = _Ppvs - _Plt\r\n # AC input power of the battery system\r\n _Pac2bs = np.maximum(0, _Pbs)\r\n # AC output power of the battery system\r\n _Pbs2ac = np.minimum(0, _Pbs)\r\n # Negative residual power (residual load demand)\r\n _Prn = np.minimum(0, _Pr)\r\n # Positive residual power (surplus PV power)\r\n _Prp = np.maximum(0, _Pr)\r\n # Direct use of PV power by the load\r\n _Ppvs2l = np.minimum(_Ppvs, _Plt)\r\n # PV charging power\r\n _Ppvs2bs = np.minimum(_Prp, _Pac2bs)\r\n # Grid charging power\r\n _Pg2bs = np.maximum(_Pac2bs - _Prp, 0)\r\n # Grid supply power of the load\r\n _Pg2l = np.minimum(_Prn - _Pbs2ac, 0)\r\n # Battery supply power of the load\r\n _Pbs2l = np.maximum(_Prn, _Pbs2ac)\r\n # Battery feed-in power\r\n _Pbs2g = np.minimum(_Pbs2ac - _Prn, 0)\r\n # PV feed-in power including curtailment\r\n _Ppvs2g = np.minimum(np.maximum(_Prp - _Pac2bs, 0), _P_ac2g_max)\r\n # Power demand from the grid\r\n _Pg2ac = _Pg2l - _Pg2bs\r\n # Feed-in power to the grid\r\n _Pac2g = _Ppvs2g - _Pbs2g\r\n # Grid power\r\n _Pg = _Pac2g + _Pg2ac\r\n # Curtailed PV power (AC output power)\r\n _Pct = np.maximum(_Prp - _Pac2bs, 0) - _Ppvs2g\r\n # AC output power of the PV system including curtailment\r\n _Ppvs = _Ppvs - _Pct\r\n # Residual power including curtailment\r\n _Pr = _Ppvs - _Plt\r\n # Index for PV curtailment\r\n _idx = np.where(_Pct > 0)[0]\r\n\r\n for i in range(len(_idx)):\r\n\r\n _tct = _idx[i]\r\n # Normalized output power of the PV inverter\r\n _ppvinvout = _Ppvs[_tct] / _parameter['P_PV2AC_out'] / 1000\r\n # DC output power of the PV generator taking into account the\r\n # conversion and curtailment losses\r\n _Ppv[_tct] = _Ppvs[_tct] + (_parameter['PV2AC_a_out'] * _ppvinvout **\r\n 2 + _parameter['PV2AC_b_out'] * _ppvinvout + _parameter['PV2AC_c_out'])\r\n\r\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\r\n\r\n # Grid power demand of the PV-battery system\r\n _Pg2pvbs = np.minimum(0, _Ppvbs)\r\n # AC input power of the PV-battery system\r\n _Pac2pvbs = _Pg2pvbs\r\n # AC output power of the PV-battery system\r\n _Ppvbs2ac = np.maximum(0, _Ppvbs)\r\n # Load supply power by the PV-battery system\r\n _Ppvbs2l = np.minimum(_Plt, _Ppvbs2ac)\r\n # Load supply power by the grid\r\n _Pg2l = _Plt - _Ppvbs2l\r\n # Direct use of PV power by the load\r\n _Ppv2l = np.minimum(_Plt, _Ppv2ac)\r\n # PV feed-in power including curtailment\r\n _Ppv2g = np.minimum(_Ppv2ac - _Ppv2l, _P_ac2g_max)\r\n # Curtailed PV power (AC output power)\r\n _Pct = _Ppv2ac - _Ppv2l - _Ppv2g\r\n\r\n if np.sum(_Pct) > 0:\r\n # Power of the PV-battery system including curtailment\r\n _Ppvbs = _Ppvbs - _Pct\r\n # AC output power of the PV-battery system including curtailment\r\n _Ppvbs2ac = np.maximum(0, _Ppvbs)\r\n # AC output power of the PV2AC conversion pathway including curtailment\r\n _Ppv2ac = _Ppv2ac - _Pct\r\n # Index for PV curtailment\r\n _idx = np.where(_Pct > 0)[0]\r\n\r\n for i in range(len(_idx)):\r\n\r\n _tct = _idx[i]\r\n # Specific AC output power of the PV2AC conversion pathway\r\n _ppv2ac = _Ppv2ac[_tct] / _parameter['P_PV2AC_out'] / 1000\r\n # DC input power of the PV2AC conversion pathway including curtailment\r\n _Ppv2ac_in[_tct] = _Ppv2ac[_tct] + (_parameter['PV2AC_a_out'] * _ppv2ac **\r\n 2 + _parameter['PV2AC_b_out'] * _ppv2ac + _parameter['PV2AC_c_out'])\r\n\r\n # DC output power of the PV generator including curtailment\r\n _Ppv = _Ppv2ac_in + _Ppv2bat_in\r\n\r\n # Grid power including curtailment\r\n _Pg = _Ppvbs-_Plt\r\n # Feed-in power to the grid including curtailment\r\n _Pac2g = np.maximum(0, _Pg)\r\n # Power demand from the grid\r\n _Pg2ac = np.minimum(0, _Pg)\r\n\r\n # Energy sums in MWH\r\n\r\n # Electrical demand including the energy consumption of the other system components\r\n _E['El'] = np.sum(np.abs(_Plt)) * _dt / 3.6e9\r\n # DC output of the PV generator including curtailment\r\n _E['Epv'] = np.sum(np.abs(_Ppv)) * _dt / 3.6e9\r\n # DC input of the battery (charged)\r\n _E['Ebatin'] = np.sum(np.abs(_Pbatin)) * _dt / 3.6e9\r\n # DC output of the battery (discharged)\r\n _E['Ebatout'] = np.sum(np.abs(_Pbatout)) * _dt / 3.6e9\r\n # Grid feed-in\r\n _E['Eac2g'] = np.sum(np.abs(_Pac2g)) * _dt / 3.6e9\r\n # Grid demand\r\n _E['Eg2ac'] = np.sum(np.abs(_Pg2ac)) * _dt / 3.6e9\r\n # Load supply by the grid\r\n _E['Eg2l'] = np.sum(np.abs(_Pg2l)) * _dt / 3.6e9\r\n # Demand of the other system components\r\n _E['Eperi'] = np.sum(np.abs(_Pperi)) * _dt / 3.6e9\r\n # Curtailed PV energy\r\n _E['Ect'] = np.sum(np.abs(_Pct)) * _dt / 3.6e9\r\n\r\n if _parameter['Top'] == 'AC': # AC-coupled systems\r\n\r\n # AC output of the PV system including curtailment\r\n _E['Epvs'] = np.sum(np.abs(_Ppvs)) * _dt / 3.6e9\r\n # AC input of the battery system\r\n _E['Eac2bs'] = np.sum(np.abs(_Pac2bs)) * _dt / 3.6e9\r\n # AC output of the battery system\r\n _E['Ebs2ac'] = np.sum(np.abs(_Pbs2ac)) * _dt / 3.6e9\r\n # Direct use of PV energy\r\n _E['Epvs2l'] = np.sum(np.abs(_Ppvs2l)) * _dt / 3.6e9\r\n # PV charging\r\n _E['Epvs2bs'] = np.sum(np.abs(_Ppvs2bs)) * _dt / 3.6e9\r\n # Grid charging\r\n _E['Eg2bs'] = np.sum(np.abs(_Pg2bs)) * _dt / 3.6e9\r\n # PV feed-in\r\n _E['Epvs2g'] = np.sum(np.abs(_Ppvs2g)) * _dt / 3.6e9\r\n # Load supply by the battery system\r\n _E['Ebs2l'] = np.sum(np.abs(_Pbs2l)) * _dt / 3.6e9\r\n # Battery feed-in\r\n _E['Ebs2g'] = np.sum(np.abs(_Pbs2g)) * _dt / 3.6e9\r\n\r\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\r\n\r\n # Grid demand of the PV-battery system\r\n _E['Eg2pvbs'] = np.sum(np.abs(_Pg2pvbs)) * _dt / 3.6e9\r\n # AC input of the PV-battery system\r\n _E['Eac2pvbs'] = np.sum(np.abs(_Pac2pvbs)) * _dt / 3.6e9\r\n # AC output of the PV-battery system\r\n _E['Epvbs2ac'] = np.sum(np.abs(_Ppvbs2ac)) * _dt / 3.6e9\r\n # Load supply by the PV-battery system\r\n _E['Epvbs2l'] = np.sum(np.abs(_Ppvbs2l)) * _dt / 3.6e9\r\n\r\n return _E","def objective_function(self, variables, mask, load, generation, annuity_scalar=1):\n size = sum(mask)\n # pay for reg down energy, get paid for reg up energy\n # paid revenue for capacity to do both\n\n p_regu = cvx.Parameter(size, value=self.p_regu.loc[mask].values, name='p_regu')\n p_regd = cvx.Parameter(size, value=self.p_regd.loc[mask].values, name='p_regd')\n p_ene = cvx.Parameter(size, value=self.price.loc[mask].values, name='price')\n\n regup_charge_payment = cvx.sum(variables['regu_c'] * -p_regu) * annuity_scalar\n regup_charge_settlement = cvx.sum(variables['regu_c'] * -p_ene) * self.dt * self.kru_avg * annuity_scalar\n\n regup_disch_payment = cvx.sum(variables['regu_d'] * -p_regu) * annuity_scalar\n regup_disch_settlement = cvx.sum(variables['regu_d'] * -p_ene) * self.dt * self.kru_avg * annuity_scalar\n\n regdown_charge_payment = cvx.sum(variables['regd_c'] * -p_regd) * annuity_scalar\n regdown_charge_settlement = cvx.sum(variables['regd_c'] * p_ene) * self.dt * self.krd_avg * annuity_scalar\n\n regdown_disch_payment = cvx.sum(variables['regd_d'] * -p_regd) * annuity_scalar\n regdown_disch_settlement = cvx.sum(variables['regd_d'] * p_ene) * self.dt * self.krd_avg * annuity_scalar\n\n return {'regup_payment': regup_charge_payment + regup_disch_payment,\n 'regdown_payment': regdown_charge_payment + regdown_disch_payment,\n 'fr_energy_settlement': regup_disch_settlement + regdown_disch_settlement + regup_charge_settlement + regdown_charge_settlement}","def set_c_values(self,nu=3,xd=2,a12sq=1,a13sq=1,a1=0,b1=0,p1=0,\n vx=0,vy=0,vz=0,epsilon=0.,omega=1.5*np.pi,\n a2=np.pi,b2=0*np.pi,p2=0.5*np.pi,silent=False):\n \n c_target = np.zeros(18)\n c_target[0] = nu*self.sigma0_RG \n xd_abs = xd*self.sigma2_RG\n c_target[4:10] = set_fGij(xd_abs,a12sq,a13sq,a1,b1,p1)\n c_target[10:13] = np.array([vx,vy,vz])\n c_target[13:18] = set_VGij(epsilon,omega,a2,b2,p2)\n \n if silent == False:\n print (\"Constrain peak parameters: \")\n if 'f0' in self.CONS or 'full' in self.CONS: \n print (\"f0: \",\"nu = %.1f\"%nu, \"$\\sigma_0$\")\n if 'f1' in self.CONS or 'full' in self.CONS: \n print (\"f1: \",\"f1,x = f1,y = f1,z = 0\")\n if 'f2' in self.CONS or 'full' in self.CONS: \n print (\"f2: \",r\"xd = {:.1f} $\\sigma_2$, a12sq = {:.1f}, a13sq = {:.1f},a1={:.2f}, b1={:.2f}, p1={:.2f}\".format(xd,a12sq,a13sq,a1,b1,p1))\n if 'vx' in self.CONS or 'full' in self.CONS: \n print (\"vx = {:.1f} km/s\".format(vx)) \n if 'vy' in self.CONS or 'full' in self.CONS: \n print (\"vy = {:.1f} km/s\".format(vy))\n if 'vz' in self.CONS or 'full' in self.CONS: \n print (\"vz = {:.1f} km/s\".format(vz))\n if 'TG' in self.CONS or 'full' in self.CONS: \n print (\"TG: \",\"epsilon = {:.1f} km/s/Mpc, omega = {:.2f}, a2={:.2f}, b2={:.2f}, p2={:.2f}\".format(epsilon,omega,a2,b2,p2))\n \n return c_target[self.cmask]","def cAPM_Q_learning(df_train, df_test, MinRPT, MaxRPT_r1, MaxRPT, alpha,\n no_rounds):\n\n # number of periods in samples\n T = df_train.shape[0]\n T_test = df_test.shape[0]\n\n # number of agents\n K = df_test.shape[1]\n\n # individual forecasts\n F = df_train.iloc[:, 1:].values\n F_test = df_test.iloc[:, :].values\n\n # outcomes\n outcomes = df_train.iloc[:, 0].values\n\n # initialize matrices containing all predictionsa and bets\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\n\n # initialize vector containing estimated errors\n est_abs_error = np.full((no_rounds, K), np.nan, dtype=float)\n\n # initialize state identification matrix\n state_mat = np.full((no_rounds, K, 3), False, dtype=bool)\n\n # confidence in the crowd\n delta_mat = np.full((no_rounds, K, 3), 0, dtype=float)\n\n # budget initialization\n budgets = np.full(K, 1, dtype=float)\n start_budgets = np.full((no_rounds, K), 1, dtype=float)\n\n # market prediction vector\n market_pred = np.full(no_rounds, np.nan, dtype=float)\n\n # initialize vectors for storing error cluster means and counts\n # (small, medium, large)\n error_cl_mean = np.full(3, np.nan, dtype=float)\n error_cl_count = np.full(3, 0, dtype=float)\n no_errors = no_rounds*K\n\n # matrix containing the Q value for each action and state\n # dimensions: action, round, agent, state\n Q_val = np.full((2, no_rounds, K, 3), 0, dtype=float)\n\n # matrix containing starting predictions (before action) for Q-updates\n pred_mat_upd = np.full((2, no_rounds, K, 3), 0, dtype=float)\n\n # matrix containing market predictions shifted by one period for Q-updates\n market_pred_upd = np.full((no_rounds, K, 3), 0, dtype=float)\n\n ##############################\n # training the market - START#\n ##############################\n for i in range(T):\n\n # first round betting\n pred_mat[0, :] = F[i, :]\n current_bets = budgets * MaxRPT_r1\n bet_mat[0, :] = current_bets\n budgets -= current_bets\n market_pred[0] = np.dot(\n pred_mat[0, :], bet_mat[0, :]\n )/np.sum(bet_mat[0, :])\n\n # rest of rounds betting\n if i == 0:\n for j in range(1, no_rounds):\n\n pred_mat[j, :] = F[i, :]\n current_bets = budgets * MaxRPT\n bet_mat[j, :] = current_bets\n budgets -= current_bets\n\n else:\n for j in range(1, no_rounds):\n\n # screen shot start of round budgets for Q-val updates later\n np.copyto(start_budgets[j, :], budgets)\n\n # base for current invididual predictions are the last round\n # individual prediction\n np.copyto(pred_mat[j, :], pred_mat[j-1, :])\n\n # error estimates using market prediction of last round\n est_error = market_pred[j-1] - pred_mat[j, :]\n est_abs_error = np.abs(est_error)\n\n # identify in which state the agent is\n cl_dist = np.abs(error_cl_mean[:, np.newaxis] - est_abs_error)\n visited_state = np.swapaxes(np.amin(cl_dist, axis=0) == cl_dist,\n 0, 1)\n state_mat[j, :, :] = visited_state\n\n # choose action: 0-preserve, 1-change prediction\n decision = np.argmax(Q_val[:, j, visited_state], axis=0)\n pred_mat[j, :] += decision * delta_mat[j, visited_state] * est_error\n\n # reestime error after the actions are taken\n est_error = market_pred[j-1] - pred_mat[j, :]\n est_abs_error = np.abs(est_error)\n\n # estimate score\n accuracy_prime = np.maximum(100 * (1 - est_abs_error/oet), 1)\n score_prime = np.log(accuracy_prime)\n\n # bet according to estimated score\n worth_to_bet = score_prime >= 1\n current_bets = (\n worth_to_bet * MaxRPT + ~worth_to_bet * MinRPT\n ) * budgets\n bet_mat[j, :] = current_bets\n budgets -= current_bets\n\n # store the market prediction at the end of the round\n market_pred[j] = np.dot(\n pred_mat[j, :], bet_mat[j, :])/np.sum(bet_mat[j, :])\n\n # absolute errors from the current market\n abs_errors = np.abs(outcomes[i] - pred_mat)\n abs_errors_flat = abs_errors.flatten()\n\n # recompute error clusters (small, medium, large)\n error_order = np.random.choice(no_errors, no_errors, replace=False)\n\n if i == 0:\n # initialize error clusters\n for k in range(3):\n error_cl_mean[k] = abs_errors_flat[error_order[k]]\n error_cl_count[k] += 1\n for k in range(3, no_errors):\n inc_error = abs_errors_flat[error_order[k]]\n closest_cl = (np.abs(error_cl_mean - inc_error)).argmin()\n error_cl_mean[closest_cl] = (error_cl_count[closest_cl] * error_cl_mean[closest_cl] + inc_error) / (error_cl_count[closest_cl] + 1)\n error_cl_count[closest_cl] += 1\n # order: small, medium, large\n error_cl_mean = np.sort(error_cl_mean)\n # in case the cluster means do not differ (very low probability):\n # spread them\n if np.unique(error_cl_mean).size < 3:\n error_cl_mean += np.array([-1e-10, 1e-10, 2e-10])\n\n # initialize delta matrix (confidence in the crowd)\n\n else:\n for k in range(no_errors):\n inc_error = abs_errors_flat[error_order[k]]\n closest_cl = (np.abs(error_cl_mean - inc_error)).argmin()\n error_cl_mean[closest_cl] = (error_cl_count[closest_cl] * error_cl_mean[closest_cl] + inc_error) / (error_cl_count[closest_cl] + 1)\n error_cl_count[closest_cl] += 1\n # in case the cluster means do not differ (very low probability):\n # spread them\n if np.unique(error_cl_mean).size < 3:\n error_cl_mean += np.array([-1e-10, 1e-10, 2e-10])\n\n # use IQR to determine outlier error threshold\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\n IQR = Q3 - Q1\n oet = Q3 + (IQR*1.5)\n\n # compute revenues of the agents based on accuracy of their predictions\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\n score = np.log(accuracy)\n revenue = np.multiply(score, bet_mat)\n\n # reward agents and rescale the budget (for computational reasons)\n budgets = budgets + np.sum(revenue, axis=0)\n budgets = budgets/np.sum(budgets)\n\n # update Q-values and deltas (possible after the first market)\n if i > 0:\n # update Q-values\n pred_mat_upd[:, 1:, :, :] = pred_mat[np.newaxis, :-1, :, np.newaxis]\n market_pred_upd[1:, :, :] = market_pred[:-1, np.newaxis, np.newaxis]\n pred_mat_upd[1, :, :, :] += delta_mat * (market_pred_upd - pred_mat_upd[1, :, :, :])\n abs_errors_upd = np.abs(outcomes[i] - pred_mat_upd)\n accuracy_upd = np.maximum(100 * (1 - abs_errors_upd/oet), 1)\n score_upd = np.log(accuracy_upd)\n worth_to_bet_upd = score_upd >= 1\n bet_mat_upd = np.multiply(\n worth_to_bet_upd * MaxRPT + ~worth_to_bet_upd * MinRPT,\n start_budgets[np.newaxis, :, :, np.newaxis]\n )\n potential_rev = np.multiply(score_upd, bet_mat_upd)\n Q_val += alpha*(potential_rev*state_mat[np.newaxis, :, :, :] - Q_val)\n # update deltas (confidence in the wisdom of the crowd)\n num = outcomes[i]-pred_mat\n denum = market_pred[:, np.newaxis]-pred_mat\n # prevent division by zero\n denum[denum == 0] = 1e-10\n experience = np.clip(num/denum, a_min=0, a_max=1)\n delta_mat += alpha*(experience[:, :, np.newaxis]*state_mat - delta_mat)\n\n ############################\n # training the market - END#\n ############################\n\n # using the market for the out-of-sample predictions\n pred = np.full(T_test, np.nan, dtype=float)\n for i in range(T_test):\n\n # reset to the trained market budget\n budgets_test = np.copy(budgets)\n\n # first round betting\n pred_mat[0, :] = F_test[i, :]\n current_bets = budgets_test * MaxRPT_r1\n bet_mat[0, :] = current_bets\n budgets_test -= current_bets\n market_pred[0] = np.dot(\n pred_mat[0, :], bet_mat[0, :]\n )/np.sum(bet_mat[0, :])\n\n # rest of rounds betting\n for j in range(1, no_rounds):\n\n # base for current invididual predictions are the last round\n # individual prediction\n np.copyto(pred_mat[j, :], pred_mat[j-1, :])\n\n # error estimates using market prediction of last round\n est_error = market_pred[j-1] - pred_mat[j, :]\n est_abs_error = np.abs(est_error)\n\n # identify in which state the agent is\n cl_dist = np.abs(error_cl_mean[:, np.newaxis] - est_abs_error)\n visited_state = np.swapaxes(\n np.amin(cl_dist, axis=0) == cl_dist, 0, 1)\n\n # choose action: 0-preserve, 1-change prediction\n decision = np.argmax(Q_val[:, j, visited_state], axis=0)\n pred_mat[j, :] += decision * delta_mat[j, visited_state]*est_error\n\n # reestime error after the actions are taken\n est_error = market_pred[j-1] - pred_mat[j, :]\n est_abs_error = np.abs(est_error)\n\n # estimate score\n accuracy_prime = np.maximum(100 * (1 - est_abs_error/oet), 1)\n score_prime = np.log(accuracy_prime)\n\n # bet according to estimated score\n worth_to_bet = score_prime >= 1\n current_bets = (\n worth_to_bet * MaxRPT + ~worth_to_bet * MinRPT\n ) * budgets_test\n bet_mat[j, :] = current_bets\n budgets_test -= current_bets\n\n # store the market prediction at the end of the round\n market_pred[j] = np.dot(\n pred_mat[j, :], bet_mat[j, :])/np.sum(bet_mat[j, :])\n\n # final round market prediction is the c-APM prediction\n pred[i] = market_pred[no_rounds-1]\n\n # output\n df_pred = pd.DataFrame(\n {\"c-APM (Q-learning)\": pred},\n index=df_test.index\n )\n\n return df_pred","def testPolicy( \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n self, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n symbol=\"jpm\", \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sd=dt.datetime(2008, 1, 1), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ed=dt.datetime(2009, 12, 31), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sv=10000, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ): \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n dates = pd.date_range(sd,ed)\n df_prices = ind.get_price(symbol, dates)\n\n daily_rets = (df_prices / df_prices.shift(1)) - 1\n daily_rets = daily_rets[1:]\n\n\n sd_older = sd - dt.timedelta(days=365)\n dates_older = pd.date_range(sd_older,ed)\n df_prices_older = ind.get_price(symbol, dates_older)\n sd_key = df_prices.index[0]\n sd_index = df_prices_older.index.get_loc(sd_key)\n\n\n df_holdings = df_prices.copy()\n df_holdings['Holdings'] = np.nan\n del df_holdings[symbol]\n # print(df_holdings)\n\n cum_ret_prev = 0\n iters = 0\n\n\n num_bins = len(self.bins)\n\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\n _,_,ind5 = ind.get_MACD(df_prices_older)\n BB = ind1.iloc[sd_index:].values\n CCI = ind2.iloc[sd_index:].values\n SMA_Cross = ind3.iloc[sd_index:].values\n Momentum = ind4.iloc[sd_index:].values\n MACD = ind5.iloc[sd_index:].values\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\n state = x_0 + x_3*10 + x_4*100\n\n\n\n\n\n self.learner.rar = 0\n\n action = self.learner.querysetstate(state[0])\n\n daily_return = daily_rets.iloc[0][symbol]\n df_holdings.iloc[0]['Holdings'] = 0\n\n\n for day_idx in range(1,daily_rets.shape[0]):\n\n # implement action\n cur_price = df_prices.iloc[day_idx-1][symbol]\n next_price = df_prices.iloc[day_idx][symbol]\n action = self.learner.querysetstate(state[day_idx])\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\n\n\n df_holdings.iloc[-1]['Holdings'] = 0\n df_trades = df_holdings.diff()\n df_trades['Trades'] = df_trades['Holdings']\n del df_trades['Holdings']\n df_trades.iloc[0]['Trades'] = 0\n return df_trades","def _calculate_a_value(self, bval, nvalue, nyr, cmag, ref_mag):\n\n denominator = np.sum(nyr * np.exp(-bval * (cmag - ref_mag)))\n return nvalue / denominator","def choice_C(data, L_plus, delta_min, wdw_length, scale, start=1, stop=10,\n step=1, delay=0, L_minus=None, k=None, n=36000, n_series=500, \n epsilon=0.001, block_length=None, BB_method='MBB', confusion=False, \n verbose=True): \n assert BB_method in ['MBB', 'NBB', 'CBB', 'MABB'], \"Undefined block bootstrap procedure\"\n if BB_method == 'MBB': \n blocks = bb.MBB(data, block_length) \n elif BB_method == 'NBB':\n blocks = bb.NBB(data, block_length) \n elif BB_method == 'CBB':\n blocks = bb.CBB(data, block_length) \n \n if 'blocks' in locals():\n n_blocks = int(np.ceil(n_series/blocks.shape[1]))\n \n wdw_length = int(np.ceil(wdw_length)) #should be integer\n \n delay = int(delay)\n n = int(n)\n assert n > 0, \"n must be strictly positive\"\n if n % 3 == 2: #n should be multiple of 3\n n += 1\n if n % 3 == 1: \n n += 2\n \n if L_minus is None:\n L_minus = -L_plus\n if k is None:\n k = delta_min/2\n \n sign = 1\n n_test = int(n/5) #n testing instances\n n_train = n - n_test #n training instances\n \n n_C = int(np.ceil((stop-start)/step))\n MAPE = np.zeros((n_C)); MSE = np.zeros((n_C)); accuracy = np.zeros((n_C))\n count = 0\n C_values = np.arange(start, stop, step)\n for C in np.arange(start, stop, step):\n \n ### training\n input_train = np.zeros((n_train, wdw_length))\n size_train = np.zeros((n_train))\n form_train = np.zeros((n_train))\n rnd = halfnorm(scale=scale).rvs(size=n_train) + delta_min #size of shifts\n delay_rnd = 0\n for b in range(0, n_train-2, 3):\n \n shift = rnd[b]*sign\n if BB_method == 'MABB': \n series = bb.resample_MatchedBB(data, block_length, n=n_series)\n else:\n series = resample(blocks, replace=True, n_samples=n_blocks).flatten()[:n_series]\n \n #simulate a random delay\n if delay > 0 :\n delay_rnd = np.random.randint(delay) \n\n \n for rnd_form in range(3):\n \n boot = np.copy(series)\n \n if rnd_form == 0: \n boot[wdw_length:] = boot[wdw_length:] + shift\n form_train[b] = 0\n elif rnd_form == 1:\n power = np.random.uniform(1.5,2)\n boot = shift/(n_series) * (np.arange(0,n_series)**power) + boot\n form_train[b] = 1\n else:\n eta = np.random.uniform(np.pi/(wdw_length), 3*np.pi/wdw_length)\n boot = np.sin(eta*np.pi*np.arange(n_series))*shift*boot\n form_train[b] = 2\n \n size_train[b] = shift\n \n input_plus = boot[wdw_length:wdw_length*2]\n C_plus = np.zeros((n_series, 1))\n for i in range(wdw_length + delay_rnd, n_series): #start the monitoring after random delay \n C_plus[i] = max(0, C_plus[i-1] + boot[i] - k)\n if C_plus[i] > L_plus:\n input_plus = boot[i+1-wdw_length:i+1] \n break \n \n input_minus = boot[wdw_length:wdw_length*2]\n C_minus = np.zeros((n_series, 1)) \n for j in range(wdw_length + delay_rnd, n_series):\n C_minus[j] = min(0, C_minus[j-1] + boot[j] + k)\n if C_minus[j] < L_minus:\n input_minus = boot[j+1-wdw_length:j+1] \n break\n \n if i > j: #save first alert recorded\n input_train[b,:] = input_minus\n else:\n input_train[b,:] = input_plus\n \n b += 1\n sign = -sign\n \n ### train the models\n regressor = SVR(C=C, epsilon=epsilon)\n regressor.fit(input_train, size_train)\n clf = svm.SVC(C=C)\n clf.fit(input_train, form_train)\n \n ###testing \n input_test = np.zeros((n_test, wdw_length))\n label_test = np.zeros((n_test))\n form_test = np.zeros((n_test))\n rnd = halfnorm(scale=scale).rvs(size=n_test) + delta_min\n delay_rnd = 0\n for b in range(0, n_test-2, 3):\n \n shift = rnd[b]*sign\n if BB_method == 'MABB': \n series = bb.resample_MatchedBB(data, block_length, n=n_series)\n else:\n series = resample(blocks, replace=True, n_samples=n_blocks).flatten()[:n_series]\n \n #simulate a random delay\n if delay > 0 :\n delay_rnd = np.random.randint(delay) \n \n for rnd_form in range(3):\n \n boot = np.copy(series)\n \n if rnd_form == 0:\n boot[wdw_length:] = boot[wdw_length:] + shift\n form_test[b] = 0\n elif rnd_form == 1:\n power = np.random.uniform(1.5,2)\n boot = shift/(n_series) * (np.arange(0,n_series)**power) + boot\n form_test[b] = 1\n else:\n eta = np.random.uniform(np.pi/(wdw_length), 3*np.pi/wdw_length)\n boot = np.sin(eta*np.pi*np.arange(n_series))*shift*boot\n form_test[b] = 2\n label_test[b] = shift\n \n input_plus = boot[wdw_length:wdw_length*2]\n C_plus = np.zeros((n_series, 1))\n for i in range(wdw_length + delay_rnd, n_series):\n C_plus[i] = max(0, C_plus[i-1] + boot[i] - k)\n if C_plus[i] > L_plus:\n input_plus = boot[i+1-wdw_length:i+1] \n break \n \n input_minus = boot[wdw_length:wdw_length*2]\n C_minus = np.zeros((n_series, 1)) \n for j in range(wdw_length + delay_rnd, n_series):\n C_minus[j] = min(0, C_minus[j-1] + boot[j] + k)\n if C_minus[j] < L_minus:\n input_minus = boot[j+1-wdw_length:j+1]\n break\n \n if i > j: #first alert recorded\n input_test[b,:] = input_minus\n else:\n input_test[b,:] = input_plus\n \n b += 1 \n sign = -sign\n \n ### compute accuracy and other precision measures \n label_pred = regressor.predict(input_test)\n label_pred_clf = clf.predict(input_test)\n \n #regressor\n MAPE[count] = (1/len(label_pred)) * sum(np.abs((np.abs(label_test) - np.abs(label_pred))/np.abs(label_test)))*100\n MSE[count] = (1/len(label_pred)) * sum((label_test - label_pred)**2)\n #classifier\n accuracy[count] = sum(label_pred_clf == form_test)*100 / len(label_pred_clf)\n \n ### compute the confusion matrix \n if confusion : \n class_names = ['jump', 'drift', 'oscill.']\n titles_options = [(\"Confusion matrix, without normalization\", None),\n (\"Normalized confusion matrix\", 'true')]\n for title, normalize in titles_options:\n disp = plot_confusion_matrix(clf, input_test, form_test,\n display_labels=class_names,\n cmap=plt.cm.Blues,\n normalize=normalize)\n disp.ax_.set_title(title)\n print(title)\n print(disp.confusion_matrix)\n plt.show()\n \n count += 1\n \n min_MAPE = C_values[np.argmin(MAPE)]\n min_MSE = C_values[np.argmin(MSE)] \n max_accuracy = C_values[np.argmax(accuracy)]\n \n if verbose:\n print('C value that minimizes the MAPE:', min_MAPE)\n print('C value that minimizes the MSE:', min_MSE)\n print('C value that maximizes the accuracy:', max_accuracy)\n \n return min_MAPE, min_MSE, max_accuracy","def calc_annual_investment(devs, param):\n\n observation_time = param[\"observation_time\"]\n interest_rate = param[\"interest_rate\"]\n q = 1 + param[\"interest_rate\"]\n\n \n # Calculate capital recovery factor\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\n \n # Calculate annuity factor for each device\n for device in devs.keys():\n \n # Get device life time\n life_time = devs[device][\"life_time\"]\n\n # Number of required replacements\n n = int(math.floor(observation_time / life_time))\n \n # Inestment for replcaments\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\n\n # Residual value of final replacement\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\n\n # Calculate annualized investments \n if life_time > observation_time:\n devs[device][\"ann_factor\"] = (1 - res_value) * CRF \n else:\n devs[device][\"ann_factor\"] = ( 1 + invest_replacements - res_value) * CRF \n \n\n return devs","def comp_vel(p1=database['K+'], p2=database['pi+'], p3=database['p+'], pmin=0, pmax=80):\r\n p_range = np.linspace(pmin, pmax, 1000)\r\n m1 = p1.mass\r\n m2 = p2.mass\r\n m3 = p3.mass\r\n v1, v2, v3 = [], [], []\r\n for p in p_range:\r\n v1.append(c*beta(p, m1))\r\n v2.append(c*beta(p, m2))\r\n v3.append(c*beta(p, m3))\r\n fig = plt.figure(figsize=[10, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n p1_name = r'K$^+$'\r\n p2_name = r'$\\pi^+$'\r\n p3_name = r'p$^+$'\r\n ax.plot(p_range, v1, 'r', label=p1_name)\r\n ax.plot(p_range, v2, 'b', label=p2_name)\r\n ax.plot(p_range, v3, 'g', label=p3_name)\r\n ax.set_xlabel('p / GeV', fontsize=20)\r\n ax.set_ylabel(r'v / $ms^{-1}$', fontsize=20)\r\n ax.axvline(75, color='k', label='p = 75 GeV')\r\n ax.set_xticks(np.arange(pmin, pmax+1, 1))\r\n ax.set_xticklabels(np.arange(pmin, pmax+1, 1))\r\n ax.grid()\r\n ax.minorticks_on()\r\n ax.set_xlim(pmin, pmax)\r\n# ax.set_ylim(np.min(v1+v2))\r\n ax.legend(fontsize=20)\r\n plt.show\r\n return","def minimum_remaining_values(csp, ac_3=False):\n assigned = list()\n result = mrv_rec_backtracking(csp, assigned, csp.variables[:]) \n if result is False:\n print \"fuck\"\n return csp, assigned","def p_act(c_range, k_a, k_i, ep_ai=5, n_sites=int(2)):\n if type(n_sites) is not int:\n raise TypeError('n_sites must be an integer.')\n\n numer = (1 + c_range / k_a)**n_sites\n denom = numer + np.exp(-ep_ai) * (1 + c_range / k_i)**n_sites\n return numer / denom","def F_calcNx_C_sC_A_BEC(i, t, dm, Nx_C_sC_A, kgeoxx, kbec, annbec):\n assert (dm.BOSON and dm.BEC and dm.SELFCAPT), \"Error, function F_calcNx_C_sC_A_BEC should not have been called\"\n tuple32 = dm.Capt_v[i], dm.anncs, t.rx, t.time, dm.selfCapt_v[i], Nx_C_sC_A[kgeoxx], kgeoxx, kbec, annbec # extra arguments for function d$\n# print \"tuple32= capt, dm.anncs, t.rx, t.time, selfcapt, Nx_C_sC_A[kgeoxx], kgeoxx, kbec, annbec\"\n# print \"tuple32=\",tuple32\n Nx_C_sC_A_BECtemp = np.array([item[0] for item in odeint(dN32dt,dm.Nxinit,t.time,args=(tuple32))])\n Nx_C_sC_A_BEC = np.zeros(len(t.time))\n for k in xrange(len(t.time)):\n if k<kbec:\n Nx_C_sC_A_BEC[k] = Nx_C_sC_A[k] # before bec is reached\n else:\n Nx_C_sC_A_BEC[k] = Nx_C_sC_A_BECtemp[k] # after bec\n print \" ... Nx_C_sC_A_BEC(t) calculated\"\n return Nx_C_sC_A_BEC","def calc_optimal_mass_flow(q1, q2, q3, q4, E1, E2, E3, E4, m1, m2, m3, m4, dP1, dP2, dP3, dP4, Area_a):\n\n mass_flow_opt = np.empty(8760)\n dP_opt = np.empty(8760)\n const = Area_a / 3600\n mass_flow_all_kgpers = [m1 * const, m2 * const, m3 * const, m4 * const] # [kg/s]\n dP_all_Pa = [dP1 * Area_a, dP2 * Area_a, dP3 * Area_a, dP4 * Area_a] # [Pa]\n balances = [q1 - E1 * 2, q2 - E2 * 2, q3 - E3 * 2, q4 - E4 * 2] # energy generation function eq.(63)\n for time in range(8760):\n balances_time = [balances[0][time], balances[1][time], balances[2][time], balances[3][time]]\n max_heat_production = np.max(balances_time)\n ix_max_heat_production = np.where(balances_time == max_heat_production)\n mass_flow_opt[time] = mass_flow_all_kgpers[ix_max_heat_production[0][0]]\n dP_opt[time] = dP_all_Pa[ix_max_heat_production[0][0]]\n return mass_flow_opt, dP_opt","def get_voltage(self, c):\n if 'slot_number' in c.keys():\n slot_number = c['slot_number'] \n yield self.open_comm(c, slot_number)\n yield self.write(c, 'VOLT?')\n voltage = yield self.read(c)\n yield self.close_comm(c, slot_number)\n \n try:\n voltage = float(voltage)\n except(ValueError):\n old_voltage = voltage\n voltage = ''.join([i for i in voltage if (i.isdigit() or i == '-' or i == '.')])\n voltage = float(voltage)\n print ('The value ' + old_voltage + ' was returned by the SIM928, this value was automatically converted to ' + voltage + '.')\n \n value = voltage * units.V\n \n # try:\n # voltage = yield self.query(c,\n # slot_number, \n # \"VOLT?\")\n # try:\n # voltage = float(voltage)\n # except:\n # self.initialize_mainframe(c)\n # voltage = yield self.query(c,\n # slot_number,\n # \"VOLT?\")\n # voltage = float(voltage)\n # except:\n # self.initialize_mainframe(c)\n # voltage = yield self.query(c,\n # slot_number,\n # \"VOLT?\")\n # try:\n # voltage = float(voltage)\n # except:\n # self.initialize_mainframe(c)\n # voltage = yield self.query(c,\n # slot_number,\n # \"VOLT?\")\n # voltage = float(voltage)\n # try:\n # value = voltage * units.V\n # except:\n # self.initialize_mainframe(c)\n # voltage = yield self.query(c,\n # slot_number,\n # \"VOLT?\")\n # voltage = float(voltage)\n # value = voltage * units.V\n # else:\n # raise ValueError(self.no_selection_msg())\n returnValue(value)","def _annualised_vol(self, asset, lookback):\n series = pd.Series(\n self.buffers.prices[\n VolatilitySignal._asset_lookback_key(\n asset, lookback\n )\n ]\n )\n returns = series.pct_change().dropna().to_numpy()\n\n if len(returns) < 1:\n return 0.0\n else:\n return np.std(returns) * np.sqrt(252)","def calc_output(line, react_cap=None, gen_res_high=225, gen_res_low=50):\n # unpack\n t, v, i = line\n t_diff = t[1] - t[0]\n # assert t_diff == 1e-9 # time scale should be 1ns.\n # values based on current measurment. Assuming voltage waveform is aligned.\n\n # validation on the real maxima/minima of current\n assert i.argmax() < i.argmin(), 'Current valley before peak, signal is inverted!'\n\n v_min = min(v)\n v_max = max(v)\n v_max_time = np.where(v == v_max)[0][0] # first value where voltage has maximum\n # v_min_time = np.where(v == v_min)[0][-1] # last value where voltage has minimum\n # assert v_max_time < v_min_time, 'Voltage valley before peak, signal inverted!'\n c_peak_time = i[0:v_max_time].argmax() # current peak is before voltage maximum\n c_max = i[c_peak_time]\n\n c_valley_time = i.argmin()\n c_min = min(i)\n assert i[c_valley_time] == c_min\n\n # some validation\n assert c_peak_time < c_valley_time, 'Current valley before peak, signal is inverted!'\n assert MAX_VOLTAGE_MIN <= v_max < MAX_VOLTAGE_MAX, 'Max voltage error (%r)' % v_max\n assert MAX_CURRENT_MIN <= c_max < MAX_CURRENT_MAX, 'Max current error (%r)' % c_max\n\n # Find the settling time of the current. Than use the time where the current is stable\n # to calculate the final pulse voltage. This pulse final voltage is then used to calculate\n # the settling time and risetime of the voltage.\n\n # all parts of current inside 10% of maximum, till end of pulse\n i_time_settling_options = [abs(x) < 0.1 * c_max for x in i[0:c_valley_time]]\n ranges = count_ranges(i_time_settling_options)\n range_before, range_pulse = find_longest_ranges(ranges, 2) # [end, length]\n end_pulse = range_pulse[0]\n i_time_settling = range_pulse[0] - range_pulse[1]\n # average of voltage during pulse when current is < 5% of max current\n v_pulse = np.mean(v[i_time_settling:end_pulse])\n # all parts of current inside 10% of maximum, till end of pulse\n v_time_settling_options = [abs(x - v_pulse) < (0.1 * v_pulse) for x in v]\n ranges = count_ranges(v_time_settling_options)\n if ranges == []: # if too much oscillations, a range cannot be found. Increase the bounds:\n # all parts of current inside 10% of maximum, till end of pulse\n v_time_settling_options = [abs(x - v_pulse) < (0.3 * v_pulse) for x in v]\n ranges = count_ranges(v_time_settling_options)\n print('Warning, voltage settling options increased from 10% to 30%!')\n assert ranges != [], \"Error! Line is too unstable.\"\n pulse = find_longest_ranges(ranges, 1) # pulse=[end,length] of voltage pulse stable\n settling_end = pulse[0] - pulse[1] # voltage pulse stable start\n # recalculate pulse voltage\n v_pulse_new = np.mean(v[settling_end:pulse[0]])\n if v_pulse > 13e3: # pulses for highest voltages have to be stable. Lower voltages are always less stable.\n assert abs(v_pulse-v_pulse_new)/v_pulse_new < 0.01, 'Pulse voltage unstable.'\n t_settling_end = t[settling_end] # voltage pulse stable start time\n v05 = 0.05 * v_pulse\n settling_start = np.where(v > v05)[0][0]\n t_settling_start = t[settling_start] # when v first rises above 0.05 of final\n t_settling = t_settling_end - t_settling_start\n v10 = 0.1 * v_pulse\n v90 = 0.9 * v_pulse\n t_rise_start = t[np.where(v > v10)[0][0]]\n t_rise_end = t[np.where(v > v90)[0][0]]\n t_rise = t_rise_end - t_rise_start\n rise_rate = (v90 - v10) / (t_rise)\n v_overshoot = v_max / v_pulse\n pulse_stable = int((settling_end + end_pulse) / 2) # point where the pulse is very stable\n # energy\n p = (v * i) # for this to be correct, make sure lines are aligned in b_correct_lines using offset 'v_div'\n e = integrate.cumtrapz(p, t, initial=0)\n p_rise = p[settling_start:pulse_stable]\n e_rise = e[settling_start:pulse_stable][-1]\n p_res = np.append(i[0:pulse_stable] ** 2 * gen_res_high, i[pulse_stable:] ** 2 * gen_res_low)\n # 1/2*C*V^2 is energy stored in capacitor, which is lost after discharging pulse.\n # e_cap = 1 / 2 * react_cap * v_pulse ** 2\n e_res = integrate.cumtrapz(p_res, t, initial=0)\n e_res_total = e_res[-1]\n e_plasma = e[-1] # energy to plasma is energy in positive pulse except charge on capacitor.\n\n # Correct the time axis to have 0 at the start of the pulse\n start = t[settling_start]\n t = t - start\n\n # all these values are added to the pickle and xlsx with 'output_' prepend in calc_run.py\n data = {\n 't': t,\n 'v': v,\n 'c': i,\n 'c_min': c_min,\n 'c_max': c_max,\n 'v_min': v_min,\n 'v_max': v_max,\n 'v_pulse': v_pulse,\n 't_settling': t_settling,\n 't_rise': t_rise,\n 'rise_rate': rise_rate,\n 'v_overshoot': v_overshoot,\n 'p': p,\n 'e': e,\n 'p_rise': p_rise,\n 'e_rise': e_rise,\n\n 'p_res': p_res,\n 'e_res': e_res,\n 'e_res_total': e_res_total,\n # 'e_cap': e_cap,\n 'e_plasma': e_plasma,\n\n 'start': start,\n 'end': t[end_pulse],\n # 'start_index': settling_start,\n # 'end_index': end_pulse,\n # 'test': i_time_settling\n }\n return data","def call_price(S0, K, r, T, alpha, theta, mu, sigma, lambda_, b, m, a, t, A0=0.5):\n def phi_xt_temp(u): return phi_xt(u, alpha, theta,\n mu, sigma, lambda_, b, m, a, T, A0)\n\n def constant(u): return phi_xt_temp(u - i_) / (phi_xt_temp(-i_) * i_ * u)\n def inside_exp(u): return -i_ * u * np.log((K / S0) * phi_xt_temp(-i_))\n def inte_mu(u): return np.real(constant(u) * np.exp(inside_exp(u)))\n\n C1 = S0 * (0.5 + 1 / np.pi * quad(inte_mu, 0, np.inf)[0])\n def inte_mu2(u): return np.real(phi_xt_temp(u) * np.exp(-i_ *\n u * np.log(K / S0 * phi_xt_temp(-i_))) / (i_ * u))\n\n C2 = K * np.exp(-r * T) * (0.5 + 1 / np.pi * quad(inte_mu2, 0, np.inf)[0])\n\n return C1 - C2","def extract(k):\n global amount, _alarm\n result = 0\n if current_policy != 'double' and k < amount:\n amount = amount - k \n result = k\n \n elif current_policy == 'double' and k < amount and (amount - k > initial_amount * 0.1):\n # print \"IN RESOURCE: k : %f, amount %f, amount - k: %f \" % (k, amount, amount - k)\n amount = amount - k\n result = k \n \n # Set the alarm when the resource reaches 30% of its original value:\n if amount < initial_amount * 0.3:\n _alarm = True\n \n return result","def decay_rate_vs_p(pmax=100, L=102.4, p1=database['K+'],\r\n target_rate=53957518.001, decay_region=65):\r\n p_range = np.linspace(1, 100, 1000)\r\n rate = []\r\n for p in p_range:\r\n rate.append(decay_rate(L, p1, p, target_rate, decay_region)*1e-6)\r\n fig = plt.figure(figsize=[12, 4])\r\n ax = fig.add_subplot(1, 1, 1)\r\n ax.plot(p_range, rate, 'r', lw=2)\r\n ax.set_xlim(0, pmax)\r\n ax.set_ylim(0)\r\n ax.set_xlabel('p / GeV', fontsize=20)\r\n text = f'{p1.name} decays in decay region / MHz'\r\n ax.set_ylabel(text, fontsize=15)\r\n ax.axvline(75, color='k', lw=2, label='current setup')\r\n ax.legend(fontsize=20)\r\n ax.minorticks_on()\r\n ax.grid()\r\n plt.show()\r\n output = 'Maximum decays at p = {0:.1f} GeV --> decay rate = {1:.2f} MHz \\n'.format(p_range[np.argmax(rate)], np.max(rate))\r\n output += 'Current decays at p = 75 GeV --> decay rate = {0:.2f} MHz'.format(decay_rate(p=75)*1e-6)\r\n print(output)\r\n return","def main():\n # Retrieve csv_file name an max_investment from argument passed in console:\n arg_csv_file, arg_max_investment = set_arg()\n if arg_csv_file:\n csv_file = arg_csv_file\n else:\n csv_file = 'dataset1_Python+P7.csv'\n if arg_max_investment:\n max_investment = float(arg_max_investment)\n else:\n max_investment = 500.00\n\n # Retrieve dataset:\n base_dataset = open_convert_and_clean_csv(csv_file)\n\n # Retrieve solution:\n start = time.perf_counter()\n print()\n print(f\"Processing with file '{csv_file}' containing {len(base_dataset)} shares...\")\n print(f\"Maximum investment: {max_investment}€\")\n print(\"Please wait...\")\n computable_dataset = add_roi_to_dataset(convert_dataset_to_cents(base_dataset))\n best_roi, combination = best_combination_dynamic(computable_dataset, max_investment)\n\n # Formatting results:\n combination.sort(key=lambda x: x[2], reverse=True)\n combination_in_euros = convert_dataset_to_euros(combination)\n best_roi /= 100\n # Following calculus is done on cent prices (combination) to avoid approximations with floats\n shares_cost = calculate_shares_cost_sum(combination) / 100\n\n # Printing results:\n print()\n print(f\"Length of dataset: {len(computable_dataset)}\")\n print(f\"Duration of Analysis: {elapsed_time_formatted(start)}\")\n print()\n print(f\"Best Return on investment after 2 years: {round(best_roi, 2)}€\")\n print(f\"Number of shares to buy : {len(combination_in_euros)}\")\n print(f\"Total cost: {round(shares_cost, 2)}€\")\n print()\n print(f\"Best combination of shares ordered by performance: \")\n for share in combination_in_euros:\n print(f\"{share[0]} | Price: {share[1]}€ | profit: {share[2]}%\")\n print()","def _get_penalty_data(self,x):\n\t\n\tfrom PyKEP import epoch, lambert_problem, propagate_lagrangian, fb_prop, DAY2SEC;\n\tfrom math import pi, acos, cos, sin;\n\timport numpy as np;\n\tfrom _mass_penalty import get_rp_ra_Trev\n\t\n\tTrajectory = [];\n\t\n\t#1 - we 'decode' the chromosome recording the various times of flight (days) in the list T for convenience\n\tT = x[3::4]\n\t\n\t# reconstruct properties that are known in _mga_incipit:\n\tself.seq = self.get_sequence();\n\tself.__n_legs = len(self.seq);\n\tself.common_mu = self.seq[0].mu_central_body\n\t\n\t#2 - We compute the epochs and ephemerides of the planetary encounters\n\tt_P = list([None] * (self.__n_legs))\n\tr_P = list([None] * (self.__n_legs))\n\tv_P = list([None] * (self.__n_legs))\n\tDV = list([None] * (self.__n_legs))\n\t\n\tfor i,planet in enumerate(self.seq):\n\t\tt_P[i] = epoch(x[0]+sum(T[:i+1]))\n\t\tr_P[i],v_P[i] = self.seq[i].eph(t_P[i])\n\n\t#3 - We start with the first leg: a lambert arc\n\ttheta = 2*pi*x[1]\n\tphi = acos(2*x[2]-1)-pi/2\n\tr = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection\n\tr = [JR*1000*d for d in r]\n\t\n\tl = lambert_problem(r,r_P[0],T[0]*DAY2SEC,self.common_mu, False, False)\n\n\t#Lambert arc to reach seq[1]\n\tv_end_l = l.get_v2()[0]\n\tv_beg_l = l.get_v1()[0]\n\tTr = [tuple(r), v_beg_l, r_P[0], v_end_l, T[0]*DAY2SEC];\n\trPvec = np.asarray(r_P[0]);\n\tvPvec = np.asarray(v_end_l);\n\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\n\tvinf = vPvec - np.asarray(v_P[0]);\n\tTr = Tr + [vinf];\n\tTrajectory.append(Tr);\n\n\t#First DSM occuring at the very beginning (will be cancelled by the optimizer)\n\tDV[0] = abs(np.linalg.norm(v_beg_l) - 3400)\n\n\t#4 - And we proceed with each successive leg\n\tfor i in xrange(1,self.__n_legs):\n\t\t#Fly-by \n\t\tv_out = fb_prop(v_end_l,v_P[i-1],x[1+4*i]*self.seq[i-1].radius,x[4*i],self.seq[i-1].mu_self)\n\t\t#s/c propagation before the DSM\n\t\tr,v = propagate_lagrangian(r_P[i-1],v_out,x[4*i+2]*T[i]*DAY2SEC,self.common_mu)\n\t\t# append r, v, etc. to the Trajectory:\n\t\tTr = [r_P[i-1], v_out, r, v, x[4*i+2]*T[i]*DAY2SEC];\n\t\trPvec = np.asarray(r);\n\t\tvPvec = np.asarray(v);\n\t\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\n\t\tvinf = [];\n\t\tTr = Tr + [vinf];\n\t\tTrajectory.append(Tr);\n\t\t\n\t\t#Lambert arc to reach Earth during (1-nu2)*T2 (second segment)\n\t\tdt = (1-x[4*i+2])*T[i]*DAY2SEC\n\t\tl = lambert_problem(r,r_P[i],dt,self.common_mu, False, False)\n\t\tv_end_l = l.get_v2()[0]\n\t\tv_beg_l = l.get_v1()[0]\n\t\t# append r, v, etc. to the Trajectory:\n\t\tTr = [r, v_beg_l, r_P[i], v_end_l, (1-x[4*i+2])*T[i]*DAY2SEC];\n\t\trPvec = np.asarray(r_P[i]);\n\t\tvPvec = np.asarray(v_end_l);\n\t\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\n\t\tvinf = vPvec - np.asarray(v_P[i]);\n\t\tTr = Tr + [vinf];\n\t\tTrajectory.append(Tr);\n\t\t\n\t\t\n\t\t#DSM occuring at time nu2*T2\n\t\tDV[i] = np.linalg.norm([a-b for a,b in zip(v_beg_l,v)])\n\treturn Trajectory;","def generate_demand_ivt():\n r = np.random.rand()\n \n # check the first cdf entry (index 0) \n if r <= cdf[0]:\n return demands[0]\n # check the second cdf entry (index 1)\n elif r <= cdf[1]:\n return demands[1]\n # check the third cdf entry (index 2)\n elif r <= cdf[2]:\n return demands[2]\n # otherwise no need to check, it's the final CDF entry (index 3)\n else:\n return demands[3]\n \n \"\"\"\n note: the code above could be replaced with the following for \n loop which iterates over each array index i in demands\n \n for i in range(len(demands)):\n if r <= cdf[i]:\n return demands[i]\n \"\"\"","def get_decided_outlet_supply_air_absolute_humidity_for_cooling(\n x_req_c: np.ndarray, v_supply: np.ndarray, x_hs_out_min_c: np.ndarray) -> np.ndarray:\n\n return np.maximum(np.sum(x_req_c * v_supply / v_supply.sum(axis=0), axis=0), x_hs_out_min_c)","def get_default_rated_capacity(region: int, a_a: float) -> (float, float):\n\n # corrected value for effects of the external temperature to the capacity\n f_ct = 1.05\n\n # corrected value for effects of the intermittent operation to the capacity\n f_cl = 1.0\n\n if region == 8:\n q_rtd_h = None\n else:\n q_rq_h = {\n 1: 73.91,\n 2: 64.32,\n 3: 62.65,\n 4: 66.99,\n 5: 72.64,\n 6: 61.34,\n 7: 64.55,\n }[region]\n q_rtd_h = q_rq_h * a_a * f_ct * f_cl\n\n q_rq_c = {\n 1: 37.61,\n 2: 36.55,\n 3: 42.34,\n 4: 54.08,\n 5: 61.69,\n 6: 60.79,\n 7: 72.53,\n 8: 61.56,\n }[region]\n\n q_rtd_c = q_rq_c * a_a * f_ct * f_cl\n\n return q_rtd_h, q_rtd_c","def calc_annual_electric_savings (self):\n price = self.diesel_prices\n #TODO add rural v non rural\n self.base_generation_cost = self.electric_diesel_reduction * price\n\n\n self.proposed_generation_cost = self.maintenance_cost\n\n self.annual_electric_savings = self.base_generation_cost - \\\n self.proposed_generation_cost\n #~ print 'self.annual_electric_savings',self.annual_electric_savings","def calculate(self, catalogue, config, completeness=None):\n # Input checks\n cmag, ctime, ref_mag, dmag, config = input_checks(catalogue,\n config,\n completeness)\n ival = 0\n tolerance = 1E-7\n number_intervals = np.shape(ctime)[0]\n b_est = np.zeros(number_intervals, dtype=float)\n neq = np.zeros(number_intervals, dtype=float)\n nyr = np.zeros(number_intervals, dtype=float)\n\n for ival in range(0, number_intervals):\n id0 = np.abs(ctime - ctime[ival]) < tolerance\n m_c = np.min(cmag[id0])\n if ival == 0:\n id1 = np.logical_and(\n catalogue.data['year'] >= (ctime[ival] - tolerance),\n catalogue.data['magnitude'] >= (m_c - tolerance))\n nyr[ival] = float(catalogue.end_year) - ctime[ival] + 1.\n elif ival == number_intervals - 1:\n id1 = np.logical_and(\n catalogue.data['year'] < (ctime[ival - 1] - tolerance),\n catalogue.data['magnitude'] >= (m_c - tolerance))\n nyr[ival] = ctime[ival - 1] - ctime[ival]\n else:\n id1 = np.logical_and(\n catalogue.data['year'] >= (ctime[ival] - tolerance),\n catalogue.data['year'] < (ctime[ival - 1] - tolerance))\n id1 = np.logical_and(\n id1, catalogue.data['magnitude'] > (m_c - tolerance))\n nyr[ival] = ctime[ival - 1] - ctime[ival]\n neq[ival] = np.sum(id1)\n # Get a- and b- value for the selected events\n temp_rec_table = recurrence_table(catalogue.data['magnitude'][id1],\n dmag,\n catalogue.data['year'][id1])\n\n aki_ml = AkiMaxLikelihood()\n b_est[ival] = aki_ml._aki_ml(temp_rec_table[:, 0],\n temp_rec_table[:, 1],\n dmag, m_c)[0]\n ival += 1\n total_neq = np.float(np.sum(neq))\n bval = self._harmonic_mean(b_est, neq)\n sigma_b = bval / np.sqrt(total_neq)\n aval = self._calculate_a_value(bval, total_neq, nyr, cmag, ref_mag)\n sigma_a = self._calculate_a_value(bval + sigma_b, total_neq, nyr,\n cmag, ref_mag)\n\n if not config['reference_magnitude']:\n aval = np.log10(aval)\n sigma_a = np.log10(sigma_a) - aval\n else:\n sigma_a = sigma_a - aval\n return bval, sigma_b, aval, sigma_a","def curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff):\n\t# price dependent\n\tpdm = curPrice - priceMin\n\tpdp = curPrice - prevPrice\n\tq = demandIntcpt + k1 * pdm + k2 * pdm * pdm - a * shock(plus(pdp)) + b * shock(minus(pdp)) \n\t\n\t# cyclic \n\tq += demCycAmp * math.sin(2.0 * math.pi * coff / demCycPer)\n\t\n\t# random\n\tq += np.random.normal(0, randDemSd)\n\t\n\tq = plus(q)\n\treturn q","def calc_SC_module(tilt_angle_deg, IAM_b_vector, IAM_d_vector, I_direct_vector, I_diffuse_vector, Tamb_vector_C, n0, c1, c2,\n mB0_r, mB_max_r, mB_min_r, C_eff_Jperm2K, t_max, aperture_area_m2, dP1, dP2, dP3, dP4, Cp_fluid_JperkgK, Tin_C, Leq, l_ext, l_int, Nseg):\n\n # local variables\n msc_max_kgpers = mB_max_r * aperture_area_m2 / 3600 # maximum mass flow [kg/s]\n\n # Do the calculation of every time step for every possible flow condition\n # get states where highly performing values are obtained.\n specific_flows_kgpers = [np.zeros(8760), (np.zeros(8760) + mB0_r) * aperture_area_m2 / 3600,\n (np.zeros(8760) + mB_max_r) * aperture_area_m2 / 3600,\n (np.zeros(8760) + mB_min_r) * aperture_area_m2 / 3600, np.zeros(8760), np.zeros(8760)] # in kg/s\n specific_pressure_losses_Pa = [np.zeros(8760), (np.zeros(8760) + dP2) * aperture_area_m2, (np.zeros(8760) + dP3) * aperture_area_m2,\n (np.zeros(8760) + dP4) * aperture_area_m2, np.zeros(8760), np.zeros(8760)] # in Pa\n\n # generate empty lists to store results\n temperature_out = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n temperature_in = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n temperature_mean = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n supply_out_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n supply_losses_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n auxiliary_electricity_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\n supply_out_pre = np.zeros(8760)\n supply_out_total_kW = np.zeros(8760)\n mcp_kWperK = np.zeros(8760)\n\n # calculate absorbed radiation\n tilt = radians(tilt_angle_deg)\n q_rad_vector = np.vectorize(calc_q_rad)(n0, IAM_b_vector, I_direct_vector, IAM_d_vector, I_diffuse_vector,\n tilt) # absorbed solar radiation in W/m2 is a mean of the group\n for flow in range(6):\n mode_seg = 1 # mode of segmented heat loss calculation. only one mode is implemented.\n TIME0 = 0\n DELT = 1 # timestep 1 hour\n delts = DELT * 3600 # convert time step in seconds\n Tfl = np.zeros([3, 1]) # create vector to store value at previous [1] and present [2] time-steps\n DT = np.zeros([3, 1])\n Tabs = np.zeros([3, 1])\n STORED = np.zeros([600, 1])\n TflA = np.zeros([600, 1])\n TflB = np.zeros([600, 1])\n TabsB = np.zeros([600, 1])\n TabsA = np.zeros([600, 1])\n q_gain_Seg = np.zeros([101, 1]) # maximum Iseg = maximum Nseg + 1 = 101\n\n for time in range(8760):\n Mfl_kgpers = specific_flows_kgpers[flow][time] # [kg/s]\n if time < TIME0 + DELT / 2:\n # set output values to the appropriate initial values\n for Iseg in range(101, 501): # 400 points with the data\n STORED[Iseg] = Tin_C\n else:\n # write average temperature of all segments at the end of previous time-step\n # as the initial temperature of the present time-step\n for Iseg in range(1, Nseg + 1): # 400 points with the data\n STORED[100 + Iseg] = STORED[200 + Iseg] # thermal capacitance node temperature\n STORED[300 + Iseg] = STORED[400 + Iseg] # absorber node temperature\n\n # calculate stability criteria\n if Mfl_kgpers > 0:\n stability_criteria = Mfl_kgpers * Cp_fluid_JperkgK * Nseg * (DELT * 3600) / (C_eff_Jperm2K * aperture_area_m2)\n if stability_criteria <= 0.5:\n print ('ERROR: stability criteria' + str(stability_criteria) + 'is not reached. aperture_area: '\n + str(aperture_area_m2) + 'mass flow: ' + str(Mfl_kgpers))\n\n # calculate average fluid temperature and average absorber temperature at the beginning of the time-step\n Tamb_C = Tamb_vector_C[time]\n q_rad_Wperm2 = q_rad_vector[time]\n Tfl[1] = 0\n Tabs[1] = 0\n for Iseg in range(1, Nseg + 1):\n Tfl[1] = Tfl[1] + STORED[100 + Iseg] / Nseg # mean fluid temperature\n Tabs[1] = Tabs[1] + STORED[300 + Iseg] / Nseg # mean absorber temperature\n\n ## first guess for Delta T\n if Mfl_kgpers > 0:\n Tout_C = Tin_C + (q_rad_Wperm2 - (c1 + 0.5) * (Tin_C - Tamb_C)) / (Mfl_kgpers * Cp_fluid_JperkgK / aperture_area_m2)\n Tfl[2] = (Tin_C + Tout_C) / 2 # mean fluid temperature at present time-step\n else:\n Tout_C = Tamb_C + q_rad_Wperm2 / (c1 + 0.5)\n Tfl[2] = Tout_C # fluid temperature same as output\n DT[1] = Tfl[2] - Tamb_C # difference between mean absorber temperature and the ambient temperature\n\n # calculate q_gain with the guess for DT[1]\n q_gain_Wperm2 = calc_q_gain(Tfl, Tabs, q_rad_Wperm2, DT, Tin_C, Tout_C, aperture_area_m2, c1, c2, Mfl_kgpers,\n delts, Cp_fluid_JperkgK, C_eff_Jperm2K, Tamb_C)\n\n A_seg_m2 = aperture_area_m2 / Nseg # aperture area per segment\n # multi-segment calculation to avoid temperature jump at times of flow rate changes.\n for Iseg in range(1, Nseg + 1):\n # get temperatures of the previous time-step\n TflA[Iseg] = STORED[100 + Iseg]\n TabsA[Iseg] = STORED[300 + Iseg]\n if Iseg > 1:\n Tin_Seg_C = Tout_Seg_C\n else:\n Tin_Seg_C = Tin_C\n\n if Mfl_kgpers > 0 and mode_seg == 1: # same heat gain/ losses for all segments\n Tout_Seg_K = ((Mfl_kgpers * Cp_fluid_JperkgK * (Tin_Seg_C + 273.15)) / A_seg_m2 -\n (C_eff_Jperm2K * (Tin_Seg_C + 273.15)) / (2 * delts) + q_gain_Wperm2 +\n (C_eff_Jperm2K * (TflA[Iseg] + 273.15) / delts)) / (Mfl_kgpers * Cp_fluid_JperkgK / A_seg_m2 + C_eff_Jperm2K / (2 * delts))\n Tout_Seg_C = Tout_Seg_K - 273.15 # in [C]\n TflB[Iseg] = (Tin_Seg_C + Tout_Seg_C) / 2\n else: # heat losses based on each segment's inlet and outlet temperatures.\n Tfl[1] = TflA[Iseg]\n Tabs[1] = TabsA[Iseg]\n q_gain_Wperm2 = calc_q_gain(Tfl, Tabs, q_rad_Wperm2, DT, Tin_Seg_C, Tout_C, A_seg_m2, c1, c2,\n Mfl_kgpers, delts, Cp_fluid_JperkgK, C_eff_Jperm2K, Tamb_C)\n Tout_Seg_C = Tout_C\n\n if Mfl_kgpers > 0:\n TflB[Iseg] = (Tin_Seg_C + Tout_Seg_C) / 2\n Tout_Seg_C = TflA[Iseg] + (q_gain_Wperm2 * delts) / C_eff_Jperm2K\n else:\n TflB[Iseg] = Tout_Seg_C\n\n #TflB[Iseg] = Tout_Seg\n q_fluid_Wperm2 = (Tout_Seg_C - Tin_Seg_C) * Mfl_kgpers * Cp_fluid_JperkgK / A_seg_m2\n q_mtherm_Whperm2 = (TflB[Iseg] - TflA[Iseg]) * C_eff_Jperm2K / delts # total heat change rate of thermal capacitance\n q_balance_error = q_gain_Wperm2 - q_fluid_Wperm2 - q_mtherm_Whperm2\n if abs(q_balance_error) > 1:\n time = time # re-enter the iteration when energy balance not satisfied\n q_gain_Seg[Iseg] = q_gain_Wperm2 # in W/m2\n\n # resulting net energy output\n q_out_kW = (Mfl_kgpers * Cp_fluid_JperkgK * (Tout_Seg_C - Tin_C)) / 1000 #[kW]\n Tabs[2] = 0\n # storage of the mean temperature\n for Iseg in range(1, Nseg + 1):\n STORED[200 + Iseg] = TflB[Iseg]\n STORED[400 + Iseg] = TabsB[Iseg]\n Tabs[2] = Tabs[2] + TabsB[Iseg] / Nseg\n\n # outputs\n temperature_out[flow][time] = Tout_Seg_C\n temperature_in[flow][time] = Tin_C\n supply_out_kW[flow][time] = q_out_kW\n temperature_mean[flow][time] = (Tin_C + Tout_Seg_C) / 2 # Mean absorber temperature at present\n\n # q_gain = 0\n # TavgB = 0\n # TavgA = 0\n # for Iseg in range(1, Nseg + 1):\n # q_gain = q_gain + q_gain_Seg[Iseg] * A_seg_m2 # [W]\n # TavgA = TavgA + TflA[Iseg] / Nseg\n # TavgB = TavgB + TflB[Iseg] / Nseg\n #\n # # OUT[9] = q_gain/Area_a # in W/m2\n # q_mtherm = (TavgB - TavgA) * C_eff * aperture_area / delts\n # q_balance_error = q_gain - q_mtherm - q_out\n\n # OUT[11] = q_mtherm\n # OUT[12] = q_balance_error\n if flow < 4:\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\n Leq, l_int, aperture_area_m2) # in kW\n if flow == 3:\n q1 = supply_out_kW[0]\n q2 = supply_out_kW[1]\n q3 = supply_out_kW[2]\n q4 = supply_out_kW[3]\n E1 = auxiliary_electricity_kW[0]\n E2 = auxiliary_electricity_kW[1]\n E3 = auxiliary_electricity_kW[2]\n E4 = auxiliary_electricity_kW[3]\n # calculate optimal mass flow and the corresponding pressure loss\n specific_flows_kgpers[4], specific_pressure_losses_Pa[4] = calc_optimal_mass_flow(q1, q2, q3, q4, E1, E2, E3, E4, 0,\n mB0_r, mB_max_r, mB_min_r, 0,\n dP2, dP3, dP4, aperture_area_m2)\n if flow == 4:\n # calculate pumping electricity when operatres at optimal mass flow\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\n Leq, l_int, aperture_area_m2) # in kW\n dp5 = specific_pressure_losses_Pa[flow]\n q5 = supply_out_kW[flow]\n m5 = specific_flows_kgpers[flow]\n # set points to zero when load is negative\n specific_flows_kgpers[5], specific_pressure_losses_Pa[5] = calc_optimal_mass_flow_2(m5, q5, dp5)\n\n if flow == 5: # optimal mass flow\n supply_losses_kW[flow] = np.vectorize(calc_qloss_network)(specific_flows_kgpers[flow], l_ext, aperture_area_m2,\n temperature_mean[flow], Tamb_vector_C, msc_max_kgpers)\n supply_out_pre = supply_out_kW[flow].copy() + supply_losses_kW[flow].copy()\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\n Leq, l_int, aperture_area_m2) # in kW\n supply_out_total_kW = supply_out_kW[flow].copy() + 0.5 * auxiliary_electricity_kW[flow].copy() - supply_losses_kW[flow].copy() # eq.(58) _[J. Fonseca et al., 2016]\n mcp_kWperK = specific_flows_kgpers[flow] * (Cp_fluid_JperkgK / 1000) # mcp in kW/K\n\n result = [supply_losses_kW[5], supply_out_total_kW, auxiliary_electricity_kW[5], temperature_out[5], temperature_in[5], mcp_kWperK]\n q_rad_per_panel = q_rad_vector*aperture_area_m2\n return result","def M_D_1(arrival_time,max_time,service_time=1/90):\n #conversion in seconds\n max_seconds = max_time*60*60\n sim_time = 0.0 # simulation time\n t_1 = 0.0 # time for next event (arrival)\n t_2 = max_seconds # time for next event (departure)\n t_n = 0.0 #last event time--> tempo dell'ultimo avvenimento generico\n t_b = 0.0 # last start of busy time--> tempo in cui la queue inizia ad essere non vuota per l'ultima volta\n c = 0 # numero di servizi completati\n queue_aircraft = [] # number of aircraft in the queue\n aircraft = 0\n arrival = [] # time of arrival\n attesa = [] # attesa per gli aerei-->NON SICURO CHE SI CALCOLI COSI'\n # simulation loop\n while(sim_time < max_seconds):\n if(t_1<t_2): #event1:arrival\n sim_time = t_1\n arrival.append(t_1)\n aircraft += 1\n queue_aircraft.append(aircraft)\n t_n = sim_time\n t_1 = sim_time + rm.expovariate(arrival_time)\n if(aircraft==1):\n t_b = sim_time\n t_2 = sim_time + 1/service_time\n else:\n sim_time = t_2\n aircraft = aircraft -1\n queue_aircraft.append(aircraft)\n t_n = sim_time\n attesa.append( t_2 - arrival[c])\n c+=1\n if(aircraft>0):\n t_2=sim_time + 1/service_time\n else:\n t_2 = max_seconds\n\n\n\n\n return queue_aircraft,arrival,attesa","def qssa(k11=5e-8, k=3.3e-10, k10=1e-6, mn=30):\n density = 1.42 * 1000 # the density of Delrin NC100, [g/dm3]\n cs = density / mn # reactant groups concentration, [mol/L]\n mass_loss = np.zeros_like(t)\n rs = np.zeros_like(t)\n acid_cons = np.array(c_water)\n for i in range(steps-1):\n # assume the reaction only happen with pH < 3 situation\n if ph[i] < 4:\n rs[i] = ((k10 * cs + k11) / (k11 + k + k10 * cs) - 1) * k10 * cs * acid_cons[i]\n acid_cons[i + 1] = acid_cons[i] - abs(rs[i] * t_step) + S_drop * abs(N1) / V_drop * t_step\n mass_loss[i+1] = mass_loss[i] + abs(rs[i] * t_step * mn)\n else:\n continue\n volume_loss = mass_loss /density\n pH_C = -np.log10(acid_cons) # the pH value with reaction consumption\n depth = volume_loss / S_rand # the penetration depth for single droplet, [dm]\n if t.shape[0] > 300000:\n # assume the HCl gas supplying will maintain until the pH is -1.\n try:\n place = np.where(acid_cons > 10)\n loc = int(place[0][0])\n except IndexError:\n loc = steps\n acid_cons[loc:] = acid_cons[loc-1]\n mass_loss[loc:] = mass_loss[loc-1]\n for i in range(loc-1, t.shape[0]-1):\n rs[i] = ((k10 * cs + k11) / (k11 + k + k10 * cs) - 1) * k10 * cs * acid_cons[i]\n acid_cons[i + 1] = acid_cons[i] - abs(rs[i] * t_step) # + S_drop * abs(N1) / V_drop * t_step\n mass_loss[i + 1] = mass_loss[i] + abs(rs[i] * t_step * mn)\n volume_loss = mass_loss / density\n pH_C = - np.log10(acid_cons) # the pH value with reaction consumption\n depth = volume_loss / S_rand # the penetration depth for single droplet\n rs[t.shape[0]-1] = rs[t.shape[0]-2]\n rs = abs(rs)\n return mass_loss, volume_loss, acid_cons, pH_C, depth, rs","def next_point(self):\n if self.verbose:\n print(\"Computing acquisition function...\")\n if self.acquisition_function == 'cb':\n acq, pred = acqfunc.confidence_bound(\n self.surrogate_model, self.X_full,\n alpha=self.alpha, beta=self.beta)\n elif self.acquisition_function == 'ei':\n acq, pred = acqfunc.expected_improvement(\n self.surrogate_model, self.X_full,\n self.X_sparse, xi=self.xi)\n elif self.acquisition_function == 'poi':\n acq, pred = acqfunc.probability_of_improvement(\n self.surrogate_model, self.X_full,\n self.X_sparse, xi=self.xi)\n elif isinstance(self.acquisition_function, types.FunctionType):\n acq, pred = self.acquisition_function(\n self.surrogate_model, self.X_full, self.X_sparse)\n else:\n raise NotImplementedError(\n \"Choose between 'cb', 'ei', and 'poi' acquisition functions or define your own\")\n self.gp_predictions.append(pred)\n if self.mask is None:\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\n vals_list = acq[indices_list][::-1][:self.batch_size].tolist()\n indices_list = np.dstack(indices_list)[0][::-1][:self.batch_size].tolist()\n else:\n acq = self.mask*acq\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\n vals_list = acq[indices_list]\n vals_list = vals_list[~np.isnan(vals_list)][::-1]\n indices_list = np.dstack(indices_list)[0]\n indices_list = indices_list[:len(vals_list)][::-1]\n vals_list = vals_list[:self.batch_size].tolist()\n indices_list = indices_list[:self.batch_size].tolist()\n if not self.batch_update:\n return vals_list, indices_list\n if self.batch_dscale is None:\n batch_dscale_ = self.surrogate_model.model.kernel.lengthscale.mean().item()\n else:\n batch_dscale_ = self.batch_dscale\n vals_list, indices_list = self.update_points(\n vals_list, indices_list, batch_dscale_)\n return vals_list, indices_list","def choose_prime_inst(given_start_date,given_end_date):\r\n\r\n #extracting primary dates where instruments are active from csv file\r\n inst_prime_dates = pd.read_csv(ref_path / 'GOES_primary_assignments.csv', header=3)\r\n\r\n #figuring out which instrument is primary for given start date\r\n for d in range(len(inst_prime_dates['Start Date'])):\r\n change_date = parse(inst_prime_dates['Start Date'][d])\r\n if given_start_date >= change_date.date():\r\n prime_inst = inst_prime_dates['EPEAD Primary'][d]\r\n backup_inst = inst_prime_dates['EPEAD Secondary'][d]\r\n end_date = parse(inst_prime_dates['Start Date'][d+1]).date()\r\n\r\n #if no prime instrument available, have to choose which instrument\r\n #to use based on which instruments have data for this date\r\n if str(prime_inst) == 'nan':\r\n if str(backup_inst) == 'nan':\r\n print('no information about primary instrument available.'\r\n 'Choosing instrument based on active date ranges')\r\n alternate_output = choose_inst(given_start_date,given_end_date)\r\n\r\n return(alternate_output)\r\n else:\r\n prime_inst = backup_inst\r\n\r\n break\r\n\r\n prime_inst = str(prime_inst).split('.')[0]\r\n\r\n #reformatting instrument name\r\n if len(prime_inst) == 2:\r\n inst_str = str(prime_inst)\r\n elif len(prime_inst) == 1:\r\n inst_str = '0' + str(prime_inst)\r\n\r\n print('GOES-%s is the primary instrument for given start time' %inst_str)\r\n\r\n #checking to make sure this primary instrument actually has data\r\n year = str(given_start_date).split('-')[0]\r\n month = str(given_start_date).split('-')[1]\r\n url = ('https://satdat.ngdc.noaa.gov/sem/goes/data/avg/'+ year + '/' +\r\n month + '/goes' + inst_str)\r\n\r\n try:\r\n request.urlopen(url)\r\n print('GOES-%s has data available' %inst_str)\r\n instrument = 'GOES-' + inst_str\r\n print('we are using %s as our instrument for observations' %instrument)\r\n\r\n except request.HTTPError:\r\n #if primary instrument doesn't have data for this date, using backup instrument\r\n print('GOES-%s does NOT have data available' %inst_str)\r\n\r\n #reformatting backup instrument\r\n if len(str(backup_inst)) == 2:\r\n inst_str = str(backup_inst)\r\n elif len(str(backup_inst)) ==1:\r\n inst_str = '0' + str(backup_inst)\r\n\r\n print('checking for data from backup instrument GOES-%s' %inst_str)\r\n\r\n url = ('https://satdat.ngdc.noaa.gov/sem/goes/data/avg/'+ year + '/'\r\n + month + '/goes' + inst_str)\r\n\r\n #checking to see if backup instrument has data for this date, if not have\r\n #to manually choose which instrument to use based off which instruments\r\n #have data available\r\n try:\r\n request.urlopen(url)\r\n print('backup instrument data found - using backup instrument')\r\n instrument = 'GOES-' + inst_str\r\n print('we are using %s as our instrument for observations'\r\n %instrument)\r\n\r\n except request.HTTPError:\r\n print('no knowledge of backup or primary instrument - choosing '\r\n 'instrument based on available data')\r\n alternate_output = choose_inst(given_start_date,given_end_date)\r\n\r\n return(alternate_output)\r\n\r\n return([instrument,end_date])","def calc(self,index,counter_values):\n gr = self.grSign * self.grPitch['Value'].value\n m = self.mSign * self.mPitch['Value'].value\n \n offsetG,offsetM = self.checkOffset()\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\n alpha = (2.0*theta) + beta\n numerator = (math.sin(alpha) + math.sin(beta))\n denominator = (self.DiffrOrder * self.look_at_grx())\n wavelength = numerator / denominator\n \n if wavelength == 0.0:\n energy_physicalmot = 0.0\n else:\n energy_physicalmot = self.hc / wavelength\n #if self.FixedM2Pit: \n Cff = math.cos(beta)/math.cos(alpha)\n if energy_physicalmot < 0 :\n #warning: wavelength se vuelve negativo ... ??????\n energy_physicalmot = energy_physicalmot *(-1) \n \n # Real Energy is equal to the energy calculated by the encoders\n # minus an offset that depends on the same energy calculated by the \n # encoders:\n # E_physicalmot = Ereal + offset\n # with offset = a*Ereal + b\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \n a_coeff = self.EnergyDP.a_offset_coeff\n b_coeff = self.EnergyDP.b_offset_coeff\n numerator = energy_physicalmot - b_coeff\n denominator = 1 + a_coeff\n energy = numerator / denominator\n \n if index == 1:\n return energy\n elif index == 2:\n return Cff","def get_FAAM_mineral_dust_calibration(instrument='PCASP', rtn_values=True):\n # Location and name of calibration files?\n folder = '{}/FAAM/'.format(get_local_folder('ARNA_data'))\n if instrument == 'PCASP':\n # NOTE: range ~0.1-4 microns\n filename = 'PCASP1_faam_20200128_v001_r000_cal.nc'\n # NOTE: dust values are a nc subgroup!\n # group = 'bin_cal'\n group = 'bin_cal/mineral_dust'\n # group = 'flow_cal'\n # The real part of the refractive index was taken as 1.53 which is a common value and is in the OPAC database. It is quite a bit smaller than the 1.547 that was reported by Weinzierl et al. [2011] but has been shown to have a relatively weak effect on the instrument response. The values of the imaginary part were based on references in Ryder et al. [2019] along with the frequency distribution of k(550nm) presented in fig 9 of Ryder et al. [2013]. So the minimum value was extended from 0.0015i to 0.001i. Calculating the bin boundaries with these multiple Mie curves was done with Gaussian centre-weighted averaging with 0.001i and 0.0024i being +/-2 sigma extreme values.\n elif instrument == 'CDP':\n # NOTE: range ~4-120 microns\n filename = 'CDP1_faam_20200208_v001_r000_cal.nc'\n # NOTE: dust values are a nc subgroup!\n group = 'master_cal/mineral_dust'\n # Open and return the widths and\n ds = xr.open_dataset(folder+filename, group=group)\n # Get values for bin centres and widths in microns (1E-6 metres)\n BinWidths = ds['dia_width'].values.flatten()\n BinCentres = ds['dia_centre'].values.flatten()\n d = {'BinWidths': BinWidths, 'BinCentres': BinCentres}\n if rtn_values:\n return d\n else:\n return ds","def __init__(self):\r\n \r\n # Define temporal range\r\n self.timelimit = np.zeros(2,dtype=datetime.datetime)\r\n self.timelimit[0] = datetime.datetime(1990,1,1)\r\n self.timelimit[1] = datetime.datetime(2050,1,1)\r\n \r\n ### emissions \r\n \r\n # Load in historical emissions by sector.\r\n self.year_E_hist_ccc, self.total_E_hist_ccc, self.sector_E_hist_ccc, self.sector_name_E, self.num_years_E_hist = load_historical_emissions()\r\n # Load in government emissions forecast.\r\n self.year_E_fore_gov, self.elms_E_fore_gov, self.total_E_fore_gov, self.total_E_fore_gov_95CI, sector_E_fore_gov, sector_name_E_fore_gov, self.num_years_E_fore = load_precovid_emission_gov_estimate()\r\n \r\n # Define Targets\r\n self.paris_wb_2 = (1-0.8) * self.total_E_hist_ccc[0]\r\n self.net_zero = 0 \r\n \r\n # Reorder to be consistent \r\n self.num_E_sectors = len(self.sector_name_E) \r\n org_hist_gov = np.zeros(self.num_E_sectors,dtype=int) \r\n \r\n for sec1 in range(0,self.num_E_sectors):\r\n \r\n for sec2 in range(0,self.num_E_sectors):\r\n \r\n if self.sector_name_E[sec1] == sector_name_E_fore_gov[sec2]:\r\n \r\n org_hist_gov[sec1] = sec2\r\n \r\n break\r\n \r\n elif (self.sector_name_E[sec1] == 'Land use, land use change and forestry' and sector_name_E_fore_gov[sec2] == 'LULUCF'):\r\n \r\n org_hist_gov[sec1] = sec2\r\n \r\n break\r\n \r\n \r\n # sector name short form (for plotting)\r\n \r\n self.sector_name_E_sf = np.array(['EneS','Bus','Tran','Pub','Res','Agr','IndP','LULUCF','WM'])\r\n self.sector_E_fore_gov = sector_E_fore_gov[org_hist_gov,:]\r\n\r\n ### economy\r\n \r\n # Load in historical economic data\r\n self.year_gdp_hist_ons, self.gdp_hist_ons, self.num_years_gdp_hist = load_annual_GDP_ons()\r\n self.month_gdp_hist_ons, self.gdp_hist_ons_mnth, self.num_months_gdp_hist = load_covid_GDP_ons() # By month\r\n \r\n # Load in projection of GDP\r\n self.year_gdp_fore_gov, self.elms_gdp_fore_gov, self.frac_change_gdp_fore_gove, self.num_years_gdp_fore = load_precovid_annual_GDP_estimate()\r\n \r\n # Find forecasted absolute values of GDP\r\n self.gdp_fore_gov = np.zeros(self.num_years_E_fore)\r\n \r\n for yr1 in range(0,self.num_years_E_fore):\r\n \r\n # Match Absolute Historical value to GDP before forecast year otherwise use percent change\r\n if self.elms_E_fore_gov[yr1] == False:\r\n \r\n for yr2 in range(0,self.num_years_gdp_hist):\r\n \r\n if self.year_gdp_hist_ons[yr1] == self.year_gdp_hist_ons[yr2]:\r\n \r\n self.gdp_fore_gov[yr1] = self.gdp_hist_ons[yr2]\r\n \r\n break\r\n \r\n else:\r\n \r\n break\r\n \r\n self.gdp_fore_gov[self.elms_E_fore_gov] = self.gdp_fore_gov[self.elms_E_fore_gov==False][-1] * (1+np.cumsum(self.frac_change_gdp_fore_gove[self.elms_gdp_fore_gov]))\r\n \r\n ### carbon intensity (eta)\r\n self.eta_gdp_hist = np.zeros(self.num_years_E_hist)\r\n\r\n # Historical \r\n for yr1 in range(0,self.num_years_gdp_hist):\r\n \r\n for yr2 in range(0,self.num_years_E_hist):\r\n \r\n if self.year_gdp_hist_ons[yr1] == self.year_E_hist_ccc[yr2]:\r\n \r\n self.eta_gdp_hist[yr1] = self.total_E_hist_ccc[yr2]/self.gdp_hist_ons[yr1]\r\n \r\n break\r\n # Forecast\r\n self.eta_gdp_fore = self.total_E_fore_gov/self.gdp_fore_gov\r\n \r\n ### COVID 19 Deaths\r\n self.day_mort_gov, self.mort_per_day_gov, self.R_per_day_gov = load_COVID19_mort()\r\n \r\n ### Google mobility\r\n self.day_m_google, self.m_google = load_google_mobility()\r\n \r\n self.tau_us, self.tau_as, self.Y_run, self.eta_run, self.E_run, self.R_run, self.m_run, self.mu_run = run_simulations()\r\n \r\n \r\n self.num_sec = len(self.tau_us)\r\n self.startdate_run = datetime.datetime(2020,1,31)\r\n self.endate_run = datetime.datetime(2050,1,1)\r\n self.num_days_run = len(self.Y_run[:,0])\r\n self.date_run = np.zeros(self.num_days_run,dtype=datetime.datetime)\r\n self.date_run[0] = self.startdate_run\r\n for day in range(1,self.num_days_run):\r\n \r\n self.date_run[day] = self.date_run[day-1] + datetime.timedelta(days=1)\r\n \r\n return","def get_cape(temp,pres,dewpt,hght,startp,startt,startdp,totalcape=False): \n\n # Check units\n # Init temp is startt in C, Init dew point is stwrtdp,\n # pressure levels are in hPa \n temp = temp - 273.15 # convert temperature to celsius\n dewpt = dewpt - 273.15 # convert dewpoint to celsius\n pres = pres/100 # convert pressure to hPa\n \n \n inds = np.where( (pres < startp) ) \n tmp = pres[inds]\n del pres\n #pres = tmp[::-1]\n pres = tmp[:]\n del tmp \n startp = startp/100\n \n tmp = temp[inds]\n del temp\n #temp = tmp[::-1]\n temp = tmp[:]\n del tmp \n\n tmp = dewpt[inds]\n del dewpt\n #dewpt = tmp[::-1]\n dewpt = tmp[:]\n del tmp \n\n tmp = hght[inds]\n del hght\n #hght = tmp[::-1]\n hght = tmp[:]\n del tmp \n\n \n # Get Sub-LCL traces \n presdry,tempdry,tempiso=dry_ascent(startp,startt-degCtoK,startdp-degCtoK) \n \n\n # make lcl variables explicit\n P_lcl=presdry[-1]\n T_lcl=tempdry[-1]\n\n # Now lift a wet parcel from the intersection point\n # preswet=linspace(P_lcl,100,101)\n preswet,tempwet=moist_ascent(P_lcl,T_lcl)\n\n # tparcel is the concatenation of tempdry and \n # tempwet, and so on.\n \n tparcel=np.concatenate((tempdry,tempwet[1:]))\n pparcel=np.concatenate((presdry,preswet[1:]))\n\n # Interpolating the environmental profile onto the \n # parcel pressure coordinate\n # tempenv=interp(preswet,pres[::-1],temp[::-1])\n ## NEW, for total column:\n tempenv=interp(pparcel,pres[::-1],temp[::-1])\n\n\n # now solve for the equlibrium levels above LCL\n # (all of them, including unstable ones)\n # eqlev,stab=solve_eq(preswet[::-1],(tempwet-tempenv)[::-1])\n # NEW, for total column:\n # On second thought, we don't really want/need\n # any equilibrium levels below LCL\n # eqlev,stab=solve_eq(pparcel[::-1],(tparcel-tempenv)[::-1])\n # This is equivalent to the old statement :\n eqlev,stab=solve_eq(pparcel[pparcel<=P_lcl][::-1],\\\n (tparcel-tempenv)[pparcel<=P_lcl][::-1])\n\n aa = tparcel-tempenv\n\n # Sorting index by decreasing pressure\n I=np.argsort(eqlev)[::-1]\n eqlev=eqlev[I]; stab=stab[I]\n\n # temperatures at the equilibrium level\n # tempeq=interp(eqlev,preswet[::-1],tempenv[::-1])\n ## NEW, for total column:\n tempeq=interp(eqlev,pparcel[::-1],tparcel[::-1])\n\n # This helps with debugging\n # for ii,eq in enumerate(eqlev):\n # print \"%5.2f %5.2f %2d\"%(eq,tempeq[ii],stab[ii])\n\n # need environmental temperature at LCL\n tenv_lcl=interp(P_lcl,pparcel[::-1],tempenv[::-1])\n\n isstab=np.where(stab==1.,True,False)\n unstab=np.where(stab==1.,False,True) \n\n if eqlev.shape[0]==0:\n # no unstable layers in entire profile\n # because the parcel never crosses the tenv\n P_lfc=float('NaN')\n P_el=float('NaN')\n elif T_lcl>tenv_lcl:\n # check LCL to see if this is unstable\n P_lfc=P_lcl\n if totalcape:\n P_el=eqlev[isstab][-1]\n else:\n P_el=eqlev[isstab][0]\n elif eqlev.shape[0]>1:\n # Parcel is stable at LCL so LFC is the \n # first unstable equilibrium level and \n # \"EQ\" level is the first stable equilibrium \n # level\n P_lfc=eqlev[unstab][0]\n if totalcape:\n P_el=eqlev[isstab][-1]\n else:\n P_el=eqlev[isstab][0]\n else:\n # catch a problem... if there is only\n # one eqlev and it's stable (this is \n # unphysical), then it could be a vertical\n # resolution thing. This is a kind of \n # \"null\" option\n try:\n\t P_el=eqlev[isstab][0]\n P_lfc=eqlev[isstab][0]\n except:\n\t P_el=eqlev[unstab][0]\n P_lfc=eqlev[unstab][0]\t\n\t\n if np.isnan(P_lfc):\n return P_lcl,P_lfc,P_el,0,0\n\n # need to handle case where dwpt is not available \n # above a certain level for any reason. Most simplest \n # thing to do is set it to a reasonably low value; \n # this should be a conservative approach!\n \n #dwpt=dewpt.copy().soften_mask()\n [inds] = np.where(np.isnan(dewpt))\n dwpt = dewpt\n dwpt[inds] = dwpt.min()\n \n # raise ValueError\n #if dwpt[(pres>=P_el).data*(pres<P_lfc).data].mask.any():\n # print \"WARNING: substituting dwpt.min() for masked values of DWPT in this sounding\"\n #dwpt[dwpt.mask]=dwpt.min()\n # dwptenv=interp(preswet,pres[::-1],dwpt[::-1])\n # NEW:\n\n dwptenv=interp(pparcel,pres[::-1],dwpt[::-1])\n\n\n \n #if hght[(pres>=P_el).data].mask.any():\n # raise NotImplementedError, \"TODO: Implement standard atmosphere to substitute missing heights\"\n # hghtenv=interp(preswet,pres[::-1],self.soundingdata['hght'][::-1])\n # NEW:\n hghtenv=interp(pparcel,pres[::-1],hght[::-1])\n \n\n # Areas of POSITIVE Bouyancy\n # cond1=(tempwet>=tempenv)*(preswet<=P_lfc)*(preswet>P_el)\n # NEW:\n cond1=(tparcel>=tempenv)*(pparcel<=P_lfc)*(pparcel>P_el)\n # Areas of NEGATIVE Bouyancy\n # cond2=(tempwet<tempenv)*(preswet<=P_lcl)*(preswet>P_el)\n # NEW:\n if totalcape:\n cond2=(tparcel<tempenv)*(pparcel>P_el)\n else:\n cond2=(tparcel<tempenv)*(pparcel>P_lfc)\n # Do CAPE calculation\n # 1. Virtual temperature of parcel... remember it's saturated above LCL.\n # e_parcel=SatVap(tempwet)\n # Tv_parcel=VirtualTemp(tempwet+degCtoK,preswet*100.,e_parcel)\n # e_env=SatVap(dwptenv)\n # Tv_env=VirtualTemp(tempenv+degCtoK,preswet*100.,e_env)\n # NEW:\n e_parcel=SatVap(tparcel)\n Tv_parcel=VirtualTemp(tparcel+degCtoK,pparcel*100.,e_parcel)\n e_env=SatVap(dwptenv)\n Tv_env=VirtualTemp(tempenv+degCtoK,pparcel*100.,e_env)\n\n CAPE=trapz(9.81*(Tv_parcel[cond1]-Tv_env[cond1])/Tv_env[cond1],hghtenv[cond1])\n CIN=trapz(9.81*(Tv_parcel[cond2]-Tv_env[cond2])/Tv_env[cond2],hghtenv[cond2])\n\n return P_lcl,P_lfc,P_el,CAPE,CIN","def specvol(SA, CT, p):\n\n SA = np.maximum(SA, 0)\n\n xs = np.sqrt(sfac * SA + soffset)\n ys = CT * 0.025\n z = p * 1e-4\n\n specific_volume = (v000\n + xs * (v100 + xs * (v200 + xs * (v300 + xs * (v400 + xs * (v500\n + xs * v600)))))\n + ys * (v010\n + xs * (v110 + xs * (v210 + xs * (v310 + xs * (v410 + xs * v510))))\n + ys * (v020 + xs * (v120 + xs * (v220 + xs * (v320 + xs * v420)))\n + ys * (v030 + xs * (v130 + xs * (v230 + xs * v330))\n + ys * (v040 + xs * (v140 + xs * v240)\n + ys * (v050 + xs * v150 + ys * v060)))))\n + z * (v001\n + xs * (v101 + xs * (v201 + xs * (v301 + xs * (v401 + xs * v501))))\n + ys * (v011 + xs * (v111 + xs * (v211 + xs * (v311 + xs * v411)))\n + ys * (v021 + xs * (v121 + xs * (v221 + xs * v321))\n + ys * (v031 + xs * (v131 + xs * v231)\n + ys * (v041 + xs * v141 + ys * v051))))\n + z * (v002\n + xs * (v102 + xs * (v202 + xs * (v302 + xs * v402)))\n + ys * (v012 + xs * (v112 + xs * (v212 + xs * v312))\n + ys * (v022 + xs * (v122 + xs * v222)\n + ys * (v032 + xs * v132 + ys * v042)))\n + z * (v003\n + xs * (v103 + xs * v203)\n + ys * (v013 + xs * v113 + ys * v023)\n + z * (v004 + xs * v104 + ys * v014\n + z * (v005 + z * v006))))))\n\n return specific_volume","def acquisition(self):\r\n fs, _ = self.gp.predict(self.gp.X)\r\n next_fs, vars = self.gp.predict(self.X_s)\r\n opt = np.min(fs)\r\n improves = opt - next_fs - self.xsi\r\n Z = improves / vars\r\n eis = improves * norm.cdf(Z) + vars * norm.pdf(Z)\r\n return self.X_s[np.argmax(eis)], eis","def get_requested_supply_air_temperature_for_cooling(\n theta_sur_c: np.ndarray, theta_ac: np.ndarray, l_d_cs: np.ndarray, v_d_supply: np.ndarray,\n psi: float, l_duct: np.ndarray) -> np.ndarray:\n\n c = get_specific_heat()\n rho = get_air_density()\n\n l_duct = np.array(l_duct).reshape(1,5).T\n\n theta_req_c = theta_sur_c - (theta_sur_c - theta_ac + l_d_cs * 10 ** 6 / (v_d_supply * c * rho)) \\\n * np.exp(psi * l_duct * 3600 / (v_d_supply * c * rho))\n\n return np.minimum(theta_req_c, theta_ac)","def sample_consumption():\n product = Product(\"NameA\", 15, 17.85, 0.07, \"oak\", 0.08, \"ENplusA1\",\n \"Pelletics.cz\", date(2020, 12, 20))\n delivery = Delivery(product, \"Pellets2Home\", 7350, 42500,\n date(2020, 12, 20))\n some_datetime = datetime(2020, 11, 20, 14, 22, 46, 0)\n consumption = Consumption(some_datetime, delivery, 30, \"30 kgs\")\n return consumption","def get_rates(c, a, K, t, nu=lambda t: 1.0, mu=lambda t: 1.0, b=lambda S: 1.0,\r\n d=lambda S: 1.0, availability_function=None):\r\n # compute stimulus: interaction mat. x ag. conc. x competition\r\n if availability_function is not None:\r\n # antigenic trigger vector (1 entry per clone)\r\n antigenic_trigger = c.dot(K)\r\n S = K.dot(a * availability_function(antigenic_trigger))\r\n # no competition function\r\n else:\r\n # stimulus for clone i= interaction matrix\r\n S = K.dot(a)\r\n\r\n # returns absolute rate, total rate\r\n bS, dS = b(S) * nu(t), d(S) * mu(t)\r\n return bS, dS","def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):","def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\n phi = 0.0\n\n ## Approach A - NREL Approach\n if approach_call == \"A\":\n\n phi = float(Q_load_W) / float(Q_design_W)\n eta_max = 0.425 # from energy.gov\n\n if phi >= phi_threshold: # from NREL-Shape\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\n\n if phi < phi_threshold:\n if phi <= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\n\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3.0 + \\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\n\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\n\n eta_therm_max = 0.45 # constant, after energy.gov\n\n if phi < phi_threshold:\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\n\n else:\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\n\n ## Approach B - Empiric Approach\n if approach_call == \"B\":\n\n if Q_design_W > 0:\n phi = float(Q_load_W) / float(Q_design_W)\n\n else:\n phi = 0\n\n eta_el_max = 0.39\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\n\n eta_el = eta_el_max * eta_el_score\n eta_therm = eta_therm_max * eta_therm_score\n\n if phi < 0.2:\n eta_el = 0\n\n return eta_el, eta_therm","def _nextObservation(self):\n frame = np.array(self.df.loc[(self.currentStep - (self.time_lag - 1)):self.currentStep,['return_Low','return_Volume']].values)\n obs = (frame,np.array([self.balance/10000,self.buy_amount/10000,self.sell_amount/10000])) # standardize the value\n return obs","def get_beta(self, epoch, beta_start=None, beta_end=None):\r\n if beta_start is None:\r\n beta_start = self.beta_start\r\n if beta_end is None:\r\n beta_end = self.beta_end\r\n\r\n if epoch < beta_start:\r\n return self.beta0\r\n elif beta_start <= epoch <= beta_end:\r\n if self.schedule_type == 'constant':\r\n return self.beta0\r\n elif self.schedule_type == 'linear':\r\n return (self.beta0\r\n + (self.beta1 - self.beta0) * (epoch - beta_start)\r\n / (beta_end - beta_start))\r\n elif self.schedule_type == 'cosine':\r\n return self.cosine_annealing(epoch, beta_start, beta_end)\r\n elif self.schedule_type == 'cosine-restarts':\r\n cycle_len = (beta_end - beta_start) // self.cycles\r\n cycle_idx = (epoch - beta_start) // cycle_len\r\n start_epoch = beta_start + cycle_len * cycle_idx\r\n end_epoch = beta_start + cycle_len * (cycle_idx + 1)\r\n return self.cosine_annealing(epoch, start_epoch, end_epoch)\r\n else:\r\n raise ValueError('Unsupported schedule type {}'\r\n .format(self.schedule_type))\r\n else:\r\n return self.beta1","def AmericanBinomialPricer(pricing_engine, option, data):\r\n\r\n\r\n expiry = option.expiry\r\n strike = option.strike\r\n (spot, rate, volatility, dividend) = data.get_data()\r\n steps = pricing_engine.steps\r\n nodes = steps + 1\r\n dt = expiry / steps \r\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \r\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\r\n pu = (np.exp(rate * dt) - d) / (u - d)\r\n pd = 1 - pu\r\n disc = np.exp(-rate * expiry)\r\n spotT = 0.0\r\n payoffT = 0.0\r\n callT = 0.0\r\n putT= 0.0\r\n #call\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n callT = max(callT, spotT-strike)\r\n price = disc * payoffT\r\n #put\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n putT = max(putT, strike-spot)\r\n price = disc * payoffT\r\n \r\n return price","def calculate_expected_return(beta, alpha, risk_free_rate, market_returns):\n return risk_free_rate + beta * (market_returns - risk_free_rate)","def beta_range_s_circular(s,sma):\n #sma**2. = s**2. + y**2.\n if s > sma: #failure mode/nonphysical\n s = sma\n y = np.sqrt(sma**2.-s**2.)\n beta_min = np.pi/2. - np.arctan2(y,s)\n beta_max = np.pi/2. + np.arctan2(y,s)\n return beta_min, beta_max"],"string":"[\n \"def get_cooling_output_for_supply_air_estimation(\\n a_a: float, q: float, mu_c: float, v_vent: np.ndarray,\\n theta_ex: np.ndarray, x_ex: np.ndarray, j: np.ndarray,\\n hc_period: np.ndarray, n_p: np.ndarray, q_gen: np.ndarray, w_gen: np.ndarray, v_local: np.ndarray,\\n theta_set_c: float, x_set_c: float):\\n\\n # specific heat of air, J/kgK\\n c = get_specific_heat()\\n\\n # air density, kg/m3\\n rho = get_air_density()\\n\\n # latent heat of evaporation, kJ/kg\\n l_wtr = get_evaporation_latent_heat()\\n\\n q_d_hs_cs = np.maximum(\\n (((q - 0.35 * 0.5 * 2.4) * a_a + c * rho * (v_local + sum(v_vent)) / 3600) * (\\n theta_ex - theta_set_c)\\n + mu_c * a_a * j + q_gen + n_p * 51.0) * 3600 * 10 ** (-6),\\n 0.0) * (hc_period == 'c')\\n\\n q_d_hs_cl = np.maximum(\\n (((v_local + sum(v_vent)) * rho * (x_ex - x_set_c) * 10 ** 3 + w_gen) * l_wtr\\n + n_p * 40.0 * 3600) * 10 ** (-6), 0.0) * (hc_period == 'c')\\n\\n return q_d_hs_cs + q_d_hs_cl\",\n \"def max_self_consumption(parameter, ppv, pl, pvmod=True, ideal=False):\\r\\n # Maximize self consumption for AC-coupled systems\\r\\n if parameter['Top'] == 'AC':\\r\\n\\r\\n # DC power output of the PV generator\\r\\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp \\r\\n if ideal:\\r\\n Ppv = np.maximum(0, ppv ) * parameter['P_PV'] * 1000\\r\\n else:\\r\\n Ppv = np.minimum(ppv * parameter['P_PV'], parameter['P_PV2AC_in']) * 1000\\r\\n else: # ppv: DC power output of the PV generator in W\\r\\n \\r\\n if ideal:\\r\\n Ppv = np.maximum(0, ppv)\\r\\n else:\\r\\n Ppv = np.minimum(ppv, parameter['P_PV2AC_in'] * 1000)\\r\\n\\r\\n\\r\\n # Normalized input power of the PV inverter\\r\\n ppvinvin = Ppv / parameter['P_PV2AC_in'] / 1000\\r\\n\\r\\n # AC power output of the PV inverter taking into account the conversion losses and maximum\\r\\n # output power of the PV inverter\\r\\n Ppvs = np.minimum(np.maximum(0, Ppv-(parameter['PV2AC_a_in'] * ppvinvin * ppvinvin + parameter['PV2AC_b_in'] * ppvinvin + parameter['PV2AC_c_in'])), parameter['P_PV2AC_out'] * 1000)\\r\\n\\r\\n # 3.2 Residual power\\r\\n\\r\\n # Additional power consumption of other system components (e.g. AC power meter) in W\\r\\n Pperi = np.ones_like(ppv) * parameter['P_PERI_AC']\\r\\n\\r\\n # Adding the standby consumption of the PV inverter in times without any AC power output of the PV system\\r\\n # to the additional power consumption\\r\\n Pperi[Ppvs == 0] += parameter['P_PVINV_AC']\\r\\n\\r\\n # Residual power\\r\\n if ideal:\\r\\n Pr = Ppv - pl\\r\\n else:\\r\\n Pr = Ppvs - pl - Pperi\\r\\n\\r\\n return Pr, Ppv, Ppvs, Pperi\\r\\n\\r\\n # Maximize self consumption for DC-coupled systems\\r\\n elif parameter['Top'] == 'DC':\\r\\n # Initialization and preallocation\\r\\n Ppv2ac_in_ac = np.zeros_like(ppv)\\r\\n Ppv = np.empty_like(ppv) # DC power output of the PV generator\\r\\n\\r\\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp\\r\\n Ppv = ppv * parameter['P_PV'] * 1000\\r\\n else:\\r\\n Ppv = ppv\\r\\n\\r\\n # DC power output of the PV generator taking into account the maximum\\r\\n # DC input power of the PV2AC conversion pathway\\r\\n Ppv = np.minimum(Ppv, parameter['P_PV2AC_in'] * 1000)\\r\\n\\r\\n # Residual power\\r\\n\\r\\n # Power demand on the AC side\\r\\n Pac = pl + parameter['P_PERI_AC']\\r\\n\\r\\n # Normalized AC output power of the PV2AC conversion pathway to cover the AC\\r\\n # power demand\\r\\n ppv2ac = np.minimum(\\r\\n Pac, parameter['P_PV2AC_out'] * 1000) / parameter['P_PV2AC_out'] / 1000\\r\\n\\r\\n # Target DC input power of the PV2AC conversion pathway\\r\\n Ppv2ac_in_ac = np.minimum(Pac, parameter['P_PV2AC_out'] * 1000) + (\\r\\n parameter['PV2AC_a_out'] * ppv2ac**2 + parameter['PV2AC_b_out'] * ppv2ac + parameter['PV2AC_c_out'])\\r\\n\\r\\n # Normalized DC input power of the PV2AC conversion pathway TODO 1\\r\\n ppv2ac = Ppv / parameter['P_PV2AC_in'] / 1000\\r\\n\\r\\n # Target AC output power of the PV2AC conversion pathway\\r\\n Ppv2ac_out = np.maximum(\\r\\n 0, Ppv - (parameter['PV2AC_a_in'] * ppv2ac**2 + parameter['PV2AC_b_in'] * ppv2ac + parameter['PV2AC_c_in']))\\r\\n\\r\\n # Residual power for battery charging\\r\\n Prpv = Ppv - Ppv2ac_in_ac\\r\\n\\r\\n # Residual power for battery discharging\\r\\n Pr = Ppv2ac_out - Pac\\r\\n\\r\\n return Pr, Prpv, Ppv, ppv2ac, Ppv2ac_out\\r\\n\\r\\n # Maximize self consumption for PV-coupled systems\\r\\n elif parameter['Top'] == 'PV':\\r\\n # Preallocation\\r\\n # Pbat = np.zeros_like(ppv) # DC power of the battery in W\\r\\n # soc = np.zeros_like(ppv) # State of charge of the battery\\r\\n # Ppv2ac_out = np.zeros_like(ppv) # Output power of the PV2AC conversion pathway in W\\r\\n # Ppv2bat_in = np.zeros_like(ppv) # Input power of the PV2BAT conversion pathway in W\\r\\n # Pbat2pv_out = np.zeros_like(ppv) # Output power of the BAT2PV conversion pathway in W\\r\\n # Ppvbs = np.zeros_like(ppv) # AC power of the PV-battery system in W\\r\\n Ppv = np.empty_like(ppv) # DC power output of the PV generator\\r\\n # Additional power consumption of other system components (e.g. AC power meter) in W\\r\\n Pperi = np.ones_like(ppv) * parameter['P_PERI_AC']\\r\\n # dt = 1 # Time increment in s\\r\\n # th = 0 # Start threshold for the recharging of the battery\\r\\n # soc0 = 0 # State of charge of the battery in the first time step\\r\\n\\r\\n # DC power output of the PV generator\\r\\n if pvmod: # ppv: Normalized DC power output of the PV generator in kW/kWp\\r\\n Ppv = ppv * parameter['P_PV'] * 1000\\r\\n\\r\\n else: # ppv: DC power output of the PV generator in W\\r\\n Ppv = ppv\\r\\n\\r\\n # Power demand on the AC side\\r\\n Pac = pl + Pperi\\r\\n\\r\\n return Pac, Ppv, Pperi\",\n \"def estimate_tr_slot(br_data_df, fab_started_at, leeway, agent_df):\\r\\n a = br_data_df.loc[0, 'AVG(ca_op_time)']\\r\\n b = br_data_df.loc[0, 'AVG(tr_op_time)']\\r\\n # br_data_df.loc[0, 'AVG(ca_op_time)'] == 9:\\r\\n #if br_data_df.loc[0, 'AVG(tr_op_time)'] == 3.5: # if these 2 conditions are met, with high prob we are in first ever auction.\\r\\n #fab_started_at = datetime.datetime.now()\\r\\n #auction_total_time = 2 # auction estimated total time = 2 min\\r\\n # slot_1_start = datetime.datetime.now() + datetime.timedelta(minutes=int(auction_total_time)) - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - leeway # time when on going fab started + mean ca processing time - mean tr operation time - margin.\\r\\n # slot_1_end = slot_1_start + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) # time when on going fab started + mean tr operation time\\r\\n # slot_2_start = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) - leeway # time when on going fab started + mean ca processing time - margin\\r\\n # slot_2_end = slot_2_start + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) # time when on going fab started + mean ca processing time + mean tr operation time\\r\\n ca_estimated_end = fab_started_at + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) # time when on going fab started + mean ca processing time.\\r\\n if br_data_df.loc[0, 'AVG(ca_op_time)'] == 9:\\r\\n if br_data_df.loc[0, 'AVG(tr_op_time)'] == 3.5:\\r\\n slot_1_start = ca_estimated_end - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - (leeway / 2)\\r\\n slot_1_end = ca_estimated_end + (leeway / 2)\\r\\n\\r\\n slot_1_start = ca_estimated_end - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)'])) - (leeway / 2)\\r\\n slot_1_end = ca_estimated_end + (leeway / 2)\\r\\n slot_2_start = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) - datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)']/2)) - (leeway / 2)\\r\\n slot_2_end = ca_estimated_end + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(ca_op_time)'])) + datetime.timedelta(minutes=int(br_data_df.loc[0, 'AVG(tr_op_time)']/2)) + (leeway / 2) # time when on going fab started + mean ca processing time + mean tr operation time\\r\\n ca_to_tr_df = pd.DataFrame([], columns=['id', 'agent_type', 'location_1', 'location_2', 'location', 'purpose', 'request_type', 'action', 'time', 'slot_1_start', 'slot_1_end', 'slot_2_start', 'slot_2_end', 'slot'])\\r\\n ca_to_tr_df.at[0, 'id'] = agent_df.loc[0, 'id']\\r\\n ca_to_tr_df.at[0, 'agent_type'] = agent_df.loc[0, 'agent_type']\\r\\n ca_to_tr_df.at[0, 'location_1'] = agent_df.loc[0, 'location_1']\\r\\n ca_to_tr_df.at[0, 'location_2'] = agent_df.loc[0, 'location_2']\\r\\n ca_to_tr_df.at[0, 'location'] = agent_df.loc[0, 'location']\\r\\n ca_to_tr_df.at[0, 'purpose'] = \\\"request\\\"\\r\\n ca_to_tr_df.at[0, 'slot_1_start'] = slot_1_start\\r\\n ca_to_tr_df.at[0, 'slot_1_end'] = slot_1_end\\r\\n ca_to_tr_df.at[0, 'slot_2_start'] = slot_2_start\\r\\n ca_to_tr_df.at[0, 'slot_2_end'] = slot_2_end\\r\\n this_time = datetime.datetime.now()\\r\\n ca_to_tr_df.at[0, 'time'] = this_time\\r\\n ca_to_tr_df.at[0, 'request_type'] = \\\"request\\\"\\r\\n ca_to_tr_df.at[0, 'action'] = \\\"pre-book\\\"\\r\\n return ca_to_tr_df\",\n \"def get_portfolio_value(prices, allocs, start_val):\\n normed = prices/prices.iloc[0]\\n alloced = np.multiply(allocs, normed)\\n pos_vals = alloced * start_val\\n port_val = pos_vals.sum(axis=1)\\n return port_val\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def compute(self):\\n\\t\\tdata = self.policy.data\\n\\t\\tCin = xarray.zeros_like(data[self.policy.finalname]).squeeze().compute()\\n\\t\\talphanum = tonumber(self.alpha,1/s) \\n\\t\\tCout = data[self.policy.finalname].squeeze() \\n\\t\\t\\n\\t\\tfor I in range(1,len(self.policy.data[self.policy.datetimename])): \\n\\t\\t\\tcurstep = {self.policy.datetimename : I}\\n\\t\\t\\tprevstep = {self.policy.datetimename : I-1}\\n\\t\\t\\tdt = (pandas.to_timedelta((data.datetime[curstep] - data.datetime[prevstep]).values)).total_seconds()\\n\\t\\t\\tCin[curstep] = (Cin[prevstep] + alphanum*dt*Cout[curstep])/(1+alphanum*dt)\\n\\n\\t\\tdata[self.name] = Cin\\n\\n\\t\\t## Setting the final values as Cout when outside and Cin between begin and end. \\n\\t\\tif \\\"enter\\\" in self.params: \\n\\t\\t\\tif \\\"stay\\\" not in self.params: \\n\\t\\t\\t\\traise ValueError(\\\"Must supply both stay and enter (as timedelta str)\\\")\\n\\n\\t\\t\\tabegin = data[self.policy.datetimename][0].values + pandas.to_timedelta(self.params[\\\"enter\\\"])\\n\\t\\t\\taend = abegin + pandas.to_timedelta(self.params[\\\"stay\\\"])\\n\\n\\t\\telse:\\n\\t\\t\\tabegin = self.params.get(\\\"begin\\\",None) \\n\\t\\t\\taend = self.params.get(\\\"end\\\" ,None) \\n\\n\\t\\tabegin = data[self.policy.datetimename].to_series()[0] if abegin is None else abegin\\n\\t\\taend = data[self.policy.datetimename].to_series()[-1] if aend is None else aend\\n\\n\\t\\tactionTimeList = data.datetime.to_series()[data[self.policy.datetimename].to_series().between(abegin,aend)]\\n\\t\\tdata[self.policy.finalname] = Cin.where(data[self.policy.datetimename].isin(actionTimeList),Cout)\\n\\t\\tdata.attrs[self.actionid] = { \\\"type\\\" : self.actiontype,\\\"actionid\\\": self.actionid,\\\"name\\\" : self.name,\\\\\\n\\t\\t\\t\\t\\t\\t \\\"params\\\" : {\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"alpha\\\" : self.alpha,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"turnover\\\":self.turnover,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"begin\\\" : abegin,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\\"end\\\" : aend \\n\\t\\t\\t\\t\\t\\t\\t\\t},\\\"outputs\\\" : [self.name]\\n\\t\\t\\t\\t\\t\\t }\",\n \"def eta2abc(parameter):\\r\\n # PV2AC conversion pathway TODO\\r\\n if parameter['Top'] == 'DC' or parameter['Top'] == 'PVINV' or parameter['Top'] == 'PV' and parameter['P_PV2AC_out'] is not None or parameter['Top'] == 'AC' and parameter['P_PV2AC_out'] is not None:\\r\\n \\r\\n # Create variables for the sampling points and corresponding efficiencies TODO\\r\\n p_pv2ac = np.fromiter((value for key, value in parameter.items() if 'p_PV2AC_' in key and value is not None), float)\\r\\n eta_pv2ac = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_PV2AC_' in key and value is not None), float)\\r\\n\\r\\n # Absolute input and output power in W\\r\\n p_pv2ac_out = parameter['P_PV2AC_out'] * p_pv2ac * 1000\\r\\n p_pv2ac_in = p_pv2ac_out / eta_pv2ac\\r\\n\\r\\n # Absolute power loss in W\\r\\n P_l_pv2ac_in = (1 - eta_pv2ac) * p_pv2ac_in\\r\\n P_l_pv2ac_out = (1 / eta_pv2ac - 1) * p_pv2ac_out\\r\\n\\r\\n # Polynomial curve fitting parameters of the power loss functions in W\\r\\n \\r\\n # Based on input power\\r\\n p = np.polyfit(p_pv2ac_in / parameter['P_PV2AC_in'] / 1000, P_l_pv2ac_in, 2)\\r\\n parameter['PV2AC_a_in'] = p[0]\\r\\n parameter['PV2AC_b_in'] = p[1]\\r\\n parameter['PV2AC_c_in'] = p[2]\\r\\n\\r\\n # Based on output power\\r\\n p = np.polyfit(p_pv2ac, P_l_pv2ac_out, 2)\\r\\n parameter['PV2AC_a_out'] = p[0]\\r\\n parameter['PV2AC_b_out'] = p[1]\\r\\n parameter['PV2AC_c_out'] = p[2]\\r\\n \\r\\n # PV2BAT conversion pathway\\r\\n if parameter['Top'] == 'DC' or parameter['Top'] == 'PV':\\r\\n\\r\\n # Create variables for the sampling points and corresponding efficiencies\\r\\n p_pv2bat = np.array([value for key, value in parameter.items() if 'p_PV2BAT_' in key])\\r\\n eta_pv2bat = np.array([value / 100 for key, value in parameter.items() if 'eta_PV2BAT_' in key])\\r\\n\\r\\n # Create missing variables\\r\\n\\r\\n # Nominal input power of the PV2BAT conversion pathway of DC-coupled systems\\r\\n if parameter['P_PV2BAT_in'] is None:\\r\\n parameter['P_PV2BAT_in'] = parameter['P_PV2BAT_out'] / (parameter['eta_PV2BAT_100'] / 100)\\r\\n\\r\\n # Absolute input and output power in W\\r\\n p_pv2bat_out = parameter['P_PV2BAT_out'] * p_pv2bat * 1000\\r\\n p_pv2bat_in = p_pv2bat_out / eta_pv2bat\\r\\n\\r\\n # Absolute power loss in W\\r\\n P_l_pv2bat_in = (1 - eta_pv2bat) * p_pv2bat_in\\r\\n P_l_pv2bat_out = (1 / eta_pv2bat - 1) * p_pv2bat_out\\r\\n \\r\\n # Polynomial curve fitting parameters of the power loss functions in W\\r\\n \\r\\n # Based on input power\\r\\n p = np.polyfit(p_pv2bat_in / parameter['P_PV2BAT_in'] / 1000, P_l_pv2bat_in, 2)\\r\\n parameter['PV2BAT_a_in'] = p[0]\\r\\n parameter['PV2BAT_b_in'] = p[1]\\r\\n parameter['PV2BAT_c_in'] = p[2]\\r\\n\\r\\n # Based on output power\\r\\n p = np.polyfit(p_pv2bat, P_l_pv2bat_out, 2)\\r\\n parameter['PV2BAT_a_out'] = p[0]\\r\\n parameter['PV2BAT_b_out'] = p[1]\\r\\n parameter['PV2BAT_c_out'] = p[2]\\r\\n \\r\\n # AC2BAT conversion pathway\\r\\n if parameter['Top'] == 'AC' or parameter['Top'] == 'DC' and parameter['P_AC2BAT_in'] is not None:\\r\\n\\r\\n # Create variables for the sampling points and corresponding efficiencies TODO\\r\\n p_ac2bat = np.fromiter((value for key, value in parameter.items() if 'p_AC2BAT_' in key), float)\\r\\n eta_ac2bat = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_AC2BAT_' in key), float)\\r\\n\\r\\n # Absolute input and output power in W\\r\\n p_ac2bat_out = parameter['P_PV2BAT_out'] * p_ac2bat * 1000\\r\\n p_ac2bat_in = p_ac2bat_out / eta_ac2bat\\r\\n\\r\\n # Absolute power loss in W\\r\\n P_l_ac2bat_in = (1 - eta_ac2bat) * p_ac2bat_in\\r\\n P_l_ac2bat_out = (1 / eta_ac2bat - 1) * p_ac2bat_out\\r\\n\\r\\n # Polynomial curve fitting parameters of the power loss functions in W\\r\\n \\r\\n # Based on input power\\r\\n p = np.polyfit(p_ac2bat_in / parameter['P_AC2BAT_in'] / 1000, P_l_ac2bat_in, 2)\\r\\n parameter['AC2BAT_a_in'] = p[0]\\r\\n parameter['AC2BAT_b_in'] = p[1]\\r\\n parameter['AC2BAT_c_in'] = p[2]\\r\\n\\r\\n # Based on output power\\r\\n p = np.polyfit(p_ac2bat, P_l_ac2bat_out, 2)\\r\\n parameter['AC2BAT_a_out'] = p[0]\\r\\n parameter['AC2BAT_b_out'] = p[1]\\r\\n parameter['AC2BAT_c_out'] = p[2]\\r\\n \\r\\n # BAT2AC conversion pathway\\r\\n if parameter['Top'] =='AC' or parameter['Top'] =='DC' or parameter['Top'] =='PV' and parameter['P_BAT2AC_out'] is not None:\\r\\n\\r\\n # Create variables for the sampling points and corresponding efficiencies TODO\\r\\n p_bat2ac = np.fromiter((value for key, value in parameter.items() if 'p_BAT2AC_' in key), float)\\r\\n eta_bat2ac = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_BAT2AC_' in key), float)\\r\\n\\r\\n # Absolute input and output power in W\\r\\n p_bat2ac_out = parameter['P_BAT2AC_out'] * p_bat2ac * 1000\\r\\n p_bat2ac_in = p_bat2ac_out / eta_bat2ac\\r\\n\\r\\n # Absolute power loss in W\\r\\n P_l_bat2ac_in = (1 - eta_bat2ac) * p_bat2ac_in\\r\\n P_l_bat2ac_out = (1 / eta_bat2ac - 1) * p_bat2ac_out\\r\\n\\r\\n # Polynomial curve fitting parameters of the power loss functions in W\\r\\n \\r\\n # Based on input power\\r\\n p = np.polyfit(p_bat2ac_in / parameter['P_BAT2AC_in'] / 1000, P_l_bat2ac_in, 2)\\r\\n parameter['BAT2AC_a_in'] = p[0]\\r\\n parameter['BAT2AC_b_in'] = p[1]\\r\\n parameter['BAT2AC_c_in'] = p[2]\\r\\n\\r\\n # Based on output power\\r\\n p = np.polyfit(p_bat2ac, P_l_bat2ac_out, 2)\\r\\n parameter['BAT2AC_a_out'] = p[0]\\r\\n parameter['BAT2AC_b_out'] = p[1]\\r\\n parameter['BAT2AC_c_out'] = p[2]\\r\\n \\r\\n # BAT2PV conversion pathway\\r\\n if parameter['Top'] =='PV':\\r\\n\\r\\n # Create variables for the sampling points and corresponding efficiencies TODO\\r\\n p_bat2pv = np.fromiter((value for key, value in parameter.items() if 'p_BAT2PV_' in key), float)\\r\\n eta_bat2pv = np.fromiter((value / 100 for key, value in parameter.items() if 'eta_BAT2PV_' in key), float)\\r\\n\\r\\n # Absolute input and output power in W\\r\\n p_bat2pv_out = parameter['P_BAT2PV_out'] * p_bat2pv * 1000\\r\\n p_bat2pv_in = p_bat2pv_out / eta_bat2pv\\r\\n\\r\\n # Absolute power loss in W\\r\\n P_l_bat2pv_in = (1 - eta_bat2pv) * p_bat2pv_in\\r\\n P_l_bat2pv_out = (1 / eta_bat2pv - 1) * p_bat2pv_out\\r\\n\\r\\n # Polynomial curve fitting parameters of the power loss functions in W\\r\\n \\r\\n # Based on input power TODO\\r\\n p = np.polyfit(p_bat2pv_in / parameter['P_BAT2AC_in'] / 1000, P_l_bat2pv_in, 2)\\r\\n parameter['BAT2PV_a_in'] = p[0]\\r\\n parameter['BAT2PV_b_in'] = p[1]\\r\\n parameter['BAT2PV_c_in'] = p[2]\\r\\n\\r\\n # Based on output power\\r\\n p = np.polyfit(p_bat2pv, P_l_bat2pv_out, 2)\\r\\n parameter['BAT2PV_a_out'] = p[0]\\r\\n parameter['BAT2PV_b_out'] = p[1]\\r\\n parameter['BAT2PV_c_out'] = p[2]\\r\\n \\r\\n # Additional parameters\\r\\n\\r\\n # Mean battery capacity in kWh\\r\\n try:\\r\\n parameter['E_BAT'] = (parameter['E_BAT_usable'] / parameter['eta_BAT'] * 100 + parameter['E_BAT_usable']) / 2\\r\\n except:\\r\\n parameter['E_BAT'] = None\\r\\n\\r\\n # Mean stationary deviation of the charging power in W\\r\\n try:\\r\\n parameter['P_PV2BAT_DEV'] = parameter['P_PV2BAT_DEV_IMPORT'] - parameter['P_PV2BAT_DEV_EXPORT']\\r\\n except:\\r\\n parameter['P_PV2BAT_DEV'] = None\\r\\n\\r\\n if parameter['Top'] == 'AC':\\r\\n parameter['P_AC2BAT_DEV'] = parameter['P_PV2BAT_DEV'] \\r\\n \\r\\n # Mean stationary deviation of the discharging power in W\\r\\n try:\\r\\n parameter['P_BAT2AC_DEV'] = parameter['P_BAT2AC_DEV_EXPORT'] - parameter['P_BAT2AC_DEV_IMPORT']\\r\\n except:\\r\\n parameter['P_BAT2AC_DEV'] = None\\r\\n \\r\\n # Time constant for the first-order time delay element in s\\r\\n try:\\r\\n parameter['t_CONSTANT'] = (parameter['t_SETTLING'] - round(parameter['t_DEAD'])) / 3\\r\\n except:\\r\\n parameter['t_CONSTANT'] = None\\r\\n\\r\\n # Hysteresis threshold for the recharging of the battery\\r\\n parameter['SOC_h'] = 0.98\\r\\n\\r\\n # Feed-in power limit in kW/kWp\\r\\n parameter['p_ac2g_max'] = 0.7\\r\\n\\r\\n return parameter\",\n \"def value(self,pt,eta,mode):\\n\\n self._range= get_etaFiner_key(eta)\\n\\n if mode == '0' :\\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['efficiency_ratio']\\n elif mode == '+1' :\\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['err_hi'] \\n elif mode == '-1' :\\n return self._map['combRelIsoPF04dBeta<02_Tight']['etapt20-500_2012ABCD'][self._range]['data/mc']['err_low']\\n else: \\n print 'ERROR: wrong \\\\'mode\\\\' specified: try \\\\'0\\\\',\\\\'+1\\\\' or \\\\'-1\\\\''\\n return 0\",\n \"def run(self, max_risk=0, min_return=0, num=0, init_holdings=None):\\n if not self.dates:\\n self.dates = ['2010-01-01', '2012-12-31']\\n self.load_data()\\n\\n num_months = len(self.df_all)\\n first_purchase = True\\n result = {}\\n baseline_result = {}\\n self.baseline_values = [0]\\n self.update_values = [0]\\n months = []\\n\\n # Define dataframe to save output data \\n headers = ['Date', 'Value'] + self.stocks + ['Variance', 'Returns']\\n self.opt_results_df = pd.DataFrame(columns=headers)\\n row = []\\n\\n self.price_df = pd.DataFrame(columns=self.stocks)\\n\\n # Initialize the plot\\n plt.ylim(ymax = 1.5*self.budget, ymin = -1.5*self.budget)\\n plt.xticks(list(range(0, num_months, 2)), \\n self.df_baseline.index.strftime('%b')[::2], rotation='vertical')\\n plt.locator_params(axis='x', nbins=num_months/2)\\n plt.plot(list(range(0, num_months)), [0]*(num_months), \\n color='red', label=\\\"Break-even\\\", linewidth=0.5)\\n\\n for i in range(3, num_months):\\n\\n # Look at just the data up to the current month\\n df = self.df_all.iloc[0:i+1,:].copy()\\n baseline_df_current = self.df_baseline.iloc[0:i+1,:]\\n print(\\\"\\\\nDate:\\\", df.last_valid_index())\\n months.append(df.last_valid_index().date()) \\n\\n if first_purchase:\\n budget = self.budget\\n initial_budget = self.budget\\n baseline_shares = (budget / baseline_df_current.iloc[-1])\\n baseline_result = {self.baseline[0]: baseline_shares} \\n else:\\n # Compute profit of current portfolio\\n budget = sum([df.iloc[-1][s]*result['stocks'][s] for s in self.stocks]) \\n self.update_values.append(budget - initial_budget)\\n\\n # Compute profit of fund portfolio\\n fund_value = sum([baseline_df_current.iloc[-1][s]*baseline_result[s] \\n for s in self.baseline]) \\n self.baseline_values.append(fund_value - initial_budget)\\n\\n self.budget = budget \\n\\n self.load_data(df=df)\\n\\n self.price_df.loc[i-2] = list(self.price.values)\\n\\n # Output for user on command-line and plot\\n update_values = np.array(self.update_values, dtype=object)\\n baseline_values = np.array(self.baseline_values, dtype=object)\\n plt.plot(range(3, i+1), update_values, \\n color='blue', label=\\\"Optimized portfolio\\\")\\n plt.plot(range(3, i+1), baseline_values, \\n color='gray', label=\\\"Fund portfolio\\\", linewidth=0.5)\\n \\n if first_purchase:\\n plt.legend(loc=\\\"lower left\\\")\\n plt.title(\\\"Start: {start}, End: {end}\\\".format\\\\\\n (start=self.df_all.first_valid_index().date(), \\n end=self.df_all.last_valid_index().date()))\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.pause(0.05)\\n \\n # Making solve run\\n if self.model_type == 'DQM':\\n print(f\\\"\\\\nMulti-Period DQM Run...\\\")\\n \\n self.build_dqm()\\n self.solution['DQM'] = self.solve_dqm()\\n result = self.solution['DQM']\\n else:\\n print(f\\\"\\\\nMulti-Period CQM Run...\\\")\\n\\n # Set budget to 0 to enforce that portfolio is self-financing \\n if self.t_cost and not first_purchase:\\n self.budget = 0 \\n\\n self.solution['CQM'] = self.solve_cqm(max_risk=max_risk, \\n min_return=min_return,\\n init_holdings=init_holdings)\\n result = self.solution['CQM']\\n init_holdings = result['stocks']\\n\\n # Print results to command-line\\n value = sum([self.price[s]*result['stocks'][s] for s in self.stocks])\\n returns = result['return']\\n variance = result['risk'] \\n\\n row = [months[-1].strftime('%Y-%m-%d'), value] + \\\\\\n [result['stocks'][s] for s in self.stocks] + \\\\\\n [variance, returns] \\n self.opt_results_df.loc[i-2] = row \\n \\n first_purchase = False\\n\\n print(self.opt_results_df)\\n print(f'\\\\nRun completed.\\\\n')\\n\\n plt.savefig(\\\"portfolio.png\\\")\\n plt.show(block=False)\",\n \"def cAPM_Constant(df_train, df_test, MaxRPT_r1, MaxRPT, no_rounds):\\n\\n # number of periods in samples\\n T = df_train.shape[0]\\n T_test = df_test.shape[0]\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # outcomes\\n outcomes = df_train.iloc[:, 0].values\\n\\n # initialize matrices containing all predictions and bets\\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n\\n # budget initialization\\n budgets = np.full(K, 1, dtype=float)\\n\\n # training the market\\n for i in range(T):\\n\\n # first round betting\\n pred_mat[0, :] = F[i, :]\\n bet_mat[0, :] = budgets * MaxRPT_r1\\n budgets = budgets * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F[i, :]\\n bet_mat[j, :] = budgets * MaxRPT\\n budgets = budgets * (1-MaxRPT)\\n\\n # use IQR to determine outlier error threshold\\n abs_errors = np.abs(outcomes[i] - pred_mat)\\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\\n IQR = Q3 - Q1\\n oet = Q3 + (IQR*1.5)\\n\\n # reward the agents based on accuracy of their predictions\\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\\n score = np.log(accuracy)\\n revenue = np.multiply(score, bet_mat)\\n budgets = budgets + np.sum(revenue, axis=0)\\n\\n # rescaling the budget (only for computational reasons)\\n budgets = budgets/np.sum(budgets)\\n\\n # using the market for the out-of-sample predictions\\n pred = np.full(T_test, np.nan, dtype=float)\\n for i in range(T_test):\\n\\n # reset test budget\\n budgets_test = np.copy(budgets)\\n\\n # first round betting\\n pred_mat[0, :] = F_test[i, :]\\n bet_mat[0, :] = budgets_test * MaxRPT_r1\\n budgets_test = budgets_test * (1-MaxRPT_r1)\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F_test[i, :]\\n bet_mat[j, :] = budgets_test * MaxRPT\\n budgets_test = budgets_test * (1-MaxRPT)\\n\\n # final round market prediction is the c-APM prediction\\n pred[i] = np.dot(\\n pred_mat[no_rounds-1, :],\\n bet_mat[no_rounds-1, :])/np.sum(bet_mat[no_rounds-1, :])\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"c-APM (Constant)\\\": pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def test_best_allocation():\\n\\n # symbols = ['BRCM', 'TXN', 'IBM', 'HNZ'] \\n symbols = ['AAPL', 'GOOG', 'IBM', 'MSFT']\\n # ['GOOG','AAPL','GLD','XOM']\\n basic_portfolio = BasicPortfolio(symbols, dt.datetime(2014, 1, 1), dt.datetime(2014, 12, 31))\\n\\n alloc = range(4)\\n\\n sharpe_max = 0\\n alloc_max = alloc[:]\\n\\n for i in range(11):\\n alloc[0] = i * 0.1\\n for j in range(11 - i):\\n alloc[1] = j * 0.1\\n for k in range(11 - i - j):\\n alloc[2] = k * 0.1\\n alloc[3] = (10 - i - j - k) * 0.1\\n\\n vol, daily_ret, sharpe, cum_ret = \\\\\\n basic_portfolio.analyze(alloc)\\n\\n if sharpe > sharpe_max:\\n sharpe_max = sharpe\\n alloc_max = alloc[:]\\n\\n print 'Best sharpe ratio is ', sharpe_max\\n print 'Best allocation is', alloc_max\\n\\n ref_symbol = '$SPX'\\n\\n basic_portfolio.plot_with_reference(alloc_max, ref_symbol, source='local')\",\n \"def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\\n\\n \\\"\\\"\\\"\\n This function calculates American Opportunity Credit\\n for up to four eligible students\\n\\n \\\"\\\"\\\"\\n\\n # Expense should not exceed the cap of $4000.\\n if _cmp == 1:\\n\\n c87482 = max(0., min(e87482, 4000.))\\n c87487 = max(0., min(e87487, 4000.))\\n c87492 = max(0., min(e87492, 4000.))\\n c87497 = max(0., min(e87497, 4000.))\\n else:\\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\\n\\n # Credit calculated as 100% of the first $2000 expense plus\\n # 25% of amount exceeding $2000.\\n if max(0, c87482 - 2000) == 0:\\n c87483 = c87482\\n else:\\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\\n\\n if max(0, c87487 - 2000) == 0:\\n c87488 = c87487\\n else:\\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\\n\\n if max(0, c87492 - 2000) == 0:\\n c87493 = c87492\\n else:\\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\\n\\n if max(0, c87497 - 2000) == 0:\\n c87498 = c87497\\n else:\\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\\n\\n # Sum of credits of all four students.\\n c87521 = c87483 + c87488 + c87493 + c87498\\n\\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\\n c87521)\",\n \"def value(self,pt,eta,mode):\\n\\n self._eta_range= get_eta_key(eta)+'_2012B'\\n self._pt_range= get_pt_key(pt)\\n\\n if mode == '0' :\\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['efficiency'] \\n elif mode == '+1' :\\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['err_hi']\\n elif mode == '-1' : \\n return self._map['DoubleMu17Mu8_Mu8_Tight'][self._eta_range][self._pt_range]['data']['err_low']\\n else: \\n print 'ERROR: wrong \\\\'mode\\\\' specified: try \\\\'0\\\\',\\\\'+1\\\\' or \\\\'-1\\\\'' \\n return 0\",\n \"def dispatch_max_sc(pv, demand, inv_size,param, return_series=False):\\n bat_size_e_adj = param['BatteryCapacity']\\n bat_size_p_adj = param['MaxPower']\\n n_bat = param['BatteryEfficiency']\\n n_inv = param['InverterEfficiency']\\n timestep = param['timestep']\\n # We work with np.ndarrays as they are much faster than pd.Series\\n Nsteps = len(pv)\\n LevelOfCharge = np.zeros(Nsteps)\\n #inv2grid = np.zeros(Nsteps)\\n inv_array=np.tile(inv_size/n_inv,len(pv))\\n pv2store = np.zeros(Nsteps)\\n store2inv = np.zeros(Nsteps)\\n inv2curt = np.zeros(Nsteps)\\n flagsell = np.zeros(Nsteps)\\n flag_12h = np.zeros(Nsteps)\\n store2grid = np.zeros(Nsteps)\\n store2load = np.zeros(Nsteps)\\n #grid2store = np.zeros(Nsteps) # TODO Always zero for now.\\n\\n #Load served by PV\\n pv2load_dc = np.array([pv, demand / n_inv,inv_array]).min(axis=0) # DC direct self-consumption, with inverter limitation\\n\\n #Residual load\\n res_load = demand - (pv2load_dc * n_inv) # AC\\n inv2load = pv2load_dc * n_inv # AC\\n\\n #Excess PV\\n res_pv = pv-pv2load_dc # DC\\n\\n #PV to storage after eff losses\\n pv2inv = pv2load_dc*n_inv # AC\\n\\n #first timestep = 0\\n LevelOfCharge[0] = 0 # bat_size_e_adj / 2 # DC\\n\\n\\n for i in range(1,Nsteps):\\n #PV to storage\\n if LevelOfCharge[i-1] >= bat_size_e_adj: # if battery is full\\n pv2store[i] = 0\\n else: #if battery is not full\\n\\n if LevelOfCharge[i-1] + res_pv[i] * n_bat * timestep > bat_size_e_adj: # if battery will be full after putting excess\\n pv2store[i] = min((bat_size_e_adj - LevelOfCharge[i-1]) / timestep, bat_size_p_adj)\\n else:\\n # pv2store[i] = min(res_pv[i], bat_size_p_adj)\\n pv2store[i] = min(res_pv[i] * n_bat, bat_size_p_adj)\\n #Storage to load\\n if pv2store[i]==0:# modification to original algorithm (The battery cannot charge and discharge at the same time)\\n store2inv[i] = min(bat_size_p_adj,(inv_size/n_inv-pv2load_dc[i]), # DC\\n res_load[i] / n_inv,\\n LevelOfCharge[i-1] / timestep) #modif to original, store2inv=pv2store*n_bat\\n\\n #SOC\\n LevelOfCharge[i] = min(LevelOfCharge[i-1] - (store2inv[i] - pv2store[i]*n_bat ) * timestep, # DC\\n bat_size_e_adj)#modif to original, store2inv=pv2store*n_bat\\n\\n pv2grid_dc=np.array([pv-pv2store,inv_array]).min(axis=0)-pv2load_dc # DC\\n pv2inv= (pv2grid_dc+pv2load_dc)*n_inv # AC\\n inv2curt=pv-pv2grid_dc-pv2load_dc-pv2store # DC\\n\\n inv2load = (pv2load_dc + store2inv) * n_inv # AC\\n inv2grid = pv2grid_dc * n_inv # AC\\n grid2load = demand - inv2load # AC\\n #MaxDischarge = np.minimum(LevelOfCharge[i-1]*BatteryEfficiency/timestep,MaxPower)\\n batt_losses=pv2store*(1-n_bat)\\n inv_losses=(pv2grid_dc+pv2load_dc+store2inv)*(1-n_inv)\\n #Potential Grid to storage # TODO: not an option for now in this strategy\\n # GridPurchase = False\\n \\n out = { 'pv2inv': pv2inv, # AC\\n 'res_pv':res_pv, # DC\\n 'pv2store': pv2store, # DC\\n 'inv2load': inv2load, # AC\\n 'grid2load': grid2load, # AC\\n 'store2inv': store2inv, # DC\\n 'inv2curt':inv2curt, # DC\\n 'LevelOfCharge': LevelOfCharge, # kWh\\n 'inv2grid': inv2grid, #AC \\n 'inv_losses':inv_losses,\\n 'batt_losses':batt_losses,\\n 'flag_sell':flagsell,\\n 'flag_12h':flag_12h, \\n 'store2grid':store2grid,\\n 'store2load':store2inv*n_inv\\n }\\n if not return_series:\\n out_pd = {}\\n for k, v in out.items(): # Create dictionary of pandas series with same index as the input pv\\n out_pd[k] = pd.Series(v, index=pv.index)\\n out = out_pd\\n return out\",\n \"def americanprice(self):\\n self.americanpay = np.zeros((self.steps+1,self.steps+1))\\n self.optionvalue = np.zeros((self.steps+1,self.steps+1))\\n self.exercisevalue = np.zeros((self.steps+1,self.steps+1))\\n self.americanpay[-1,:] = np.array( list( map(lambda x:max(x-self.s,0.0),self.pricetree[-1,:]) ) )\\n discount = math.exp( self.r*self.deltatime )\\n for i in range(self.steps,0,-1):\\n for j in range(i):\\n self.optionvalue[i-1][j] = (self.americanpay[i][j]*self.upprob + self.americanpay[i][j+1]*(1-self.upprob))/discount\\n self.exercisevalue[i-1][j] = max(self.pricetree[i-1][j]-self.s,0.0)\\n self.americanpay[i-1][j] = max(self.optionvalue[i-1][j],self.exercisevalue[i-1][j])\\n return self.americanpay[0][0]\",\n \"def value(self,pt,eta,mode):\\n \\n self._eta_range= get_eta_key(eta)+'_2012B'\\n self._pt_range= get_pt_key(pt)\\n\\n if mode == '0' :\\n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['efficiency'] \\n elif mode == '+1' :\\n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['err_hi']\\n elif mode == '-1' : \\n return self._map['DoubleMu17Mu8_Mu17_Tight'][self._eta_range][self._pt_range]['data']['err_low']\\n else: \\n print 'ERROR: wrong \\\\'mode\\\\' specified: try \\\\'0\\\\',\\\\'+1\\\\' or \\\\'-1\\\\''\\n return 0\",\n \"def kA_func(self):\\n\\n i1 = self.inl[0].to_flow()\\n i2 = self.inl[1].to_flow()\\n o1 = self.outl[0].to_flow()\\n o2 = self.outl[1].to_flow()\\n\\n T_i1 = T_bp_p(i1)\\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\\n\\n if T_i1 <= T_o2 and not self.inl[0].T.val_set:\\n T_i1 = T_o2 + 0.5\\n if T_i1 <= T_o2 and not self.outl[1].T.val_set:\\n T_o2 = T_i1 - 0.5\\n\\n if T_o1 <= T_i2 and not self.outl[0].T.val_set:\\n T_o1 = T_i2 + 1\\n if T_o1 <= T_i2 and not self.inl[1].T.val_set:\\n T_i2 = T_o1 - 1\\n\\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\\n\\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log\",\n \"def compute_actual_value(solution, actual_shows,id_to_group,group_to_ids, wtc,otc,itc,gapc, n_slots):\\n \\n # first convert to schedule format\\n schedule = [[] for i in range(n_slots)]\\n tot_shows = 0\\n for p in range(len(solution)):\\n if actual_shows[p] == 0:\\n continue\\n slot_p = solution[p]\\n tot_shows+=1\\n schedule[slot_p].append(p)\\n #print(schedule)\\n\\n # if tot_shows == 0:\\n # return 0, 0, 0,0,[np.nan for i in range(len(solution))]\\n\\n # then, for each slot, calculate the queue, etc\\n tot_w = 0 # total waiting time over all slots and patients\\n tot_it = 0 # total idle time\\n queue = []\\n wts = [0 for i in range(len(solution))]\\n for i in range(n_slots):\\n if len(queue) + len(schedule[i]) < 0.001:\\n tot_it += 1 * itc\\n # patients arrive\\n queue.extend(schedule[i])\\n # one patient is seen\\n if len(queue) > 0:\\n queue.pop(0)\\n # whoever is in queue, pays wt\\n for p in queue:\\n wts[p] += 1 \\n tot_w += len(queue) * wtc\\n tot_ot = len(queue) * otc\\n remaining_patients = len(queue)\\n for i in range(0,remaining_patients):\\n queue.pop(0)\\n for p in queue:\\n wts[p] += 1 \\n tot_w += len(queue) * wtc\\n #print(f'wtc = {tot_w}, otc = {tot_ot}')\\n\\n for p in range(len(solution)):\\n if actual_shows[p] == 0:\\n wts[p] = np.nan\\n # for each group of patient in the same slot, divide their waiting time\\n for slot in range(len(schedule)):\\n sum_wt_in_slot = 0\\n shows_in_slot = 0\\n for p in schedule[slot]:\\n if actual_shows[p]:\\n sum_wt_in_slot += wts[p]\\n shows_in_slot += 1\\n for p in schedule[slot]:\\n if actual_shows[p]:\\n wts[p] = sum_wt_in_slot / shows_in_slot\\n \\n tot_cost = tot_ot + tot_w + tot_it\\n return tot_cost, tot_w ,tot_ot, tot_it, wts\",\n \"def calc_annual_investment(devs, devs_dom, param):\\n\\n observation_time = param[\\\"observation_time\\\"]\\n interest_rate = param[\\\"interest_rate\\\"]\\n q = 1 + param[\\\"interest_rate\\\"]\\n\\n \\n\\n \\n # Calculate capital recovery factor\\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\\n\\n \\n # Balancing Unit devices\\n \\n # Calculate annuity factor for each device\\n for device in devs.keys():\\n \\n # Get device life time\\n life_time = devs[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF \\n else:\\n devs[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF \\n \\n \\n # Building devices\\n \\n for device in devs_dom.keys():\\n \\n # Get device life time\\n life_time = devs_dom[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs_dom[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF\\n else: \\n devs_dom[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF\\n \\n \\n # Distribution devices (pipes, pumps)\\n \\n for dev in [\\\"pipe\\\", \\\"pump\\\"]: #PUmpe fehlt noch\\n \\n # Get device life time\\n life_time = param[dev + \\\"_lifetime\\\"]\\n \\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n param[\\\"ann_factor_\\\" + dev] = (1 - res_value) * CRF \\n else:\\n param[\\\"ann_factor_\\\" + dev] = ( 1 + invest_replacements - res_value) * CRF \\n\\n return devs\",\n \"def LA_contribution(self):\\n pr=paraxial(self.entrance_pupil,0)\\n #hnu=-u*self.entrance_pupil #n=1\\n pr.propagate(self.surfaces)\\n #print('hnu',hnu,1/hnu)\\n #print('paraxial y ',pr.y[1:])\\n #print('paraxial nu',pr.nu[:-1])\\n #print('paraxial u ',pr.nu[:-1]/self.get_n()[:-1])\\n #print('paraxial u ',pr.nu[:-1]/self.get_n()[:-1]/hnu/5.715023)\\n #print('paraxial i ',pr.i[1:])\\n ni=self.get_n()[:-1]*pr.i[1:]\\n #print('ni',ni)\\n marginal=beam_field()\\n marginal.single_beam_from_Kingslake_Q(self.entrance_pupil,0) #marginal beam\\n marginal.propagate(self.surfaces)\\n Q=marginal.Kingslake_Qabs(self.surfaces)[:,0]\\n Q_=marginal.Kingslake_Q_abs(self.surfaces)[:,0]\\n #print('marginal Q ',marginal.Kingslake_Qabs(ls.surfaces)[:,0])\\n #print('marginal Q\\\\'',marginal.Kingslake_Q_abs(ls.surfaces)[:,0])\\n #print(Q-Q_)\\n #print('paraxial nu\\\\'',pr.nu[1:])\\n #print('sin Uk\\\\'',marginal.U)\\n target_surface=len(self.surfaces)-1\\n #print(marginal.U[3,0,1]*pr.nu[target_surface])\\n nusinU=marginal.U[3,0,1]*pr.nu[target_surface] #n'u'sinU'_k all values at end focus\\n LA=-(Q-Q_)*ni/nusinU\\n #print('spherical LA contribution',LA)\\n #print('sum',sum(LA))\\n return LA\",\n \"def cal_ja(Y,t,voltage_clamp_func,voltage_clamp_params):\\n v = voltage_clamp_func(t,voltage_clamp_params)\\n m = Y[0]\\n \\n tfa = 1.\\n ki = 0.001 # (mM)\\n \\n cao = 2.5 # Davidson (mM)\\n \\\" To do: make cai variable as an input like voltage \\\"\\n cai = 1.e-4 # (mM) Roughly values (100 nM) from Intracellular calcium regulation among subpopulations of rat dorsal root ganglion neurons by Lu, Zhang, Gold 2007\\n \\n celsius = 37.\\n \\n def alpha(v):\\n return 15.69*(81.5 - v)/(np.exp((-1.0*v+81.5)/10.0)-1.0)\\n def beta(v):\\n return 0.29*np.exp(-v/10.86)\\n def KTF(celsius):\\n return ((25./293.15)*(celsius + 273.15))\\n def efun(z):\\n return np.array([1 - i/2 if i < 1e-4 else i/(np.exp(i)-1) for i in z])\\n def calc_ghk(v, cai, cao): \\n f = KTF(celsius)/2\\n nu = v/f\\n return -f*(1. - (cai/cao)*np.exp(nu))*efun(nu)\\n\\n a = alpha(v)\\n b = beta(v)\\n tau = 1./(tfa*(a + b))\\n minf = a/(a+b)\\n dm = (minf - m)/tau\\n \\n \\\"\\\"\\\" Calculating the current \\n # h gate\\n h2 = ki/(ki+cai)\\n gcalbar = 0.003\\n ghk = calc_ghk(v,cai,cao)\\n ical = gcalbar*m*m*h2*ghk\\n \\\"\\\"\\\"\\n return [dm]\",\n \"def calcBeamplot(PALC_config, gamma_n, plt_ranges, f, dire_meas_LSA, dire_meas_deg):\\n # general\\n N = PALC_config.N\\n \\n########################## SIMULATION SETUP ###############################\\n # maximum of discrete mapping points:\\n max_points = 10000\\n # mesh\\n x_range = plt_ranges.p_x\\n y_range = plt_ranges.p_y\\n pts_x = max_points / (y_range[1]-y_range[0])\\n pts_y = max_points / (x_range[1]-x_range[0])\\n\\n x = np.linspace(x_range[0], x_range[1], num=int(pts_x+1))\\n y = np.linspace(y_range[0], y_range[1], num=int(pts_y+1))\\n\\n X, Y = np.meshgrid(x,y)\\n # get vertically array\\n x_vert = np.reshape(X, np.size(X))\\n y_vert = np.reshape(Y, np.size(Y))\\n z_vert = np.array([0])\\n\\n # reference pressure\\n p0 = 2 * 10**(-5)\\n # considered frequency\\n omega = 2 * np.pi * f\\n # initialize driving fct. and output array\\n D_opt_LSA = np.ones([N, 1])\\n P_LSA = np.zeros([np.shape(x_vert)[0],1], dtype=complex) \\n\\n # air attenuation\\n T = 293.15\\n p = 101.325 * 10**(3)\\n h = 50\\n alpha, c = AirAbsorptionCoefficient(f, T, p, h)\\n\\n # directivity\\n if PALC_config.directivity not in ['Measured Loudspeaker Data']:\\n dire_meas_LSA = np.ones([1,1])\\n dire_meas_deg = np.ones([1,1])\\n \\n ######################### SPL CALCULATION #################################\\n x_start, y_start, x_stop, y_stop, x_c_n, y_c_n, x_S, y_S = source_pos(gamma_n, PALC_config)\\n\\n G_LSA_vert = CalcGreenFunctions(x_vert, y_vert, z_vert, x_c_n, y_c_n, 0.82,\\\\\\n PALC_config.directivity, PALC_config.Lambda_y, \\\\\\n gamma_n, c, omega, 1, dire_meas_LSA, \\\\\\n dire_meas_deg, alpha, f, 0 )\\n\\n P_LSA[:,0] = G_LSA_vert @ D_opt_LSA[:,0]\\n\\n p_SPL = 20 * np.log10(np.abs(P_LSA) / p0)\\n \\n p_SPL = np.reshape(p_SPL, np.shape(X))\\n\\n return p_SPL, X, Y\",\n \"def minimum_remaining_values_with_degree(csp, ac_3=False):\\n assigned = list()\\n result = mrv_rec_backtracking(csp, assigned, csp.variables[:],True) \\n if result is False:\\n print \\\"fuck\\\"\\n return csp, assigned\",\n \"def calc_Cinv_CCGT(CC_size_W, CCGT_cost_data):\\n\\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\\n # capacity for the corresponding technology from the database\\n if CC_size_W < CCGT_cost_data['cap_min'][0]:\\n CC_size_W = CCGT_cost_data['cap_min'][0]\\n CCGT_cost_data = CCGT_cost_data[\\n (CCGT_cost_data['cap_min'] <= CC_size_W) & (CCGT_cost_data['cap_max'] > CC_size_W)]\\n\\n\\n #costs of connection\\n connection_costs = ngas.calc_Cinv_gas(CC_size_W)\\n\\n Inv_a = CCGT_cost_data.iloc[0]['a']\\n Inv_b = CCGT_cost_data.iloc[0]['b']\\n Inv_c = CCGT_cost_data.iloc[0]['c']\\n Inv_d = CCGT_cost_data.iloc[0]['d']\\n Inv_e = CCGT_cost_data.iloc[0]['e']\\n Inv_IR = CCGT_cost_data.iloc[0]['IR_%']\\n Inv_LT = CCGT_cost_data.iloc[0]['LT_yr']\\n Inv_OM = CCGT_cost_data.iloc[0]['O&M_%'] / 100\\n\\n InvC = Inv_a + Inv_b * (CC_size_W) ** Inv_c + (Inv_d + Inv_e * CC_size_W) * log(CC_size_W)\\n\\n Capex_a_CCGT_USD = calc_capex_annualized((InvC+connection_costs), Inv_IR, Inv_LT)\\n Opex_fixed_CCGT_USD = InvC * Inv_OM\\n Capex_CCGT_USD = InvC\\n\\n return Capex_a_CCGT_USD, Opex_fixed_CCGT_USD, Capex_CCGT_USD\",\n \"def dispatch_max_sc_bhv(pv, demand, bhv,prices_binned,inv_size,param , return_series=False, bins_soc=[0,33,66,100],bins_price=[0.04,0.12,0.20,0.28],kW_dis=4):\\n \\n bat_size_e_adj = param['BatteryCapacity']\\n bat_size_p_adj = param['MaxPower']\\n n_bat = param['BatteryEfficiency']\\n n_inv = param['InverterEfficiency']\\n timestep = param['timestep']\\n # We work with np.ndarrays as they are much faster than pd.Series\\n Nsteps = len(pv)\\n LevelOfCharge = np.zeros(Nsteps)\\n inv2grid = np.zeros(Nsteps)\\n inv_array=np.tile(inv_size/n_inv,len(pv))\\n pv2store = np.zeros(Nsteps)\\n store2inv = np.zeros(Nsteps)\\n inv2curt = np.zeros(Nsteps)\\n \\n flagsell = np.zeros(Nsteps)\\n store2load = np.zeros(Nsteps)\\n store2grid = np.zeros(Nsteps)\\n flag_12h=np.full((Nsteps), False)\\n #grid2store = np.zeros(Nsteps) # TODO Always zero for now.\\n \\n #Load served by PV\\n pv2load_dc = np.array([pv, demand / n_inv,inv_array]).min(axis=0) # DC direct self-consumption, with inverter limitation\\n\\n #Residual load\\n res_load = demand - (pv2load_dc * n_inv) # AC\\n inv2load = pv2load_dc * n_inv # AC\\n\\n #Excess PV\\n res_pv = pv-pv2load_dc # DC\\n\\n #PV to storage after eff losses\\n pv2inv = pv2load_dc*n_inv # AC\\n\\n #first timestep = 0\\n LevelOfCharge[0] = 0 # bat_size_e_adj / 2 # DC\\n\\n #get the sp hours\\n delta=dt.timedelta(hours=12)\\n sp_hour=res_pv.ne(0).groupby([res_pv.index.month,res_pv.index.day]).idxmax().droplevel(1).reset_index(drop=True)\\n twelve_bf=sp_hour-delta\\n\\n for i in range(1,Nsteps): \\n #PV to storage\\n if LevelOfCharge[i-1] >= bat_size_e_adj: # if battery is full\\n pv2store[i] = 0\\n else: #if battery is not full\\n if LevelOfCharge[i-1] + res_pv[i] * n_bat * timestep > bat_size_e_adj: # if battery will be full after putting excess\\n pv2store[i] = min((bat_size_e_adj - LevelOfCharge[i-1]) / timestep, bat_size_p_adj)\\n else:\\n# pv2store[i] = min(res_pv[i], bat_size_p_adj)\\n pv2store[i] = min(res_pv[i] * n_bat, bat_size_p_adj)\\n #Storage to load\\n if (pv2store[i]==0)&(res_pv[i]==0): \\n #According to prosumer behaviour the battery will inject into the community or not only if there is not PV suplus\\n store2load[i] = min(bat_size_p_adj,(inv_size/n_inv-pv2load_dc[i]), #Power\\n res_load[i] / n_inv, #Power\\n LevelOfCharge[i-1] / timestep) # Power; all in DC\\n if (pv.index[i]<=sp_hour[int(np.floor((i)/96))]) & (pv.index[i]>twelve_bf[int(np.floor((i)/96))]):\\n #if timestep is between twelve hours before and the surplus hour\\n try:\\n flag_12h[i]=True\\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\\n (bhv.SOC_binned==np.digitize(LevelOfCharge[i-1],bins=bins_soc))&\\n (bhv.surplus_time=='12h'),'sell'].values):#if sell\\n #surplus_time==12h\\n # sell 1 kWh of energy to the community and cover residual load if excess\\n #print('12hsell')\\n flagsell[i]=1\\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\\n kW_dis / n_inv, #Power\\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\\n\\n # here should take into account whether the prosumer desires to sell or not according to his preferences (SOC,price)\\n else: # no sell then cover only res_load\\n #print('out12h')\\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\\n except Exception as e:\\n # Ugly but provisional SOC bin from 0 to 1\\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\\n (bhv.SOC_binned==1)&\\n (bhv.surplus_time=='12h'),'sell'].values):#if sell\\n #surplus_time==12h\\n # sell 1 kWh of energy to the community and cover residual load if excess\\n #print('12hsell')\\n flagsell[i]=1\\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\\n kW_dis / n_inv, #Power\\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\\n else: # no sell then cover only res_load\\n #print('out12h')\\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\\n \\n else: \\n try:\\n \\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\\n (bhv.SOC_binned==np.digitize(LevelOfCharge[i-1],bins=bins_soc))&\\n (bhv.surplus_time=='12h+'),'sell'].values):#if sell\\n #surplus_time==12h+\\n # sell 1 kWh of energy to the community and cover residual load if excess \\n flagsell[i]=2\\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\\n kW_dis / n_inv, #Power\\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\\n\\n # here should take into account whether the prosumer desires to sell or not according to his preferences (SOC,price)\\n else: # no sell then cover only res_load\\n #print('out12h+')\\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\\n except Exception as e:\\n # Ugly but provisional SOC bin from 0 to 1\\n if np.array(bhv.loc[(bhv.Price_binned==prices_binned[i])&\\n (bhv.SOC_binned==1)&\\n (bhv.surplus_time=='12h+'),'sell'].values):#if sell\\n #surplus_time==12h\\n # sell 1 kWh of energy to the community and cover residual load if excess\\n #print('12hsell')\\n flagsell[i]=1\\n store2grid[i] = min(bat_size_p_adj-store2load[i],(inv_size/n_inv-pv2load_dc[i]-store2load[i]), #Power\\n kW_dis / n_inv, #Power\\n (LevelOfCharge[i-1]) / timestep-store2load[i])# Power; all in DC\\n store2inv[i] = (store2load[i]+store2grid[i]) # DC\\n else: # no sell then cover only res_load\\n #print('out12h')\\n store2inv[i] = (store2load[i]+store2grid[i]) #DC\\n #SOC\\n LevelOfCharge[i] = min(LevelOfCharge[i-1] - (store2inv[i] - pv2store[i]*n_bat ) * timestep, # DC\\n bat_size_e_adj)#modif to original, store2inv=pv2store*n_bat\\n\\n pv2grid_dc=np.array([pv-pv2store,inv_array]).min(axis=0)-pv2load_dc # DC\\n pv2inv= (pv2grid_dc+pv2load_dc)*n_inv # AC\\n inv2curt=pv-pv2grid_dc-pv2load_dc-pv2store # DC\\n\\n inv2load = (pv2load_dc + store2load) * n_inv # AC\\n inv2grid = (pv2grid_dc+store2grid) * n_inv # AC\\n grid2load = demand - inv2load # AC\\n #MaxDischarge = np.minimum(LevelOfCharge[i-1]*BatteryEfficiency/timestep,MaxPower)\\n batt_losses=pv2store*(1-n_bat)\\n inv_losses=(pv2grid_dc+pv2load_dc+store2inv)*(1-n_inv)\\n \\n out = {'pv2inv': pv2inv, # AC\\n 'res_pv':res_pv, # DC\\n 'pv2store': pv2store, # DC\\n 'inv2load': inv2load, # AC\\n 'grid2load': grid2load, # AC\\n 'store2inv': store2inv, # DC\\n 'inv2curt':inv2curt, # DC\\n 'LevelOfCharge': LevelOfCharge, # kWh\\n 'inv2grid': inv2grid, # AC\\n 'inv_losses':inv_losses,\\n 'batt_losses':batt_losses,\\n 'flag_sell':flagsell,\\n 'flag_12h':flag_12h, \\n 'store2grid':store2grid*n_inv, # AC\\n 'store2load':store2load*n_inv # AC\\n \\n }\\n if not return_series:\\n out_pd = {}\\n for k, v in out.items(): # Create dictionary of pandas series with same index as the input pv\\n out_pd[k] = pd.Series(v, index=pv.index)\\n out = out_pd\\n \\n return out\",\n \"def _determine_next_eval_point(self):\\n anc_data = self._get_ancillary_data_for_acquisition()\\n acq_to_use = getattr(acquisitions.asy, self.options.acq.lower())\\n next_eval_point = acq_to_use(self.gp, self.acq_optimise, anc_data)\\n return next_eval_point\",\n \"def eta_details(self):\\n\\t\\t# Experimentation gives you 72pts to a random science every production\\n\\t\\t# Stupid brute force implementation for now\\n\\t\\trequired = self.required\\n\\t\\trate = self.player.science\\n\\t\\tdef combine(base, add, add_time, chance):\\n\\t\\t\\t# add given add into base with +add_time tick and modified by chance\\n\\t\\t\\tfor time, p in add.items():\\n\\t\\t\\t\\ttime += add_time\\n\\t\\t\\t\\tp *= chance\\n\\t\\t\\t\\tbase[time] = base.get(time, 0) + p\\n\\t\\tdef _eta_details(value, time_to_prod=self.galaxy.production_rate):\\n\\t\\t\\tnaive_eta = max(0, int(math.ceil((required - value)/rate)))\\n\\t\\t\\tif naive_eta <= time_to_prod: return {naive_eta: 1}\\n\\t\\t\\tbase = {}\\n\\t\\t\\twithout_extra = _eta_details(value + rate*time_to_prod)\\n\\t\\t\\twith_extra = _eta_details(value + rate*time_to_prod + 72)\\n\\t\\t\\tcombine(base, without_extra, time_to_prod, 6/7.)\\n\\t\\t\\tcombine(base, with_extra, time_to_prod, 1/7.)\\n\\t\\t\\treturn base\\n\\t\\treturn _eta_details(self.current, self.galaxy.production_rate - self.galaxy.production_counter)\",\n \"def solve_retired(\\n assets_this_period,\\n assets_next_period,\\n interest_rate,\\n pension_benefit,\\n beta,\\n gamma,\\n sigma,\\n neg,\\n continuation_value,\\n survival_rate,\\n):\\n # Consumption\\n consumption = get_consumption(\\n assets_this_period=assets_this_period,\\n assets_next_period=assets_next_period,\\n pension_benefit=pension_benefit,\\n labor_input=np.float64(0.0),\\n interest_rate=interest_rate,\\n wage_rate=np.float64(0.0),\\n income_tax_rate=np.float64(0.0),\\n productivity=np.float64(0.0),\\n efficiency=np.float64(0.0),\\n )\\n\\n # Flow utility\\n flow_utility = util(\\n consumption=consumption,\\n labor_input=np.float64(0.0),\\n hc_effort=np.float64(0.0),\\n gamma=gamma,\\n sigma=sigma,\\n )\\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\\n\\n # Calculate value on meshes (i.e. for all choices)\\n value_full = flow_utility + beta * survival_rate * continuation_value\\n\\n # Derive optimal policies and store value function given optimal choices\\n policy_capital_retired_tmp = np.argmax(value_full, axis=1)\\n value_retired_tmp = np.max(value_full, axis=1)\\n\\n return value_retired_tmp, policy_capital_retired_tmp\",\n \"def compute_port_val(allocs, prices):\\n # normalized price\\n # normalized prices\\n normed = prices/prices.iloc[0]\\n prices.head()\\n alloced = normed * allocs\\n\\n # position values\\n start_val = 1 # included to simplify adding ability to calc as $\\n pos_vals = alloced * start_val\\n\\n # portfolio value\\n port_val = pos_vals.sum(axis=1)\\n\\n return port_val\",\n \"def solve_working(\\n assets_this_period,\\n assets_next_period,\\n hc_this_period,\\n hc_next_period,\\n interest_rate,\\n wage_rate,\\n income_tax_rate,\\n beta,\\n gamma,\\n sigma,\\n neg,\\n continuation_value,\\n delta_hc,\\n zeta,\\n psi,\\n n_gridpoints_capital,\\n n_gridpoints_hc,\\n efficiency,\\n survival_rate,\\n):\\n # Initialize objects\\n policy_labor_working_tmp = np.zeros(\\n (n_gridpoints_capital, n_gridpoints_hc), dtype=np.float64\\n )\\n\\n # Implied hc effort\\n hc_effort = get_hc_effort(\\n hc_this_period=hc_this_period,\\n hc_next_period=hc_next_period,\\n zeta=zeta,\\n psi=psi,\\n delta_hc=delta_hc,\\n )\\n\\n hc_effort = np.where(np.isnan(hc_effort), 0.0, hc_effort)\\n\\n # Implied labor supply\\n labor_input = 1 - hc_effort\\n\\n # Consumption\\n consumption = get_consumption(\\n assets_this_period=assets_this_period,\\n assets_next_period=assets_next_period,\\n pension_benefit=np.float64(0.0),\\n labor_input=labor_input,\\n interest_rate=interest_rate,\\n wage_rate=wage_rate,\\n income_tax_rate=income_tax_rate,\\n productivity=hc_this_period,\\n efficiency=efficiency,\\n )\\n\\n # Flow utility\\n flow_utility = util(\\n consumption=consumption,\\n labor_input=labor_input,\\n hc_effort=hc_effort,\\n gamma=gamma,\\n sigma=sigma,\\n )\\n\\n flow_utility = np.where(consumption < 0.0, neg, flow_utility)\\n flow_utility = np.where(hc_effort > 1.0, neg, flow_utility)\\n\\n # Value function on the complete mesh (i.e. for all possible choices)\\n value_full = flow_utility + beta * survival_rate * continuation_value\\n\\n # Derive optimal policies and store value function given optimal choices\\n policy_capital_working_tmp = np.argmax(np.max(value_full, axis=3), axis=1)\\n policy_hc_working_tmp = np.argmax(np.max(value_full, axis=1), axis=2)\\n value_working_tmp = np.max(np.max(value_full, axis=3), axis=1)\\n for assets_this_period_idx in range(n_gridpoints_capital):\\n for hc_this_period_idx in range(n_gridpoints_hc):\\n assets_next_period_idx = policy_capital_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n hc_next_period_idx = policy_hc_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ]\\n policy_labor_working_tmp[\\n assets_this_period_idx, hc_this_period_idx\\n ] = labor_input[\\n assets_this_period_idx,\\n assets_next_period_idx,\\n hc_this_period_idx,\\n hc_next_period_idx,\\n ]\\n\\n return (\\n policy_capital_working_tmp,\\n policy_hc_working_tmp,\\n policy_labor_working_tmp,\\n value_working_tmp,\\n )\",\n \"def obj(k_next) : \\n \\n if method==1 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\\n elif method==2 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\\n elif method==3 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\\n \\n return value_vec\",\n \"def call_option_value(x_s, x_y, tau_y, x_sigma, m_moneyness, tau_implvol,\\n k_strk, t_end, t_hor):\\n\\n x_sigma = x_sigma.reshape(-1)\\n\\n # Step 1: Compute time to expiry of the call option at thor\\n\\n tau = np.busday_count(t_hor, t_end)/252\\n\\n # Step 2: Compute value of the underlying\\n\\n s = np.exp(x_s)\\n\\n # Step 3: Compute m moneyness\\n\\n m = np.log(s/k_strk)/np.sqrt(tau)\\n\\n # Step 4: Compute shadow yield\\n\\n if x_y.shape[0] == 1:\\n x_y_interp = x_y\\n else:\\n interp = sp.interpolate.interp1d(tau_y.flatten(), x_y, axis=1,\\n fill_value='extrapolate')\\n x_y_interp = interp(tau)\\n\\n # Step 5: Compute discount rate\\n\\n y = shadowrates_ytm(x_y_interp)\\n\\n # Step 6: Compute log-implied volatility in point (m, tau)\\n\\n points = list(zip(*[grid.flatten() for grid in\\n np.meshgrid(*[tau_implvol, m_moneyness])]))\\n m_e = min(max(m, min(m_moneyness)), max(m_moneyness)) # extrapolation\\n tau_e = min(max(tau, tau_implvol[0]), tau_implvol[-1]) # extrapolation\\n x_sigma_interp = \\\\\\n interpolate.LinearNDInterpolator(points, x_sigma)(*np.r_[tau_e, m_e])\\n\\n # Step 7: Compute implied volatility\\n\\n sigma_interp = np.exp(x_sigma_interp)\\n\\n # Step 8: Compute call option value\\n\\n v = bsm_function(s, y, sigma_interp, m, tau)\\n\\n return v\",\n \"def find_allocation_for_graph(self,consumption_graph : ConsumptionGraph):\\n mat = cvxpy.Variable((self.num_of_agents, self.num_of_items))\\n constraints = []\\n # every var >=0 and if there is no edge the var is zero\\n # and proportional condition\\n for i in range(self.num_of_agents):\\n count = 0\\n for j in range(self.num_of_items):\\n if (consumption_graph.get_graph()[i][j] == 0):\\n constraints.append(mat[i][j] == 0)\\n else:\\n constraints.append(mat[i][j] >= 0)\\n count += mat[i][j] * self.valuation[i][j]\\n constraints.append(count >= sum(self.valuation[i]) / len(self.valuation))\\n # the sum of each column is 1 (the property on each object is 100%)\\n for i in range(self.num_of_items):\\n constraints.append(sum(mat[:, i]) == 1)\\n \\\"\\\"\\\"\\n # the proportional condition\\n count = 0\\n for i in range(len(consumption_graph)):\\n count = 0\\n for j in range(len(consumption_graph[i])):\\n count += mat[i][j] * matv[i][j]\\n constraints.append(count >= sum(matv[i]) / len(matv[i]))\\n \\\"\\\"\\\"\\n objective = cvxpy.Maximize(1)\\n prob = cvxpy.Problem(objective, constraints)\\n prob.solve() # Returns the optimal value.\\n if not (prob.status == 'infeasible'):\\n alloc = Allocation(mat.value)\\n alloc.round()\\n if(alloc.num_of_shering() < self.min_sharing_number):\\n self.min_sharing_number = alloc.num_of_shering()\\n self.min_sharing_allocation = alloc.get_allocation()\\n # only for doctet:\\n return (mat.value)\",\n \"def ecg_diagnose(apn):\\n # Total minutes of apnea\\n apnea_total = sum(apn)\\n\\n # Maximum hourly Apnea Index\\n total_hour = int(len(apn) / 60)\\n y_pred_hourly = np.reshape(apn[: total_hour * 60], (total_hour, 60))\\n AI_hourly = y_pred_hourly.sum(axis=1)\\n # If data in the last hour exceed 30 minutes, then convert to hourly result\\n y_pred_left = apn[total_hour * 60 :]\\n # if len(y_pred_left) >= 30:\\n # AI_hourly = np.append(AI_hourly, sum(y_pred_left) * 60 / len(y_pred_left))\\n # total_hour += 1\\n AI_max = AI_hourly.max()\\n\\n if AI_max >= 10 and apnea_total >= 100:\\n return \\\"A\\\"\\n elif AI_max >= 5 and apnea_total >= 5:\\n return \\\"B\\\"\\n else:\\n return \\\"C\\\"\",\n \"def hrc_gain_fit_gaus(c_input):\\n#\\n#--- if an obsid is provided, analyize that, else get new obsids from databases\\n#\\n\\n if mcf.chkNumeric(c_input):\\n candidate_list = [c_input]\\n else:\\n candidate_list = arlist.hrc_gain_find_ar_lac()\\n\\n if len(candidate_list) > 0:\\n for obsid in candidate_list:\\n file = extract_hrc_evt2(obsid)\\n if file == 'na':\\n continue\\n#\\n#--- get a file name header for the later use\\n#\\n temp = re.split('N', file)\\n hname = temp[0]\\n#\\n#--- extract information from the fits file header\\n#\\n [obsid, detnam, date_obs, date_end, tstart, tstop, ra_pnt, dec_pnt, ra_nom, dec_nom, roll_pnt, foc_len, defocus, sim_x, sim_y, sim_z] = find_header_info(file)\\n#\\n#--- find the diffrence between real AR Lac position and nominal postion so that we can determin how much area we should include \\n#\\n ra_diff = abs(ra - ra_nom) * 60.0\\n dec_diff = abs(dec - dec_nom) * 60.0\\n rad_diff = math.sqrt(ra_diff * ra_diff + dec_diff * dec_diff)\\n\\n if rad_diff < 10.0:\\n fit_rad = 60.0\\n else:\\n fit_rad = 200.0\\n#\\n#--- find a location of the brightest object (assume it is AR Lac) in sky coordinates\\n#\\n [x, y] = find_center(file)\\n#\\n#--- extract pha values in the given area\\n#\\n pha = extract_pha(file, x, y, fit_rad)\\n#\\n#--- create pha count distribution\\n#\\n pmax = max(pha) + 1\\n pha_bin = [x for x in range(0, pmax)]\\n pha_hist = [0 for x in range(0, pmax)]\\n\\n for ent in pha:\\n pha_hist[ent] += 1\\n#\\n#--- print out the distirbution results\\n#\\n outfile = data_dir + hname + '_pha.dat'\\n fo = open(outfile, 'w')\\n for i in range(0, pmax):\\n line = str(pha_bin[i]) + '\\\\t' + str(pha_hist[i]) + '\\\\n'\\n fo.write(line)\\n fo.close()\\n#\\n#--- find median point\\n#\\n med = find_med(pha_hist)\\n#\\n#--- fit a normal distribution on the data\\n#\\n [amp, center, width] = fit_gauss(pha_bin, pha_hist)\\n#\\n#--- print out the fitting result\\n#\\n outfile = house_keeping + 'fitting_results'\\n\\n copied_file = outfile + '~'\\n cmd = 'cp ' + outfile + ' ' + copied_file\\n os.system(cmd)\\n\\n fo = open(outfile, 'a')\\n line = str(obsid) + '\\\\t' + date_obs + '\\\\t' + str(tstart) + '\\\\t' + detnam + '\\\\t' + str(ra_pnt) + '\\\\t' + str(dec_pnt) + '\\\\t\\\\t'\\n line = line + str(round(ra_diff,3)) + '\\\\t' + str(round(dec_diff, 3)) + '\\\\t' + str(round(rad_diff,3)) + '\\\\t' + str(med) + '\\\\t\\\\t'\\n line = line + str(round(center, 3)) + '\\\\t' + str(round(amp, 3)) + '\\\\t' + str(round(width, 3)) + '\\\\t'\\n line = line + str(roll_pnt) + '\\\\t' + str(foc_len) + '\\\\t' + str(defocus) + '\\\\t'\\n line = line + str(sim_x) + '\\\\t' + str(sim_y) + '\\\\t' + str(sim_z) + '\\\\n'\\n fo.write(line)\\n fo.close()\\n#\\n#--- plot the data\\n#\\n outfile = plot_dir + hname + '_gfit.png'\\n plot_gauss(pha_bin, pha_hist, amp, center, width, file, outfile)\\n#\\n#--- remove the evt2 file\\n#\\n mcf.rm_file(file)\",\n \"def calc_annual_electric_savings (self):\\n costs = self.comp_specs['diesel generator o&m']\\n\\n for kW in costs.keys():\\n try:\\n if self.average_load < int(kW):\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n break\\n except ValueError:\\n maintenance = self.comp_specs['diesel generator o&m'][kW]\\n\\n self.baseline_generation_cost = maintenance + \\\\\\n (self.pre_intertie_generation_fuel_used * self.diesel_prices)\\n\\n maintenance = self.capital_costs * \\\\\\n (self.comp_specs['percent o&m'] / 100.0)\\n self.proposed_generation_cost = maintenance + \\\\\\n self.intertie_offset_generation_fuel_used * \\\\\\n self.intertie_diesel_prices\\n self.annual_electric_savings = self.baseline_generation_cost -\\\\\\n self.proposed_generation_cost\\n #~ print len(self.annual_electric_savings)\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def _calculate(self):\\n source = self.source\\n res = {}\\n l_cols = [[], [], [], []]\\n r_lines = {}\\n dateline=None\\n ###delete the below code when fetch data from database(assume: data in database has been pretreatment)\\n if source[t.ror].min() > -99.0:\\n pass\\n else:\\n source[t.ror] = np.where(\\n source[t.ror] > -99.0, source[t.ror], -99.0)\\n ###\\n for account in self.accounts:\\n source_account = source[source[t.account] == account]\\n source_account = source_account.reset_index(drop=True)\\n dateline=source_account[t.effective_date]\\n ror=source_account[t.ror]/100\\n returns_cum = ROR.ror_cum_ann(source_account, self.annualized)\\n # double_return_cum=round(double_return_cum,2)+1\\n returns_cum = returns_cum + 1\\n growth_amounts = returns_cum * self.starting_value\\n returns_cum, growth_amounts = round(returns_cum - 1, 4), \\\\\\n round(growth_amounts, 2)\\n l_cols[0].append(growth_amounts.iloc[-1, 0])#account growth amount\\n l_cols[1].append(growth_amounts.iloc[-1, 1])#bench growth amount\\n l_cols[2].append(returns_cum.iloc[-1, 0])#account return\\n l_cols[3].append(returns_cum.iloc[-1, 1])#bench return\\n r_lines[account] = [list(returns_cum.iloc[:,0]), list(growth_amounts.iloc[:, 0]),#list(returns_cum.iloc[:, 0])\\n list(growth_amounts.iloc[:, 1])]#account return, account growth amount, bench growth amount\\n res['account_vs_benchmark'] = {'xAxis': self.accounts,\\n 'series': l_cols}\\n res['growth_of_unit'] = {'xAxis': list(dateline),\\n 'series': r_lines}\\n return res\\n # ret_dict = self._ret(accounts, starting_value, source, annualized)\\n # return ret_dict\",\n \"def get_a(a_low=1.0e1, a_high=4.41e7, num_sys=1, alpha=-1.6, prob='log_flat'):\\n\\n if prob == 'log_flat':\\n C_a = 1.0 / (np.log(a_high) - np.log(a_low))\\n tmp_y = uniform(size=num_sys)\\n return a_low*np.exp(tmp_y/C_a)\\n\\n elif prob == 'raghavan':\\n mu_P_orb = 5.03\\n sigma_P_orb = 2.28\\n # Assume a system mass of 2 Msun\\n P_orb_low = np.log10(a_to_P(1.0, 1.0, a_low))\\n P_orb_high = np.log10(a_to_P(1.0, 1.0, a_high))\\n # Set limits for truncnorm\\n a, b = (P_orb_low - mu_P_orb) / sigma_P_orb, (P_orb_high - mu_P_orb) / sigma_P_orb\\n P_orb = 10.0**(truncnorm.rvs(a, b, loc=mu_P_orb, scale=sigma_P_orb, size=num_sys))\\n return P_to_a(1.0, 1.0, P_orb)\\n\\n elif prob == 'power_law':\\n if alpha == -1:\\n return get_a(a_low=a_low, a_high=a_high, num_sys=num_sys, prob='log_flat')\\n\\n # Scale so 50% of binaries have a > 100 AU\\n a_low, a_high = 100.0 * c.AU_to_cm / c.Rsun_to_cm, 4.41e7\\n C_a = 0.5 / (a_high**(alpha + 1.0) - a_low**(alpha + 1.0))\\n\\n a_low = ((4.41e7)**(alpha + 1.0) - 1.0 / C_a) ** (1.0 / (alpha + 1.0))\\n tmp_y = uniform(size=num_sys)\\n return (tmp_y/C_a + a_low**(alpha + 1.0))**(1.0/(alpha + 1.0))\\n\\n else:\\n print(\\\"You must provide a valid probability distribution\\\")\\n print(\\\"Options are 'log_flat', 'raghavan', or 'power_law'\\\")\\n return\",\n \"def get_ramp(x0,x1,vmax,a,dt, output='ramp only'):\\n # Insure we are dealing with floating point numbers\\n x0, x1 = float(x0), float(x1)\\n vmax, a = float(vmax), float(a)\\n dt = float(dt)\\n vmax, a = abs(vmax), abs(a) # Make sure that v_max and a are positive\\n\\n # Check to see if there is anything to do\\n if x0==x1:\\n return scipy.array([x0])\\n\\n # Get distance and sign indicating direction\\n dist = abs(x1-x0)\\n sign = scipy.sign(x1-x0)\\n\\n # Determine if we will reach v_max\\n t2vmax = vmax/a\\n t2halfdist = scipy.sqrt(0.5*dist/a)\\n \\n if t2vmax > t2halfdist:\\n # Trajectory w/o constant velocity segment \\n T = scipy.sqrt(dist/a)\\n n = int(scipy.round_((1.0/dt)*T))\\n \\n # Adjust accel and duration for rounding of n (discrete time steps)\\n a = dist/(n*dt)**2\\n T = scipy.sqrt(dist/a)\\n \\n # Generate trajectory\\n t = scipy.linspace(0.0,2.0*T,2*n+1)\\n def f1(t):\\n return 0.5*sign*a*(t**2)\\n def f2(t):\\n s = t-T\\n return f1(T)+ sign*a*T*s - 0.5*sign*a*s**2\\n func_list = [f1,f2]\\n cond_list = [t<=T, t>T]\\n ramp = x0+scipy.piecewise(t,cond_list,func_list)\\n \\n else:\\n # Trajectory w/ constant velocity segment\\n # Compute acceleration time and adjust acceleration\\n T1 = vmax/a \\n n = int(scipy.round_(T1/dt))\\n a = vmax/(n*dt) # Adjusted acceleration \\n T1 = vmax/a # Adjusted acceleration time \\n\\n # Compute and adjust constant velocity time\\n T2 = dist/vmax - T1 \\n m = int(scipy.round_(T2/dt))\\n vmax = dist/(dt*(n+m)) # Adjusted max velocity \\n T2 = dist/vmax - T1 # Adjusted constant velocity time\\n\\n # Generate trajectory\\n t = scipy.linspace(0.0,2.0*T1+T2,2*n+m+1)\\n def f1(t):\\n return 0.5*sign*a*(t**2)\\n def f2(t):\\n s = t-T1\\n return f1(T1) + sign*vmax*s\\n def f3(t):\\n s = t-T1-T2\\n return f2(T1+T2)+sign*vmax*s-0.5*sign*a*s**2 \\n func_list = [f1,f2,f3]\\n cond_list = [t<=T1, scipy.logical_and(t>T1,t<=T1+T2), t>T1+T2]\\n ramp = x0+scipy.piecewise(t,cond_list,func_list)\\n\\n if output=='ramp only':\\n return ramp\\n elif output=='full':\\n return ramp, vmax, a\\n else:\\n raise(ValueError, 'unknown keyword option output=%s'%(output,))\",\n \"def calculatedResults(meanReturns, covMatrix, riskFreeRate=0, constraintSet=(0,1)):\\n # Max Sharpe Ratio Portfolio\\n maxSR_Portfolio = maxSR(meanReturns, covMatrix)\\n maxSR_returns, maxSR_std = portfolioPerformance(maxSR_Portfolio['x'], meanReturns, covMatrix)\\n \\n maxSR_allocation = pd.DataFrame(maxSR_Portfolio['x'], index=meanReturns.index, columns=['allocation'])\\n maxSR_allocation.allocation = [round(i*100,0) for i in maxSR_allocation.allocation]\\n \\n # Min Volatility Portfolio\\n minVol_Portfolio = minimizeVariance(meanReturns, covMatrix)\\n minVol_returns, minVol_std = portfolioPerformance(minVol_Portfolio['x'], meanReturns, covMatrix)\\n \\n minVol_allocation = pd.DataFrame(minVol_Portfolio['x'], index=meanReturns.index, columns=['allocation'])\\n minVol_allocation.allocation = [round(i*100,0) for i in minVol_allocation.allocation]\\n\\n # Efficient Frontier\\n efficientList = []\\n targetReturns = np.linspace(minVol_returns, maxSR_returns, 20)\\n for target in targetReturns:\\n efficientList.append(efficientOpt(meanReturns, covMatrix, target)['fun'])\\n \\n maxSR_returns, maxSR_std = round(maxSR_returns*100,2), round(maxSR_std*100,2)\\n minVol_returns, minVol_std = round(minVol_returns*100,2), round(minVol_std*100,2)\\n \\n return maxSR_returns, maxSR_std, maxSR_allocation, minVol_returns, minVol_std, minVol_allocation, efficientList, targetReturns\",\n \"def calc_Cinv_boiler(Q_design_W, technology_type, boiler_cost_data):\\n Capex_a_Boiler_USD = 0.0\\n Opex_a_fix_Boiler_USD = 0.0\\n Capex_Boiler_USD = 0.0\\n\\n if Q_design_W > 0.0:\\n boiler_cost_data = boiler_cost_data[boiler_cost_data['code'] == technology_type]\\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\\n # capacity for the corresponding technology from the database\\n if Q_design_W < boiler_cost_data.iloc[0]['cap_min']:\\n Q_design_W = boiler_cost_data.iloc[0]['cap_min']\\n max_boiler_size = boiler_cost_data.iloc[0]['cap_max']\\n\\n if Q_design_W <= max_boiler_size:\\n\\n boiler_cost_data = boiler_cost_data[\\n (boiler_cost_data['cap_min'] <= Q_design_W) & (boiler_cost_data['cap_max'] > Q_design_W)]\\n\\n Inv_a = boiler_cost_data.iloc[0]['a']\\n Inv_b = boiler_cost_data.iloc[0]['b']\\n Inv_c = boiler_cost_data.iloc[0]['c']\\n Inv_d = boiler_cost_data.iloc[0]['d']\\n Inv_e = boiler_cost_data.iloc[0]['e']\\n Inv_IR = boiler_cost_data.iloc[0]['IR_%']\\n Inv_LT = boiler_cost_data.iloc[0]['LT_yr']\\n Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0\\n\\n InvC = Inv_a + Inv_b * (Q_design_W) ** Inv_c + (Inv_d + Inv_e * Q_design_W) * log(Q_design_W)\\n\\n Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\\n Opex_a_fix_Boiler_USD = InvC * Inv_OM\\n Capex_Boiler_USD = InvC\\n\\n else:\\n number_of_boilers = int(ceil(Q_design_W / max_boiler_size))\\n Q_nom_W = Q_design_W / number_of_boilers\\n\\n boiler_cost_data = boiler_cost_data[\\n (boiler_cost_data['cap_min'] <= Q_nom_W) & (boiler_cost_data['cap_max'] > Q_nom_W)]\\n\\n Inv_a = boiler_cost_data.iloc[0]['a']\\n Inv_b = boiler_cost_data.iloc[0]['b']\\n Inv_c = boiler_cost_data.iloc[0]['c']\\n Inv_d = boiler_cost_data.iloc[0]['d']\\n Inv_e = boiler_cost_data.iloc[0]['e']\\n Inv_IR = boiler_cost_data.iloc[0]['IR_%']\\n Inv_LT = boiler_cost_data.iloc[0]['LT_yr']\\n Inv_OM = boiler_cost_data.iloc[0]['O&M_%'] / 100.0\\n\\n InvC = (Inv_a + Inv_b * (Q_nom_W) ** Inv_c + (Inv_d + Inv_e * Q_nom_W) * log(Q_nom_W)) * number_of_boilers\\n\\n Capex_a_Boiler_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\\n Opex_a_fix_Boiler_USD = InvC * Inv_OM\\n Capex_Boiler_USD = InvC\\n\\n return Capex_a_Boiler_USD, Opex_a_fix_Boiler_USD, Capex_Boiler_USD\",\n \"def kA_func(self):\\n i1 = self.inl[0].to_flow()\\n i2 = self.inl[1].to_flow()\\n o1 = self.outl[0].to_flow()\\n o2 = self.outl[1].to_flow()\\n\\n T_i1 = T_mix_ph(i1, T0=self.inl[0].T.val_SI)\\n T_i2 = T_mix_ph(i2, T0=self.inl[1].T.val_SI)\\n T_o1 = T_mix_ph(o1, T0=self.outl[0].T.val_SI)\\n T_o2 = T_mix_ph(o2, T0=self.outl[1].T.val_SI)\\n\\n if T_i1 <= T_o2:\\n T_i1 = T_o2 + 0.01\\n if T_i1 <= T_o2:\\n T_o2 = T_i1 - 0.01\\n if T_i1 <= T_o2:\\n T_o1 = T_i2 + 0.02\\n if T_o1 <= T_i2:\\n T_i2 = T_o1 - 0.02\\n\\n td_log = ((T_o1 - T_i2 - T_i1 + T_o2) /\\n np.log((T_o1 - T_i2) / (T_i1 - T_o2)))\\n\\n return i1[0] * (o1[2] - i1[2]) + self.kA.val * td_log\",\n \"def _compute_from_table_values(\\n name=\\\"plant\\\", color=(0/255, 128/255, 0/255),\\n germination_time=(3, 1), \\n r_max=(1.0,1.0),\\n maturation_time=(10, 1),\\n stopping_color=(0, 0, 1),\\n color_step=(10/255, 0, 0),\\n c1=0.1,\\n r_0=0.04\\n ):\\n\\n c2 = 1\\n k1, k2 = 0.3, 0.7\\n unoccluded_c1 = c1 / k2\\n h_0 = 0.1\\n r_max = max(1, np.random.normal(MAX_RADIUS[name][0], MAX_RADIUS[name][1]))\\n # r_max = MAX_RADIUS[name][0] + MAX_RADIUS[name][1]\\n growth_time = generate_growth_time(germination_time, maturation_time, r_max, r_0, k2, c2)\\n\\n return {\\n \\\"germination_time\\\": germination_time,\\n \\\"maturation_time\\\": maturation_time,\\n \\\"k1\\\": k1,\\n \\\"k2\\\": k2,\\n \\\"c1\\\": unoccluded_c1,\\n \\\"c2\\\": c2,\\n \\\"start_radius\\\": r_0,\\n \\\"start_height\\\": h_0,\\n \\\"r_max\\\": r_max,\\n \\\"growth_time\\\": growth_time,\\n \\\"plant_type\\\": name,\\n \\\"color\\\": color,\\n \\\"stopping_color\\\": stopping_color,\\n \\\"color_step\\\": color_step\\n }\",\n \"def __init__(self, Asset_File, N, K, epsilon=0.01, delta=1.0):\\n self.Asset_File = Asset_File\\n self.N = N # Total number of assets in a dataset\\n self.K = K\\n self.epsilon = epsilon # Min investment\\n self.delta = delta # Max investment\\n self.number_of_stocks = 0\\n self.returns_deviations = []\\n self.correlations = []\\n self.covariance = np.nan\\n temp_li_1 = []\\n temp_li_2 = []\\n\\n # Splitting rows based on what they contain\\n with open('Datasets/{}'.format(Asset_File), newline='') as datafile:\\n for row in datafile:\\n if len(row.split()) == 1: # if row is len of 1 it will be number of assets\\n for x in row.split(' '):\\n if x == '':\\n continue\\n self.number_of_stocks = (int(x))\\n elif len(row.split()) == 2: # if row is len of 2 it will be the assets return and standard deviation\\n for x in row.split(' '):\\n if x == '':\\n continue\\n self.returns_deviations.append(float(x))\\n elif len(row.split()) == 3: # if row is len of 3 it will be the correlation between assets\\n for x in row.split(' '):\\n if x == '':\\n continue\\n self.correlations.append(float(x))\\n\\n # Variable for storing standard deviations of returns\\n for i, z in zip(self.returns_deviations[0::2], self.returns_deviations[1::2]):\\n temp_li_1.append([i, z])\\n self.returns_deviations = temp_li_1\\n\\n # Variable for storing correlations between assets\\n zeros = np.zeros((int(self.number_of_stocks), int(self.number_of_stocks)))\\n for x, y, z in zip(self.correlations[0::3], self.correlations[1::3], self.correlations[2::3]):\\n temp_li_2.append([x, y, z])\\n zeros[int(x)-1][int(y)-1] = z\\n self.correlations = temp_li_2\\n\\n # Creates a matrix of returns and deviations\\n self.returns_deviations = np.array(self.returns_deviations)\\n\\n # Splitting the data into variables needed for calculation\\n self.deviations = self.returns_deviations[:, 1]\\n self.mu = self.returns_deviations[:, 0]\\n self.covariance = zeros * self.deviations * self.deviations.reshape((self.deviations.shape[0], 1))\\n self.sigma = self.covariance + self.covariance.T - np.diag(self.covariance.diagonal()) #Fills in the second part of the covariance matrix\\n\\n # Making sure constraints on minimum and maximum investments are met\\n if K * epsilon > 1.0:\\n print(\\\"Minimum investment is too large\\\")\\n raise ValueError\\n if K * delta < 1.0:\\n print(\\\"Maximum investment is too small\\\")\\n raise ValueError\\n\\n self.F = 1.0 - K * epsilon\",\n \"def prada(self):\\n scale_factor = 1.0 / (1.0 + self.snapshot.header.redshift)\\n r200c_physical = self.r200c * scale_factor / 1000.0 # units Mpc\\n\\n v200 = (\\n (self.snapshot.const.G * self.m200c)\\n / r200c_physical\\n * self.snapshot.const.Mpc ** 2\\n / 1000.0 ** 2\\n ) ** 0.5 # units km/s\\n\\n def y(x, vmax, v200):\\n func = np.log(1 + x) - (x / (1 + x))\\n return ((0.216 * x) / func) ** 0.5 - (vmax / v200)\\n\\n concentration = np.zeros((len(self.vmax)))\\n for halo in range(self.N_halos):\\n if v200[halo] > self.vmax[halo]:\\n concentration[halo] = -9999.0\\n else:\\n try:\\n concentration[halo] = newton(\\n y, x0=5.0, args=(self.vmax[halo], v200[halo])\\n )\\n except:\\n concentration[halo] = -9999.0\\n\\n return concentration\",\n \"def alpha(SA, CT, p):\\n\\n SA = np.maximum(SA, 0)\\n\\n xs = np.sqrt(sfac * SA + soffset)\\n ys = CT * 0.025\\n z = p * 1e-4\\n\\n v_CT_part = (a000\\n + xs * (a100 + xs * (a200 + xs * (a300 + xs * (a400 + a500 * xs))))\\n + ys * (a010 + xs * (a110 + xs * (a210 + xs * (a310 + a410 * xs)))\\n + ys * (a020 + xs * (a120 + xs * (a220 + a320 * xs))\\n + ys * (a030 + xs * (a130 + a230 * xs)\\n + ys * (a040 + a140 * xs + a050 * ys))))\\n + z * (a001 + xs * (a101 + xs * (a201 + xs * (a301 + a401 * xs)))\\n + ys * (a011 + xs * (a111 + xs * (a211 + a311 * xs))\\n + ys * (a021 + xs * (a121 + a221 * xs)\\n + ys * (a031 + a131 * xs + a041 * ys)))\\n + z * (a002 + xs * (a102 + xs * (a202 + a302 * xs))\\n + ys * (a012 + xs * (a112 + a212 * xs)\\n + ys * (a022 + a122 * xs + a032 * ys))\\n + z * (a003 + a103 * xs + a013 * ys + a004 * z))))\\n\\n specific_volume = (v000\\n + xs * (v100 + xs * (v200 + xs * (v300 + xs * (v400 + xs * (v500\\n + xs * v600)))))\\n + ys * (v010\\n + xs * (v110 + xs * (v210 + xs * (v310 + xs * (v410 + xs * v510))))\\n + ys * (v020 + xs * (v120 + xs * (v220 + xs * (v320 + xs * v420)))\\n + ys * (v030 + xs * (v130 + xs * (v230 + xs * v330))\\n + ys * (v040 + xs * (v140 + xs * v240)\\n + ys * (v050 + xs * v150 + ys * v060)))))\\n + z * (v001\\n + xs * (v101 + xs * (v201 + xs * (v301 + xs * (v401 + xs * v501))))\\n + ys * (v011 + xs * (v111 + xs * (v211 + xs * (v311 + xs * v411)))\\n + ys * (v021 + xs * (v121 + xs * (v221 + xs * v321))\\n + ys * (v031 + xs * (v131 + xs * v231)\\n + ys * (v041 + xs * v141 + ys * v051))))\\n + z * (v002\\n + xs * (v102 + xs * (v202 + xs * (v302 + xs * v402)))\\n + ys * (v012 + xs * (v112 + xs * (v212 + xs * v312))\\n + ys * (v022 + xs * (v122 + xs * v222)\\n + ys * (v032 + xs * v132 + ys * v042)))\\n + z * (v003\\n + xs * (v103 + xs * v203)\\n + ys * (v013 + xs * v113 + ys * v023)\\n + z * (v004 + xs * v104 + ys * v014\\n + z * (v005 + z * v006))))))\\n\\n return 0.025 * v_CT_part / specific_volume\",\n \"def calAng(self, dates, values, angle_type):\\n print(\\\"Defining points running...\\\")\\n #Determining the type of extrema value to be calculated\\n if angle_type == \\\"max\\\":\\n type_k = \\\"max_k\\\"\\n elif angle_type == \\\"min\\\":\\n type_k = \\\"min_k\\\"\\n else:\\n raise NameError('Incorrect type as angle type')\\n return\\n\\n #Initial values\\n k, k_dates, k_points = self.calcDir(dates, values)\\n\\n #While there is a maximum left\\n while len(k_points) > 3:\\n idx, minima = self.extrema(k, type_k)\\n #When the function is done we need the most defining points \\n if len(idx) < 3:\\n k_points = [dir_points[0], dir_points[-1]]\\n k_dates = [dir_dates[0], dir_dates[-1]]\\n k, k_d, k_p = self.calcDir(k_dates, k_points)\\n break\\n dir_dates = [k_dates[i] for i in idx]\\n dir_points = [k_points[i] for i in idx]\\n k, k_dates, k_points = self.calcDir(dir_dates, dir_points)\\n print(\\\"Defining points done!\\\")\\n return k_dates, k_points, k[0]\",\n \"def penalty_calc(self):\\n self.p_budget = (self.tx_oma_min - self.rx_unstressed_sensitivity - self.fiber_conn_loss)*self.l_1\\n\\n # fiber attenuation,\\n self.p_atten = self.alpha*self.length # column B\\n\\n # calculate bandwidth for RIN test (exclude transmitter)\\n rin_inverse_bw = np.sqrt(np.square(1.0/self.bw_cd) + np.square(1.0/self.bw_md) + (0.477/(self.rx_bw**2))*self.l_1)\\n rin_bw = 1.0 / rin_inverse_bw\\n\\n # see FC-MSQS-2 equation B.47 in Annex B.4 for the following k_rin = math.sqrt(2.0/math.pi)*erfinv(0.8)\\n k_rin = 0.7\\n\\n # v_rin,\\n self.v_rin = (k_rin*1E6*(self.rin_test_isi**2)*rin_bw*\\n math.pow(10.0,0.1*self.rin)) # column AK\\n\\n # Prin,\\n print('v_rin: ', self.v_rin)\\n print('Q: ',self.Q)\\n print('isi_dj_refl_closed :', self.isi_dj_refl_closed)\\n self.p_rin = -10.0*np.log10(np.sqrt(1.0-np.multiply(self.v_rin, np.square(self.Q/self.isi_dj_refl_closed)))) # column R\\n print(\\\"P_rin : \\\", self.p_rin)\\n self.beta = (3.14159E-6*self.speedup*self.br_nominal *self.delta_lambda*self.d1*self.length) # column O\\n self.sigma_mpn = (self.k_mpn/math.sqrt(2.0)*(self.l_1 -np.exp(-np.square(self.beta)))) # column P\\n self.p_mpn = (-10.0*np.log10(np.sqrt(self.l_1 - (self.Q**2)*np.square(self.sigma_mpn)))) # column Q\\n self.p_blw = (-10.0*math.log10(math.sqrt(1.0- ((self.Q*self.sigma_blw)/ self.isi_tp4_rx)**2))*self.l_1) # cell T13\\n self.p_reflection = -10.0*np.log10(self.isi_reflection) # column N\\n self.v_mn = (((1.0-math.pow(10.0,-0.2*self.pmn))/ (self.Q)**2)*self.l_1) # cell AG7\\n print(\\\"isi_center : \\\", self.isi_center)\\n\\n self.p_isi_center = -10.0*np.log10(self.isi_center) # column J\\n\\n self.p_isi_corners = (-10.0*np.log10(self.isi_corners) - self.p_isi_center) # column K\\n self.p_isi_dj_center = (-10.0*np.log10(self.isi_dj_refl_closed) - self.p_isi_center) # column L\\n self.p_isi_dj_corners = (-10.0*np.log10(self.isi_dj_corners) -self.p_isi_center -self.p_isi_corners) # column M\\n\\n\\n # calculate the \\\"cross\\\" penalty contribution, column S\\n arg1 = ((self.sigma_blw**2 + self.v_rin)/ np.square(self.isi_dj_refl_closed))\\n arg2 = self.l_1 - (self.Q**2)*(arg1 + self.v_mn + np.square(self.sigma_mpn))\\n arg3 = (-10.0*np.log10(np.multiply(self.isi_dj_refl_closed, np.sqrt(arg2))))\\n self.p_cross_center = ( # column S\\n arg3\\n - self.p_blw # cell T13\\n - self.p_isi_center # column J\\n - self.p_isi_dj_center # column L\\n - self.p_mpn # column Q\\n - self.p_reflection # column N\\n - self.p_rin # column R\\n - self.pmn*self.l_1) # cell G13\\n print('p_isi_center: ', self.p_isi_center)\\n\\n # calculate the total power budget evaluated at the center of the eye\\n self.p_total_center = ( # column T\\n self.p_isi_center # column J\\n + self.p_isi_dj_center # column L\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1) # cell G13\\n # calculate the total power budget evaluated at the corner of the eye\\n self.p_total_corners = (\\n self.p_isi_center # column J\\n + self.p_isi_corners # column K\\n + self.p_atten # column B\\n + self.p_mpn # column Q\\n + self.p_reflection # column N\\n + self.p_rin # column R\\n + self.p_cross_center # column S\\n + self.pmn*self.l_1 # cell G13\\n + self.p_isi_dj_corners)# column M\\n\\n # receiver stressed sensitivity\\n self.margin = ( self.p_budget\\n - self.p_total_center) # column W\\n\\n self.rx_stressed_sensitivity = (\\n self.tx_oma_min*self.l_1\\n - self.chil\\n - self.p_mpn\\n - self.p_reflection\\n - self.p_rin\\n - 0.5*self.p_cross_center\\n - self.pmn*self.l_1\\n - self.margin[self.lnum//2]*self.l_1)\\n\\n\\n # end of GbE10.penalty_calc\\n #======================================================================+\",\n \"def mc_main(self, end_plant_tuple, h2_demand, year=2021, centralised=True, pipeline=True, max_pipeline_dist=2000,\\r\\n iterations=1000, elec_type='alkaline'):\\r\\n\\r\\n df = pd.read_csv(filepath_or_buffer=\\\"Data/renewables.csv\\\", index_col=0)\\r\\n\\r\\n total_cost_per_kg_h2 = np.zeros((iterations, len(df)))\\r\\n generation_cost_per_kg = np.zeros((iterations, len(df)))\\r\\n solar_cost = np.zeros((iterations, len(df)))\\r\\n wind_cost = np.zeros((iterations, len(df)))\\r\\n\\r\\n cost_end_nh3 = np.zeros(iterations)\\r\\n cost_end_lohc = np.zeros(iterations)\\r\\n cost_end_h2_liq = np.zeros(iterations)\\r\\n\\r\\n # Define parameters for generation costs\\r\\n year_diff, capex_extra, capex_h2, lifetime_hours, electrolyser_efficiency, elec_opex, other_capex_elec, water_cost, \\\\\\r\\n capex_wind, opex_wind, capex_solar, opex_factor_solar = define_gen_parameters(year, iterations, elec_type)\\r\\n\\r\\n for i in range(iterations):\\r\\n df, cost_end_nh3[i], cost_end_lohc[i], cost_end_h2_liq[i] = initial_geo_calcs(df, end_plant_tuple,\\r\\n centralised=centralised,\\r\\n pipeline=pipeline,\\r\\n max_pipeline_dist=max_pipeline_dist)\\r\\n\\r\\n for i in range(iterations):\\r\\n df = mc_generation_costs(df, h2_demand, year_diff, capex_extra[i], capex_h2[i], lifetime_hours,\\r\\n electrolyser_efficiency[i], elec_opex[i],\\r\\n other_capex_elec[i], water_cost[i],\\r\\n capex_wind[i], opex_wind[i], capex_solar[i], opex_factor_solar[i],\\r\\n interest=0.08, full_load_hours=2000)\\r\\n\\r\\n df = mc_transport_costs(df, end_plant_tuple, h2_demand, cost_end_nh3[i], cost_end_lohc[i], cost_end_h2_liq[i],\\r\\n centralised=centralised, pipeline=pipeline,\\r\\n max_pipeline_dist=max_pipeline_dist)\\r\\n\\r\\n df['Total Yearly Cost'] = df['Yearly gen. cost'] + df['Yearly Transport Cost']\\r\\n df['Total Cost per kg H2'] = df['Gen. cost per kg H2'] + df['Transport Cost per kg H2']\\r\\n\\r\\n total_cost_per_kg_h2[i, :] = df['Total Cost per kg H2'].to_numpy()\\r\\n generation_cost_per_kg[i, :] = df['Gen. cost per kg H2'].to_numpy()\\r\\n solar_cost[i, :] = df['Elec Cost Solar'].to_numpy()\\r\\n wind_cost[i, :] = df['Elec Cost Wind'].to_numpy()\\r\\n\\r\\n return df, total_cost_per_kg_h2, generation_cost_per_kg, solar_cost, wind_cost\",\n \"def E_Dynamic_MavkoEtAl2009(rhob,DTS,PR):\\n E = (2*(rhob*1000)*((304800/DTS)**2)*(1+PR))/1000000\\n return E\",\n \"def get_effective_mass():\\n\\n H_BAR = 6.582119514e-16 # eV*s\\n M_0 = 9.10938356e-31 # kg\\n N_KPTS = 6 # Number of k-points included in the parabola.\\n\\n spin_up = Spin(1)\\n\\n band_structure = Vasprun('vasprun.xml').get_band_structure()\\n\\n # Locations of CBM and VBM in band_structure.bands\\n cbm_band_index = band_structure.get_cbm()['band_index'][spin_up][0]\\n cbm_kpoint_index = band_structure.get_cbm()['kpoint_index'][0]\\n\\n vbm_band_index = band_structure.get_vbm()['band_index'][spin_up][0]\\n vbm_kpoint_index = band_structure.get_vbm()['kpoint_index'][0]\\n\\n k = {'electron': {'left': [], 'right': []},\\n 'hole': {'left': [], 'right': []}}\\n E = {'electron': {'left': [], 'right': []},\\n 'hole': {'left': [], 'right': []}}\\n\\n e_ref_coords = band_structure.kpoints[cbm_kpoint_index]._ccoords\\n h_ref_coords = band_structure.kpoints[vbm_kpoint_index]._ccoords\\n\\n for n in range(-N_KPTS, 1):\\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\\n\\n k['electron']['left'].append(\\n ((e_coords[0] - e_ref_coords[0])**2 +\\n (e_coords[1] - e_ref_coords[1])**2 +\\n (e_coords[2] - e_ref_coords[2])**2)**0.5\\n )\\n k['hole']['left'].append(\\n ((h_coords[0] - h_ref_coords[0])**2 +\\n (h_coords[1] - h_ref_coords[1])**2 +\\n (h_coords[2] - h_ref_coords[2])**2)**0.5\\n )\\n\\n e_energy = band_structure.bands[\\n spin_up][cbm_band_index][cbm_kpoint_index + n]\\n h_energy = band_structure.bands[\\n spin_up][vbm_band_index][vbm_kpoint_index + n]\\n\\n E['electron']['left'].append(e_energy)\\n E['hole']['left'].append(h_energy)\\n\\n for n in range(1, 1 + N_KPTS):\\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\\n\\n k['electron']['right'].append(\\n ((e_coords[0] - e_ref_coords[0])**2 +\\n (e_coords[1] - e_ref_coords[1])**2 +\\n (e_coords[2] - e_ref_coords[2])**2)**0.5\\n )\\n k['hole']['right'].append(\\n ((h_coords[0] - h_ref_coords[0])**2 +\\n (h_coords[1] - h_ref_coords[1])**2 +\\n (h_coords[2] - h_ref_coords[2])**2)**0.5\\n )\\n\\n e_energy = band_structure.bands[\\n spin_up][cbm_band_index][cbm_kpoint_index + n]\\n h_energy = band_structure.bands[\\n spin_up][vbm_band_index][vbm_kpoint_index + n]\\n\\n E['electron']['right'].append(e_energy)\\n E['hole']['right'].append(h_energy)\\n\\n # 2nd order fits\\n e_l_fit = np.poly1d(\\n np.polyfit(k['electron']['left'], E['electron']['left'], 2))\\n e_r_fit = np.poly1d(\\n np.polyfit(k['electron']['right'], E['electron']['right'], 2))\\n h_l_fit = np.poly1d(\\n np.polyfit(k['hole']['left'], E['hole']['left'], 2))\\n h_r_fit = np.poly1d(\\n np.polyfit(k['hole']['right'], E['hole']['right'], 2))\\n\\n # Curvatures\\n e_l_curvature = e_l_fit.deriv().deriv()[0]\\n e_r_curvature = e_r_fit.deriv().deriv()[0]\\n h_l_curvature = h_l_fit.deriv().deriv()[0]\\n h_r_curvature = h_r_fit.deriv().deriv()[0]\\n\\n # Unit conversion\\n e_m_eff_l = 10 * ((H_BAR ** 2) / e_l_curvature) / M_0\\n e_m_eff_r = 10 * ((H_BAR ** 2) / e_r_curvature) / M_0\\n h_m_eff_l = -10 * ((H_BAR ** 2) / h_l_curvature) / M_0\\n h_m_eff_r = -10 * ((H_BAR ** 2) / h_r_curvature) / M_0\\n\\n return {'electron': {'left': e_m_eff_l, 'right': e_m_eff_r},\\n 'hole': {'left': h_m_eff_l, 'right': h_m_eff_r}}\",\n \"def _get_ancillary_data_for_acquisition(self):\\n max_num_acq_opt_evals = self.get_acq_opt_max_evals(self.step_idx)\\n return Namespace(max_evals=max_num_acq_opt_evals,\\n t=self.step_idx,\\n curr_max_val=self.curr_opt_val,\\n evals_in_progress=self.eval_points_in_progress)\",\n \"def bat_res_mod(_parameter, _Pl, _Ppv, _Pbat, _dt, *args):\\r\\n _E = dict()\\r\\n\\r\\n if _parameter['Top'] == 'AC': # AC-coupled systems\\r\\n\\r\\n _Ppvs = args[0] # AC output power of the PV system\\r\\n _Pbs = args[1] # AC power of the battery system\\r\\n # Additional power consumption of the other system components\\r\\n _Pperi = args[2]\\r\\n\\r\\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\\r\\n\\r\\n _Ppv2ac = args[0] # AC output power of the PV2AC conversion pathway\\r\\n _Ppv2bat_in = args[1] # Input power of the PV2BAT conversion pathway\\r\\n _Ppvbs = args[2] # AC power of the PV-battery system\\r\\n # Additional power consumption of the other system components\\r\\n _Pperi = args[3]\\r\\n\\r\\n _Ppv2ac_in = _Ppv - _Ppv2bat_in # Input power of the PV2AC conversion pathway\\r\\n\\r\\n # Total load including the power consumption of the other system components\\r\\n _Plt = _Pl + _Pperi\\r\\n # DC input power of the battery (charged)\\r\\n _Pbatin = np.maximum(0, _Pbat)\\r\\n # DC output power of the battery (discharged)\\r\\n _Pbatout = np.minimum(0, _Pbat)\\r\\n # Maximum PV feed-in power\\r\\n _P_ac2g_max = _parameter['p_ac2g_max'] * _parameter['P_PV'] * 1000\\r\\n\\r\\n if _parameter['Top'] == 'AC': # AC-coupled systems\\r\\n\\r\\n # Residual power without curtailment\\r\\n _Pr = _Ppvs - _Plt\\r\\n # AC input power of the battery system\\r\\n _Pac2bs = np.maximum(0, _Pbs)\\r\\n # AC output power of the battery system\\r\\n _Pbs2ac = np.minimum(0, _Pbs)\\r\\n # Negative residual power (residual load demand)\\r\\n _Prn = np.minimum(0, _Pr)\\r\\n # Positive residual power (surplus PV power)\\r\\n _Prp = np.maximum(0, _Pr)\\r\\n # Direct use of PV power by the load\\r\\n _Ppvs2l = np.minimum(_Ppvs, _Plt)\\r\\n # PV charging power\\r\\n _Ppvs2bs = np.minimum(_Prp, _Pac2bs)\\r\\n # Grid charging power\\r\\n _Pg2bs = np.maximum(_Pac2bs - _Prp, 0)\\r\\n # Grid supply power of the load\\r\\n _Pg2l = np.minimum(_Prn - _Pbs2ac, 0)\\r\\n # Battery supply power of the load\\r\\n _Pbs2l = np.maximum(_Prn, _Pbs2ac)\\r\\n # Battery feed-in power\\r\\n _Pbs2g = np.minimum(_Pbs2ac - _Prn, 0)\\r\\n # PV feed-in power including curtailment\\r\\n _Ppvs2g = np.minimum(np.maximum(_Prp - _Pac2bs, 0), _P_ac2g_max)\\r\\n # Power demand from the grid\\r\\n _Pg2ac = _Pg2l - _Pg2bs\\r\\n # Feed-in power to the grid\\r\\n _Pac2g = _Ppvs2g - _Pbs2g\\r\\n # Grid power\\r\\n _Pg = _Pac2g + _Pg2ac\\r\\n # Curtailed PV power (AC output power)\\r\\n _Pct = np.maximum(_Prp - _Pac2bs, 0) - _Ppvs2g\\r\\n # AC output power of the PV system including curtailment\\r\\n _Ppvs = _Ppvs - _Pct\\r\\n # Residual power including curtailment\\r\\n _Pr = _Ppvs - _Plt\\r\\n # Index for PV curtailment\\r\\n _idx = np.where(_Pct > 0)[0]\\r\\n\\r\\n for i in range(len(_idx)):\\r\\n\\r\\n _tct = _idx[i]\\r\\n # Normalized output power of the PV inverter\\r\\n _ppvinvout = _Ppvs[_tct] / _parameter['P_PV2AC_out'] / 1000\\r\\n # DC output power of the PV generator taking into account the\\r\\n # conversion and curtailment losses\\r\\n _Ppv[_tct] = _Ppvs[_tct] + (_parameter['PV2AC_a_out'] * _ppvinvout **\\r\\n 2 + _parameter['PV2AC_b_out'] * _ppvinvout + _parameter['PV2AC_c_out'])\\r\\n\\r\\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\\r\\n\\r\\n # Grid power demand of the PV-battery system\\r\\n _Pg2pvbs = np.minimum(0, _Ppvbs)\\r\\n # AC input power of the PV-battery system\\r\\n _Pac2pvbs = _Pg2pvbs\\r\\n # AC output power of the PV-battery system\\r\\n _Ppvbs2ac = np.maximum(0, _Ppvbs)\\r\\n # Load supply power by the PV-battery system\\r\\n _Ppvbs2l = np.minimum(_Plt, _Ppvbs2ac)\\r\\n # Load supply power by the grid\\r\\n _Pg2l = _Plt - _Ppvbs2l\\r\\n # Direct use of PV power by the load\\r\\n _Ppv2l = np.minimum(_Plt, _Ppv2ac)\\r\\n # PV feed-in power including curtailment\\r\\n _Ppv2g = np.minimum(_Ppv2ac - _Ppv2l, _P_ac2g_max)\\r\\n # Curtailed PV power (AC output power)\\r\\n _Pct = _Ppv2ac - _Ppv2l - _Ppv2g\\r\\n\\r\\n if np.sum(_Pct) > 0:\\r\\n # Power of the PV-battery system including curtailment\\r\\n _Ppvbs = _Ppvbs - _Pct\\r\\n # AC output power of the PV-battery system including curtailment\\r\\n _Ppvbs2ac = np.maximum(0, _Ppvbs)\\r\\n # AC output power of the PV2AC conversion pathway including curtailment\\r\\n _Ppv2ac = _Ppv2ac - _Pct\\r\\n # Index for PV curtailment\\r\\n _idx = np.where(_Pct > 0)[0]\\r\\n\\r\\n for i in range(len(_idx)):\\r\\n\\r\\n _tct = _idx[i]\\r\\n # Specific AC output power of the PV2AC conversion pathway\\r\\n _ppv2ac = _Ppv2ac[_tct] / _parameter['P_PV2AC_out'] / 1000\\r\\n # DC input power of the PV2AC conversion pathway including curtailment\\r\\n _Ppv2ac_in[_tct] = _Ppv2ac[_tct] + (_parameter['PV2AC_a_out'] * _ppv2ac **\\r\\n 2 + _parameter['PV2AC_b_out'] * _ppv2ac + _parameter['PV2AC_c_out'])\\r\\n\\r\\n # DC output power of the PV generator including curtailment\\r\\n _Ppv = _Ppv2ac_in + _Ppv2bat_in\\r\\n\\r\\n # Grid power including curtailment\\r\\n _Pg = _Ppvbs-_Plt\\r\\n # Feed-in power to the grid including curtailment\\r\\n _Pac2g = np.maximum(0, _Pg)\\r\\n # Power demand from the grid\\r\\n _Pg2ac = np.minimum(0, _Pg)\\r\\n\\r\\n # Energy sums in MWH\\r\\n\\r\\n # Electrical demand including the energy consumption of the other system components\\r\\n _E['El'] = np.sum(np.abs(_Plt)) * _dt / 3.6e9\\r\\n # DC output of the PV generator including curtailment\\r\\n _E['Epv'] = np.sum(np.abs(_Ppv)) * _dt / 3.6e9\\r\\n # DC input of the battery (charged)\\r\\n _E['Ebatin'] = np.sum(np.abs(_Pbatin)) * _dt / 3.6e9\\r\\n # DC output of the battery (discharged)\\r\\n _E['Ebatout'] = np.sum(np.abs(_Pbatout)) * _dt / 3.6e9\\r\\n # Grid feed-in\\r\\n _E['Eac2g'] = np.sum(np.abs(_Pac2g)) * _dt / 3.6e9\\r\\n # Grid demand\\r\\n _E['Eg2ac'] = np.sum(np.abs(_Pg2ac)) * _dt / 3.6e9\\r\\n # Load supply by the grid\\r\\n _E['Eg2l'] = np.sum(np.abs(_Pg2l)) * _dt / 3.6e9\\r\\n # Demand of the other system components\\r\\n _E['Eperi'] = np.sum(np.abs(_Pperi)) * _dt / 3.6e9\\r\\n # Curtailed PV energy\\r\\n _E['Ect'] = np.sum(np.abs(_Pct)) * _dt / 3.6e9\\r\\n\\r\\n if _parameter['Top'] == 'AC': # AC-coupled systems\\r\\n\\r\\n # AC output of the PV system including curtailment\\r\\n _E['Epvs'] = np.sum(np.abs(_Ppvs)) * _dt / 3.6e9\\r\\n # AC input of the battery system\\r\\n _E['Eac2bs'] = np.sum(np.abs(_Pac2bs)) * _dt / 3.6e9\\r\\n # AC output of the battery system\\r\\n _E['Ebs2ac'] = np.sum(np.abs(_Pbs2ac)) * _dt / 3.6e9\\r\\n # Direct use of PV energy\\r\\n _E['Epvs2l'] = np.sum(np.abs(_Ppvs2l)) * _dt / 3.6e9\\r\\n # PV charging\\r\\n _E['Epvs2bs'] = np.sum(np.abs(_Ppvs2bs)) * _dt / 3.6e9\\r\\n # Grid charging\\r\\n _E['Eg2bs'] = np.sum(np.abs(_Pg2bs)) * _dt / 3.6e9\\r\\n # PV feed-in\\r\\n _E['Epvs2g'] = np.sum(np.abs(_Ppvs2g)) * _dt / 3.6e9\\r\\n # Load supply by the battery system\\r\\n _E['Ebs2l'] = np.sum(np.abs(_Pbs2l)) * _dt / 3.6e9\\r\\n # Battery feed-in\\r\\n _E['Ebs2g'] = np.sum(np.abs(_Pbs2g)) * _dt / 3.6e9\\r\\n\\r\\n elif _parameter['Top'] == 'DC' or _parameter['Top'] == 'PV': # DC- and PV-coupled systems\\r\\n\\r\\n # Grid demand of the PV-battery system\\r\\n _E['Eg2pvbs'] = np.sum(np.abs(_Pg2pvbs)) * _dt / 3.6e9\\r\\n # AC input of the PV-battery system\\r\\n _E['Eac2pvbs'] = np.sum(np.abs(_Pac2pvbs)) * _dt / 3.6e9\\r\\n # AC output of the PV-battery system\\r\\n _E['Epvbs2ac'] = np.sum(np.abs(_Ppvbs2ac)) * _dt / 3.6e9\\r\\n # Load supply by the PV-battery system\\r\\n _E['Epvbs2l'] = np.sum(np.abs(_Ppvbs2l)) * _dt / 3.6e9\\r\\n\\r\\n return _E\",\n \"def objective_function(self, variables, mask, load, generation, annuity_scalar=1):\\n size = sum(mask)\\n # pay for reg down energy, get paid for reg up energy\\n # paid revenue for capacity to do both\\n\\n p_regu = cvx.Parameter(size, value=self.p_regu.loc[mask].values, name='p_regu')\\n p_regd = cvx.Parameter(size, value=self.p_regd.loc[mask].values, name='p_regd')\\n p_ene = cvx.Parameter(size, value=self.price.loc[mask].values, name='price')\\n\\n regup_charge_payment = cvx.sum(variables['regu_c'] * -p_regu) * annuity_scalar\\n regup_charge_settlement = cvx.sum(variables['regu_c'] * -p_ene) * self.dt * self.kru_avg * annuity_scalar\\n\\n regup_disch_payment = cvx.sum(variables['regu_d'] * -p_regu) * annuity_scalar\\n regup_disch_settlement = cvx.sum(variables['regu_d'] * -p_ene) * self.dt * self.kru_avg * annuity_scalar\\n\\n regdown_charge_payment = cvx.sum(variables['regd_c'] * -p_regd) * annuity_scalar\\n regdown_charge_settlement = cvx.sum(variables['regd_c'] * p_ene) * self.dt * self.krd_avg * annuity_scalar\\n\\n regdown_disch_payment = cvx.sum(variables['regd_d'] * -p_regd) * annuity_scalar\\n regdown_disch_settlement = cvx.sum(variables['regd_d'] * p_ene) * self.dt * self.krd_avg * annuity_scalar\\n\\n return {'regup_payment': regup_charge_payment + regup_disch_payment,\\n 'regdown_payment': regdown_charge_payment + regdown_disch_payment,\\n 'fr_energy_settlement': regup_disch_settlement + regdown_disch_settlement + regup_charge_settlement + regdown_charge_settlement}\",\n \"def set_c_values(self,nu=3,xd=2,a12sq=1,a13sq=1,a1=0,b1=0,p1=0,\\n vx=0,vy=0,vz=0,epsilon=0.,omega=1.5*np.pi,\\n a2=np.pi,b2=0*np.pi,p2=0.5*np.pi,silent=False):\\n \\n c_target = np.zeros(18)\\n c_target[0] = nu*self.sigma0_RG \\n xd_abs = xd*self.sigma2_RG\\n c_target[4:10] = set_fGij(xd_abs,a12sq,a13sq,a1,b1,p1)\\n c_target[10:13] = np.array([vx,vy,vz])\\n c_target[13:18] = set_VGij(epsilon,omega,a2,b2,p2)\\n \\n if silent == False:\\n print (\\\"Constrain peak parameters: \\\")\\n if 'f0' in self.CONS or 'full' in self.CONS: \\n print (\\\"f0: \\\",\\\"nu = %.1f\\\"%nu, \\\"$\\\\sigma_0$\\\")\\n if 'f1' in self.CONS or 'full' in self.CONS: \\n print (\\\"f1: \\\",\\\"f1,x = f1,y = f1,z = 0\\\")\\n if 'f2' in self.CONS or 'full' in self.CONS: \\n print (\\\"f2: \\\",r\\\"xd = {:.1f} $\\\\sigma_2$, a12sq = {:.1f}, a13sq = {:.1f},a1={:.2f}, b1={:.2f}, p1={:.2f}\\\".format(xd,a12sq,a13sq,a1,b1,p1))\\n if 'vx' in self.CONS or 'full' in self.CONS: \\n print (\\\"vx = {:.1f} km/s\\\".format(vx)) \\n if 'vy' in self.CONS or 'full' in self.CONS: \\n print (\\\"vy = {:.1f} km/s\\\".format(vy))\\n if 'vz' in self.CONS or 'full' in self.CONS: \\n print (\\\"vz = {:.1f} km/s\\\".format(vz))\\n if 'TG' in self.CONS or 'full' in self.CONS: \\n print (\\\"TG: \\\",\\\"epsilon = {:.1f} km/s/Mpc, omega = {:.2f}, a2={:.2f}, b2={:.2f}, p2={:.2f}\\\".format(epsilon,omega,a2,b2,p2))\\n \\n return c_target[self.cmask]\",\n \"def cAPM_Q_learning(df_train, df_test, MinRPT, MaxRPT_r1, MaxRPT, alpha,\\n no_rounds):\\n\\n # number of periods in samples\\n T = df_train.shape[0]\\n T_test = df_test.shape[0]\\n\\n # number of agents\\n K = df_test.shape[1]\\n\\n # individual forecasts\\n F = df_train.iloc[:, 1:].values\\n F_test = df_test.iloc[:, :].values\\n\\n # outcomes\\n outcomes = df_train.iloc[:, 0].values\\n\\n # initialize matrices containing all predictionsa and bets\\n pred_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n bet_mat = np.full((no_rounds, K), np.nan, dtype=float)\\n\\n # initialize vector containing estimated errors\\n est_abs_error = np.full((no_rounds, K), np.nan, dtype=float)\\n\\n # initialize state identification matrix\\n state_mat = np.full((no_rounds, K, 3), False, dtype=bool)\\n\\n # confidence in the crowd\\n delta_mat = np.full((no_rounds, K, 3), 0, dtype=float)\\n\\n # budget initialization\\n budgets = np.full(K, 1, dtype=float)\\n start_budgets = np.full((no_rounds, K), 1, dtype=float)\\n\\n # market prediction vector\\n market_pred = np.full(no_rounds, np.nan, dtype=float)\\n\\n # initialize vectors for storing error cluster means and counts\\n # (small, medium, large)\\n error_cl_mean = np.full(3, np.nan, dtype=float)\\n error_cl_count = np.full(3, 0, dtype=float)\\n no_errors = no_rounds*K\\n\\n # matrix containing the Q value for each action and state\\n # dimensions: action, round, agent, state\\n Q_val = np.full((2, no_rounds, K, 3), 0, dtype=float)\\n\\n # matrix containing starting predictions (before action) for Q-updates\\n pred_mat_upd = np.full((2, no_rounds, K, 3), 0, dtype=float)\\n\\n # matrix containing market predictions shifted by one period for Q-updates\\n market_pred_upd = np.full((no_rounds, K, 3), 0, dtype=float)\\n\\n ##############################\\n # training the market - START#\\n ##############################\\n for i in range(T):\\n\\n # first round betting\\n pred_mat[0, :] = F[i, :]\\n current_bets = budgets * MaxRPT_r1\\n bet_mat[0, :] = current_bets\\n budgets -= current_bets\\n market_pred[0] = np.dot(\\n pred_mat[0, :], bet_mat[0, :]\\n )/np.sum(bet_mat[0, :])\\n\\n # rest of rounds betting\\n if i == 0:\\n for j in range(1, no_rounds):\\n\\n pred_mat[j, :] = F[i, :]\\n current_bets = budgets * MaxRPT\\n bet_mat[j, :] = current_bets\\n budgets -= current_bets\\n\\n else:\\n for j in range(1, no_rounds):\\n\\n # screen shot start of round budgets for Q-val updates later\\n np.copyto(start_budgets[j, :], budgets)\\n\\n # base for current invididual predictions are the last round\\n # individual prediction\\n np.copyto(pred_mat[j, :], pred_mat[j-1, :])\\n\\n # error estimates using market prediction of last round\\n est_error = market_pred[j-1] - pred_mat[j, :]\\n est_abs_error = np.abs(est_error)\\n\\n # identify in which state the agent is\\n cl_dist = np.abs(error_cl_mean[:, np.newaxis] - est_abs_error)\\n visited_state = np.swapaxes(np.amin(cl_dist, axis=0) == cl_dist,\\n 0, 1)\\n state_mat[j, :, :] = visited_state\\n\\n # choose action: 0-preserve, 1-change prediction\\n decision = np.argmax(Q_val[:, j, visited_state], axis=0)\\n pred_mat[j, :] += decision * delta_mat[j, visited_state] * est_error\\n\\n # reestime error after the actions are taken\\n est_error = market_pred[j-1] - pred_mat[j, :]\\n est_abs_error = np.abs(est_error)\\n\\n # estimate score\\n accuracy_prime = np.maximum(100 * (1 - est_abs_error/oet), 1)\\n score_prime = np.log(accuracy_prime)\\n\\n # bet according to estimated score\\n worth_to_bet = score_prime >= 1\\n current_bets = (\\n worth_to_bet * MaxRPT + ~worth_to_bet * MinRPT\\n ) * budgets\\n bet_mat[j, :] = current_bets\\n budgets -= current_bets\\n\\n # store the market prediction at the end of the round\\n market_pred[j] = np.dot(\\n pred_mat[j, :], bet_mat[j, :])/np.sum(bet_mat[j, :])\\n\\n # absolute errors from the current market\\n abs_errors = np.abs(outcomes[i] - pred_mat)\\n abs_errors_flat = abs_errors.flatten()\\n\\n # recompute error clusters (small, medium, large)\\n error_order = np.random.choice(no_errors, no_errors, replace=False)\\n\\n if i == 0:\\n # initialize error clusters\\n for k in range(3):\\n error_cl_mean[k] = abs_errors_flat[error_order[k]]\\n error_cl_count[k] += 1\\n for k in range(3, no_errors):\\n inc_error = abs_errors_flat[error_order[k]]\\n closest_cl = (np.abs(error_cl_mean - inc_error)).argmin()\\n error_cl_mean[closest_cl] = (error_cl_count[closest_cl] * error_cl_mean[closest_cl] + inc_error) / (error_cl_count[closest_cl] + 1)\\n error_cl_count[closest_cl] += 1\\n # order: small, medium, large\\n error_cl_mean = np.sort(error_cl_mean)\\n # in case the cluster means do not differ (very low probability):\\n # spread them\\n if np.unique(error_cl_mean).size < 3:\\n error_cl_mean += np.array([-1e-10, 1e-10, 2e-10])\\n\\n # initialize delta matrix (confidence in the crowd)\\n\\n else:\\n for k in range(no_errors):\\n inc_error = abs_errors_flat[error_order[k]]\\n closest_cl = (np.abs(error_cl_mean - inc_error)).argmin()\\n error_cl_mean[closest_cl] = (error_cl_count[closest_cl] * error_cl_mean[closest_cl] + inc_error) / (error_cl_count[closest_cl] + 1)\\n error_cl_count[closest_cl] += 1\\n # in case the cluster means do not differ (very low probability):\\n # spread them\\n if np.unique(error_cl_mean).size < 3:\\n error_cl_mean += np.array([-1e-10, 1e-10, 2e-10])\\n\\n # use IQR to determine outlier error threshold\\n Q3, Q1 = np.percentile(abs_errors, [75, 25])\\n IQR = Q3 - Q1\\n oet = Q3 + (IQR*1.5)\\n\\n # compute revenues of the agents based on accuracy of their predictions\\n accuracy = np.maximum(100 * (1 - abs_errors/oet), 1)\\n score = np.log(accuracy)\\n revenue = np.multiply(score, bet_mat)\\n\\n # reward agents and rescale the budget (for computational reasons)\\n budgets = budgets + np.sum(revenue, axis=0)\\n budgets = budgets/np.sum(budgets)\\n\\n # update Q-values and deltas (possible after the first market)\\n if i > 0:\\n # update Q-values\\n pred_mat_upd[:, 1:, :, :] = pred_mat[np.newaxis, :-1, :, np.newaxis]\\n market_pred_upd[1:, :, :] = market_pred[:-1, np.newaxis, np.newaxis]\\n pred_mat_upd[1, :, :, :] += delta_mat * (market_pred_upd - pred_mat_upd[1, :, :, :])\\n abs_errors_upd = np.abs(outcomes[i] - pred_mat_upd)\\n accuracy_upd = np.maximum(100 * (1 - abs_errors_upd/oet), 1)\\n score_upd = np.log(accuracy_upd)\\n worth_to_bet_upd = score_upd >= 1\\n bet_mat_upd = np.multiply(\\n worth_to_bet_upd * MaxRPT + ~worth_to_bet_upd * MinRPT,\\n start_budgets[np.newaxis, :, :, np.newaxis]\\n )\\n potential_rev = np.multiply(score_upd, bet_mat_upd)\\n Q_val += alpha*(potential_rev*state_mat[np.newaxis, :, :, :] - Q_val)\\n # update deltas (confidence in the wisdom of the crowd)\\n num = outcomes[i]-pred_mat\\n denum = market_pred[:, np.newaxis]-pred_mat\\n # prevent division by zero\\n denum[denum == 0] = 1e-10\\n experience = np.clip(num/denum, a_min=0, a_max=1)\\n delta_mat += alpha*(experience[:, :, np.newaxis]*state_mat - delta_mat)\\n\\n ############################\\n # training the market - END#\\n ############################\\n\\n # using the market for the out-of-sample predictions\\n pred = np.full(T_test, np.nan, dtype=float)\\n for i in range(T_test):\\n\\n # reset to the trained market budget\\n budgets_test = np.copy(budgets)\\n\\n # first round betting\\n pred_mat[0, :] = F_test[i, :]\\n current_bets = budgets_test * MaxRPT_r1\\n bet_mat[0, :] = current_bets\\n budgets_test -= current_bets\\n market_pred[0] = np.dot(\\n pred_mat[0, :], bet_mat[0, :]\\n )/np.sum(bet_mat[0, :])\\n\\n # rest of rounds betting\\n for j in range(1, no_rounds):\\n\\n # base for current invididual predictions are the last round\\n # individual prediction\\n np.copyto(pred_mat[j, :], pred_mat[j-1, :])\\n\\n # error estimates using market prediction of last round\\n est_error = market_pred[j-1] - pred_mat[j, :]\\n est_abs_error = np.abs(est_error)\\n\\n # identify in which state the agent is\\n cl_dist = np.abs(error_cl_mean[:, np.newaxis] - est_abs_error)\\n visited_state = np.swapaxes(\\n np.amin(cl_dist, axis=0) == cl_dist, 0, 1)\\n\\n # choose action: 0-preserve, 1-change prediction\\n decision = np.argmax(Q_val[:, j, visited_state], axis=0)\\n pred_mat[j, :] += decision * delta_mat[j, visited_state]*est_error\\n\\n # reestime error after the actions are taken\\n est_error = market_pred[j-1] - pred_mat[j, :]\\n est_abs_error = np.abs(est_error)\\n\\n # estimate score\\n accuracy_prime = np.maximum(100 * (1 - est_abs_error/oet), 1)\\n score_prime = np.log(accuracy_prime)\\n\\n # bet according to estimated score\\n worth_to_bet = score_prime >= 1\\n current_bets = (\\n worth_to_bet * MaxRPT + ~worth_to_bet * MinRPT\\n ) * budgets_test\\n bet_mat[j, :] = current_bets\\n budgets_test -= current_bets\\n\\n # store the market prediction at the end of the round\\n market_pred[j] = np.dot(\\n pred_mat[j, :], bet_mat[j, :])/np.sum(bet_mat[j, :])\\n\\n # final round market prediction is the c-APM prediction\\n pred[i] = market_pred[no_rounds-1]\\n\\n # output\\n df_pred = pd.DataFrame(\\n {\\\"c-APM (Q-learning)\\\": pred},\\n index=df_test.index\\n )\\n\\n return df_pred\",\n \"def testPolicy( \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n self, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n symbol=\\\"jpm\\\", \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sd=dt.datetime(2008, 1, 1), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ed=dt.datetime(2009, 12, 31), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sv=10000, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ): \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n dates = pd.date_range(sd,ed)\\n df_prices = ind.get_price(symbol, dates)\\n\\n daily_rets = (df_prices / df_prices.shift(1)) - 1\\n daily_rets = daily_rets[1:]\\n\\n\\n sd_older = sd - dt.timedelta(days=365)\\n dates_older = pd.date_range(sd_older,ed)\\n df_prices_older = ind.get_price(symbol, dates_older)\\n sd_key = df_prices.index[0]\\n sd_index = df_prices_older.index.get_loc(sd_key)\\n\\n\\n df_holdings = df_prices.copy()\\n df_holdings['Holdings'] = np.nan\\n del df_holdings[symbol]\\n # print(df_holdings)\\n\\n cum_ret_prev = 0\\n iters = 0\\n\\n\\n num_bins = len(self.bins)\\n\\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\\n _,_,ind5 = ind.get_MACD(df_prices_older)\\n BB = ind1.iloc[sd_index:].values\\n CCI = ind2.iloc[sd_index:].values\\n SMA_Cross = ind3.iloc[sd_index:].values\\n Momentum = ind4.iloc[sd_index:].values\\n MACD = ind5.iloc[sd_index:].values\\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\\n state = x_0 + x_3*10 + x_4*100\\n\\n\\n\\n\\n\\n self.learner.rar = 0\\n\\n action = self.learner.querysetstate(state[0])\\n\\n daily_return = daily_rets.iloc[0][symbol]\\n df_holdings.iloc[0]['Holdings'] = 0\\n\\n\\n for day_idx in range(1,daily_rets.shape[0]):\\n\\n # implement action\\n cur_price = df_prices.iloc[day_idx-1][symbol]\\n next_price = df_prices.iloc[day_idx][symbol]\\n action = self.learner.querysetstate(state[day_idx])\\n df_holdings.iloc[day_idx]['Holdings'],_ = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\\n\\n\\n df_holdings.iloc[-1]['Holdings'] = 0\\n df_trades = df_holdings.diff()\\n df_trades['Trades'] = df_trades['Holdings']\\n del df_trades['Holdings']\\n df_trades.iloc[0]['Trades'] = 0\\n return df_trades\",\n \"def _calculate_a_value(self, bval, nvalue, nyr, cmag, ref_mag):\\n\\n denominator = np.sum(nyr * np.exp(-bval * (cmag - ref_mag)))\\n return nvalue / denominator\",\n \"def choice_C(data, L_plus, delta_min, wdw_length, scale, start=1, stop=10,\\n step=1, delay=0, L_minus=None, k=None, n=36000, n_series=500, \\n epsilon=0.001, block_length=None, BB_method='MBB', confusion=False, \\n verbose=True): \\n assert BB_method in ['MBB', 'NBB', 'CBB', 'MABB'], \\\"Undefined block bootstrap procedure\\\"\\n if BB_method == 'MBB': \\n blocks = bb.MBB(data, block_length) \\n elif BB_method == 'NBB':\\n blocks = bb.NBB(data, block_length) \\n elif BB_method == 'CBB':\\n blocks = bb.CBB(data, block_length) \\n \\n if 'blocks' in locals():\\n n_blocks = int(np.ceil(n_series/blocks.shape[1]))\\n \\n wdw_length = int(np.ceil(wdw_length)) #should be integer\\n \\n delay = int(delay)\\n n = int(n)\\n assert n > 0, \\\"n must be strictly positive\\\"\\n if n % 3 == 2: #n should be multiple of 3\\n n += 1\\n if n % 3 == 1: \\n n += 2\\n \\n if L_minus is None:\\n L_minus = -L_plus\\n if k is None:\\n k = delta_min/2\\n \\n sign = 1\\n n_test = int(n/5) #n testing instances\\n n_train = n - n_test #n training instances\\n \\n n_C = int(np.ceil((stop-start)/step))\\n MAPE = np.zeros((n_C)); MSE = np.zeros((n_C)); accuracy = np.zeros((n_C))\\n count = 0\\n C_values = np.arange(start, stop, step)\\n for C in np.arange(start, stop, step):\\n \\n ### training\\n input_train = np.zeros((n_train, wdw_length))\\n size_train = np.zeros((n_train))\\n form_train = np.zeros((n_train))\\n rnd = halfnorm(scale=scale).rvs(size=n_train) + delta_min #size of shifts\\n delay_rnd = 0\\n for b in range(0, n_train-2, 3):\\n \\n shift = rnd[b]*sign\\n if BB_method == 'MABB': \\n series = bb.resample_MatchedBB(data, block_length, n=n_series)\\n else:\\n series = resample(blocks, replace=True, n_samples=n_blocks).flatten()[:n_series]\\n \\n #simulate a random delay\\n if delay > 0 :\\n delay_rnd = np.random.randint(delay) \\n\\n \\n for rnd_form in range(3):\\n \\n boot = np.copy(series)\\n \\n if rnd_form == 0: \\n boot[wdw_length:] = boot[wdw_length:] + shift\\n form_train[b] = 0\\n elif rnd_form == 1:\\n power = np.random.uniform(1.5,2)\\n boot = shift/(n_series) * (np.arange(0,n_series)**power) + boot\\n form_train[b] = 1\\n else:\\n eta = np.random.uniform(np.pi/(wdw_length), 3*np.pi/wdw_length)\\n boot = np.sin(eta*np.pi*np.arange(n_series))*shift*boot\\n form_train[b] = 2\\n \\n size_train[b] = shift\\n \\n input_plus = boot[wdw_length:wdw_length*2]\\n C_plus = np.zeros((n_series, 1))\\n for i in range(wdw_length + delay_rnd, n_series): #start the monitoring after random delay \\n C_plus[i] = max(0, C_plus[i-1] + boot[i] - k)\\n if C_plus[i] > L_plus:\\n input_plus = boot[i+1-wdw_length:i+1] \\n break \\n \\n input_minus = boot[wdw_length:wdw_length*2]\\n C_minus = np.zeros((n_series, 1)) \\n for j in range(wdw_length + delay_rnd, n_series):\\n C_minus[j] = min(0, C_minus[j-1] + boot[j] + k)\\n if C_minus[j] < L_minus:\\n input_minus = boot[j+1-wdw_length:j+1] \\n break\\n \\n if i > j: #save first alert recorded\\n input_train[b,:] = input_minus\\n else:\\n input_train[b,:] = input_plus\\n \\n b += 1\\n sign = -sign\\n \\n ### train the models\\n regressor = SVR(C=C, epsilon=epsilon)\\n regressor.fit(input_train, size_train)\\n clf = svm.SVC(C=C)\\n clf.fit(input_train, form_train)\\n \\n ###testing \\n input_test = np.zeros((n_test, wdw_length))\\n label_test = np.zeros((n_test))\\n form_test = np.zeros((n_test))\\n rnd = halfnorm(scale=scale).rvs(size=n_test) + delta_min\\n delay_rnd = 0\\n for b in range(0, n_test-2, 3):\\n \\n shift = rnd[b]*sign\\n if BB_method == 'MABB': \\n series = bb.resample_MatchedBB(data, block_length, n=n_series)\\n else:\\n series = resample(blocks, replace=True, n_samples=n_blocks).flatten()[:n_series]\\n \\n #simulate a random delay\\n if delay > 0 :\\n delay_rnd = np.random.randint(delay) \\n \\n for rnd_form in range(3):\\n \\n boot = np.copy(series)\\n \\n if rnd_form == 0:\\n boot[wdw_length:] = boot[wdw_length:] + shift\\n form_test[b] = 0\\n elif rnd_form == 1:\\n power = np.random.uniform(1.5,2)\\n boot = shift/(n_series) * (np.arange(0,n_series)**power) + boot\\n form_test[b] = 1\\n else:\\n eta = np.random.uniform(np.pi/(wdw_length), 3*np.pi/wdw_length)\\n boot = np.sin(eta*np.pi*np.arange(n_series))*shift*boot\\n form_test[b] = 2\\n label_test[b] = shift\\n \\n input_plus = boot[wdw_length:wdw_length*2]\\n C_plus = np.zeros((n_series, 1))\\n for i in range(wdw_length + delay_rnd, n_series):\\n C_plus[i] = max(0, C_plus[i-1] + boot[i] - k)\\n if C_plus[i] > L_plus:\\n input_plus = boot[i+1-wdw_length:i+1] \\n break \\n \\n input_minus = boot[wdw_length:wdw_length*2]\\n C_minus = np.zeros((n_series, 1)) \\n for j in range(wdw_length + delay_rnd, n_series):\\n C_minus[j] = min(0, C_minus[j-1] + boot[j] + k)\\n if C_minus[j] < L_minus:\\n input_minus = boot[j+1-wdw_length:j+1]\\n break\\n \\n if i > j: #first alert recorded\\n input_test[b,:] = input_minus\\n else:\\n input_test[b,:] = input_plus\\n \\n b += 1 \\n sign = -sign\\n \\n ### compute accuracy and other precision measures \\n label_pred = regressor.predict(input_test)\\n label_pred_clf = clf.predict(input_test)\\n \\n #regressor\\n MAPE[count] = (1/len(label_pred)) * sum(np.abs((np.abs(label_test) - np.abs(label_pred))/np.abs(label_test)))*100\\n MSE[count] = (1/len(label_pred)) * sum((label_test - label_pred)**2)\\n #classifier\\n accuracy[count] = sum(label_pred_clf == form_test)*100 / len(label_pred_clf)\\n \\n ### compute the confusion matrix \\n if confusion : \\n class_names = ['jump', 'drift', 'oscill.']\\n titles_options = [(\\\"Confusion matrix, without normalization\\\", None),\\n (\\\"Normalized confusion matrix\\\", 'true')]\\n for title, normalize in titles_options:\\n disp = plot_confusion_matrix(clf, input_test, form_test,\\n display_labels=class_names,\\n cmap=plt.cm.Blues,\\n normalize=normalize)\\n disp.ax_.set_title(title)\\n print(title)\\n print(disp.confusion_matrix)\\n plt.show()\\n \\n count += 1\\n \\n min_MAPE = C_values[np.argmin(MAPE)]\\n min_MSE = C_values[np.argmin(MSE)] \\n max_accuracy = C_values[np.argmax(accuracy)]\\n \\n if verbose:\\n print('C value that minimizes the MAPE:', min_MAPE)\\n print('C value that minimizes the MSE:', min_MSE)\\n print('C value that maximizes the accuracy:', max_accuracy)\\n \\n return min_MAPE, min_MSE, max_accuracy\",\n \"def calc_annual_investment(devs, param):\\n\\n observation_time = param[\\\"observation_time\\\"]\\n interest_rate = param[\\\"interest_rate\\\"]\\n q = 1 + param[\\\"interest_rate\\\"]\\n\\n \\n # Calculate capital recovery factor\\n CRF = ((q**observation_time)*interest_rate)/((q**observation_time)-1)\\n \\n # Calculate annuity factor for each device\\n for device in devs.keys():\\n \\n # Get device life time\\n life_time = devs[device][\\\"life_time\\\"]\\n\\n # Number of required replacements\\n n = int(math.floor(observation_time / life_time))\\n \\n # Inestment for replcaments\\n invest_replacements = sum((q ** (-i * life_time)) for i in range(1, n+1))\\n\\n # Residual value of final replacement\\n res_value = ((n+1) * life_time - observation_time) / life_time * (q ** (-observation_time))\\n\\n # Calculate annualized investments \\n if life_time > observation_time:\\n devs[device][\\\"ann_factor\\\"] = (1 - res_value) * CRF \\n else:\\n devs[device][\\\"ann_factor\\\"] = ( 1 + invest_replacements - res_value) * CRF \\n \\n\\n return devs\",\n \"def comp_vel(p1=database['K+'], p2=database['pi+'], p3=database['p+'], pmin=0, pmax=80):\\r\\n p_range = np.linspace(pmin, pmax, 1000)\\r\\n m1 = p1.mass\\r\\n m2 = p2.mass\\r\\n m3 = p3.mass\\r\\n v1, v2, v3 = [], [], []\\r\\n for p in p_range:\\r\\n v1.append(c*beta(p, m1))\\r\\n v2.append(c*beta(p, m2))\\r\\n v3.append(c*beta(p, m3))\\r\\n fig = plt.figure(figsize=[10, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n p1_name = r'K$^+$'\\r\\n p2_name = r'$\\\\pi^+$'\\r\\n p3_name = r'p$^+$'\\r\\n ax.plot(p_range, v1, 'r', label=p1_name)\\r\\n ax.plot(p_range, v2, 'b', label=p2_name)\\r\\n ax.plot(p_range, v3, 'g', label=p3_name)\\r\\n ax.set_xlabel('p / GeV', fontsize=20)\\r\\n ax.set_ylabel(r'v / $ms^{-1}$', fontsize=20)\\r\\n ax.axvline(75, color='k', label='p = 75 GeV')\\r\\n ax.set_xticks(np.arange(pmin, pmax+1, 1))\\r\\n ax.set_xticklabels(np.arange(pmin, pmax+1, 1))\\r\\n ax.grid()\\r\\n ax.minorticks_on()\\r\\n ax.set_xlim(pmin, pmax)\\r\\n# ax.set_ylim(np.min(v1+v2))\\r\\n ax.legend(fontsize=20)\\r\\n plt.show\\r\\n return\",\n \"def minimum_remaining_values(csp, ac_3=False):\\n assigned = list()\\n result = mrv_rec_backtracking(csp, assigned, csp.variables[:]) \\n if result is False:\\n print \\\"fuck\\\"\\n return csp, assigned\",\n \"def p_act(c_range, k_a, k_i, ep_ai=5, n_sites=int(2)):\\n if type(n_sites) is not int:\\n raise TypeError('n_sites must be an integer.')\\n\\n numer = (1 + c_range / k_a)**n_sites\\n denom = numer + np.exp(-ep_ai) * (1 + c_range / k_i)**n_sites\\n return numer / denom\",\n \"def F_calcNx_C_sC_A_BEC(i, t, dm, Nx_C_sC_A, kgeoxx, kbec, annbec):\\n assert (dm.BOSON and dm.BEC and dm.SELFCAPT), \\\"Error, function F_calcNx_C_sC_A_BEC should not have been called\\\"\\n tuple32 = dm.Capt_v[i], dm.anncs, t.rx, t.time, dm.selfCapt_v[i], Nx_C_sC_A[kgeoxx], kgeoxx, kbec, annbec # extra arguments for function d$\\n# print \\\"tuple32= capt, dm.anncs, t.rx, t.time, selfcapt, Nx_C_sC_A[kgeoxx], kgeoxx, kbec, annbec\\\"\\n# print \\\"tuple32=\\\",tuple32\\n Nx_C_sC_A_BECtemp = np.array([item[0] for item in odeint(dN32dt,dm.Nxinit,t.time,args=(tuple32))])\\n Nx_C_sC_A_BEC = np.zeros(len(t.time))\\n for k in xrange(len(t.time)):\\n if k<kbec:\\n Nx_C_sC_A_BEC[k] = Nx_C_sC_A[k] # before bec is reached\\n else:\\n Nx_C_sC_A_BEC[k] = Nx_C_sC_A_BECtemp[k] # after bec\\n print \\\" ... Nx_C_sC_A_BEC(t) calculated\\\"\\n return Nx_C_sC_A_BEC\",\n \"def calc_optimal_mass_flow(q1, q2, q3, q4, E1, E2, E3, E4, m1, m2, m3, m4, dP1, dP2, dP3, dP4, Area_a):\\n\\n mass_flow_opt = np.empty(8760)\\n dP_opt = np.empty(8760)\\n const = Area_a / 3600\\n mass_flow_all_kgpers = [m1 * const, m2 * const, m3 * const, m4 * const] # [kg/s]\\n dP_all_Pa = [dP1 * Area_a, dP2 * Area_a, dP3 * Area_a, dP4 * Area_a] # [Pa]\\n balances = [q1 - E1 * 2, q2 - E2 * 2, q3 - E3 * 2, q4 - E4 * 2] # energy generation function eq.(63)\\n for time in range(8760):\\n balances_time = [balances[0][time], balances[1][time], balances[2][time], balances[3][time]]\\n max_heat_production = np.max(balances_time)\\n ix_max_heat_production = np.where(balances_time == max_heat_production)\\n mass_flow_opt[time] = mass_flow_all_kgpers[ix_max_heat_production[0][0]]\\n dP_opt[time] = dP_all_Pa[ix_max_heat_production[0][0]]\\n return mass_flow_opt, dP_opt\",\n \"def get_voltage(self, c):\\n if 'slot_number' in c.keys():\\n slot_number = c['slot_number'] \\n yield self.open_comm(c, slot_number)\\n yield self.write(c, 'VOLT?')\\n voltage = yield self.read(c)\\n yield self.close_comm(c, slot_number)\\n \\n try:\\n voltage = float(voltage)\\n except(ValueError):\\n old_voltage = voltage\\n voltage = ''.join([i for i in voltage if (i.isdigit() or i == '-' or i == '.')])\\n voltage = float(voltage)\\n print ('The value ' + old_voltage + ' was returned by the SIM928, this value was automatically converted to ' + voltage + '.')\\n \\n value = voltage * units.V\\n \\n # try:\\n # voltage = yield self.query(c,\\n # slot_number, \\n # \\\"VOLT?\\\")\\n # try:\\n # voltage = float(voltage)\\n # except:\\n # self.initialize_mainframe(c)\\n # voltage = yield self.query(c,\\n # slot_number,\\n # \\\"VOLT?\\\")\\n # voltage = float(voltage)\\n # except:\\n # self.initialize_mainframe(c)\\n # voltage = yield self.query(c,\\n # slot_number,\\n # \\\"VOLT?\\\")\\n # try:\\n # voltage = float(voltage)\\n # except:\\n # self.initialize_mainframe(c)\\n # voltage = yield self.query(c,\\n # slot_number,\\n # \\\"VOLT?\\\")\\n # voltage = float(voltage)\\n # try:\\n # value = voltage * units.V\\n # except:\\n # self.initialize_mainframe(c)\\n # voltage = yield self.query(c,\\n # slot_number,\\n # \\\"VOLT?\\\")\\n # voltage = float(voltage)\\n # value = voltage * units.V\\n # else:\\n # raise ValueError(self.no_selection_msg())\\n returnValue(value)\",\n \"def _annualised_vol(self, asset, lookback):\\n series = pd.Series(\\n self.buffers.prices[\\n VolatilitySignal._asset_lookback_key(\\n asset, lookback\\n )\\n ]\\n )\\n returns = series.pct_change().dropna().to_numpy()\\n\\n if len(returns) < 1:\\n return 0.0\\n else:\\n return np.std(returns) * np.sqrt(252)\",\n \"def calc_output(line, react_cap=None, gen_res_high=225, gen_res_low=50):\\n # unpack\\n t, v, i = line\\n t_diff = t[1] - t[0]\\n # assert t_diff == 1e-9 # time scale should be 1ns.\\n # values based on current measurment. Assuming voltage waveform is aligned.\\n\\n # validation on the real maxima/minima of current\\n assert i.argmax() < i.argmin(), 'Current valley before peak, signal is inverted!'\\n\\n v_min = min(v)\\n v_max = max(v)\\n v_max_time = np.where(v == v_max)[0][0] # first value where voltage has maximum\\n # v_min_time = np.where(v == v_min)[0][-1] # last value where voltage has minimum\\n # assert v_max_time < v_min_time, 'Voltage valley before peak, signal inverted!'\\n c_peak_time = i[0:v_max_time].argmax() # current peak is before voltage maximum\\n c_max = i[c_peak_time]\\n\\n c_valley_time = i.argmin()\\n c_min = min(i)\\n assert i[c_valley_time] == c_min\\n\\n # some validation\\n assert c_peak_time < c_valley_time, 'Current valley before peak, signal is inverted!'\\n assert MAX_VOLTAGE_MIN <= v_max < MAX_VOLTAGE_MAX, 'Max voltage error (%r)' % v_max\\n assert MAX_CURRENT_MIN <= c_max < MAX_CURRENT_MAX, 'Max current error (%r)' % c_max\\n\\n # Find the settling time of the current. Than use the time where the current is stable\\n # to calculate the final pulse voltage. This pulse final voltage is then used to calculate\\n # the settling time and risetime of the voltage.\\n\\n # all parts of current inside 10% of maximum, till end of pulse\\n i_time_settling_options = [abs(x) < 0.1 * c_max for x in i[0:c_valley_time]]\\n ranges = count_ranges(i_time_settling_options)\\n range_before, range_pulse = find_longest_ranges(ranges, 2) # [end, length]\\n end_pulse = range_pulse[0]\\n i_time_settling = range_pulse[0] - range_pulse[1]\\n # average of voltage during pulse when current is < 5% of max current\\n v_pulse = np.mean(v[i_time_settling:end_pulse])\\n # all parts of current inside 10% of maximum, till end of pulse\\n v_time_settling_options = [abs(x - v_pulse) < (0.1 * v_pulse) for x in v]\\n ranges = count_ranges(v_time_settling_options)\\n if ranges == []: # if too much oscillations, a range cannot be found. Increase the bounds:\\n # all parts of current inside 10% of maximum, till end of pulse\\n v_time_settling_options = [abs(x - v_pulse) < (0.3 * v_pulse) for x in v]\\n ranges = count_ranges(v_time_settling_options)\\n print('Warning, voltage settling options increased from 10% to 30%!')\\n assert ranges != [], \\\"Error! Line is too unstable.\\\"\\n pulse = find_longest_ranges(ranges, 1) # pulse=[end,length] of voltage pulse stable\\n settling_end = pulse[0] - pulse[1] # voltage pulse stable start\\n # recalculate pulse voltage\\n v_pulse_new = np.mean(v[settling_end:pulse[0]])\\n if v_pulse > 13e3: # pulses for highest voltages have to be stable. Lower voltages are always less stable.\\n assert abs(v_pulse-v_pulse_new)/v_pulse_new < 0.01, 'Pulse voltage unstable.'\\n t_settling_end = t[settling_end] # voltage pulse stable start time\\n v05 = 0.05 * v_pulse\\n settling_start = np.where(v > v05)[0][0]\\n t_settling_start = t[settling_start] # when v first rises above 0.05 of final\\n t_settling = t_settling_end - t_settling_start\\n v10 = 0.1 * v_pulse\\n v90 = 0.9 * v_pulse\\n t_rise_start = t[np.where(v > v10)[0][0]]\\n t_rise_end = t[np.where(v > v90)[0][0]]\\n t_rise = t_rise_end - t_rise_start\\n rise_rate = (v90 - v10) / (t_rise)\\n v_overshoot = v_max / v_pulse\\n pulse_stable = int((settling_end + end_pulse) / 2) # point where the pulse is very stable\\n # energy\\n p = (v * i) # for this to be correct, make sure lines are aligned in b_correct_lines using offset 'v_div'\\n e = integrate.cumtrapz(p, t, initial=0)\\n p_rise = p[settling_start:pulse_stable]\\n e_rise = e[settling_start:pulse_stable][-1]\\n p_res = np.append(i[0:pulse_stable] ** 2 * gen_res_high, i[pulse_stable:] ** 2 * gen_res_low)\\n # 1/2*C*V^2 is energy stored in capacitor, which is lost after discharging pulse.\\n # e_cap = 1 / 2 * react_cap * v_pulse ** 2\\n e_res = integrate.cumtrapz(p_res, t, initial=0)\\n e_res_total = e_res[-1]\\n e_plasma = e[-1] # energy to plasma is energy in positive pulse except charge on capacitor.\\n\\n # Correct the time axis to have 0 at the start of the pulse\\n start = t[settling_start]\\n t = t - start\\n\\n # all these values are added to the pickle and xlsx with 'output_' prepend in calc_run.py\\n data = {\\n 't': t,\\n 'v': v,\\n 'c': i,\\n 'c_min': c_min,\\n 'c_max': c_max,\\n 'v_min': v_min,\\n 'v_max': v_max,\\n 'v_pulse': v_pulse,\\n 't_settling': t_settling,\\n 't_rise': t_rise,\\n 'rise_rate': rise_rate,\\n 'v_overshoot': v_overshoot,\\n 'p': p,\\n 'e': e,\\n 'p_rise': p_rise,\\n 'e_rise': e_rise,\\n\\n 'p_res': p_res,\\n 'e_res': e_res,\\n 'e_res_total': e_res_total,\\n # 'e_cap': e_cap,\\n 'e_plasma': e_plasma,\\n\\n 'start': start,\\n 'end': t[end_pulse],\\n # 'start_index': settling_start,\\n # 'end_index': end_pulse,\\n # 'test': i_time_settling\\n }\\n return data\",\n \"def call_price(S0, K, r, T, alpha, theta, mu, sigma, lambda_, b, m, a, t, A0=0.5):\\n def phi_xt_temp(u): return phi_xt(u, alpha, theta,\\n mu, sigma, lambda_, b, m, a, T, A0)\\n\\n def constant(u): return phi_xt_temp(u - i_) / (phi_xt_temp(-i_) * i_ * u)\\n def inside_exp(u): return -i_ * u * np.log((K / S0) * phi_xt_temp(-i_))\\n def inte_mu(u): return np.real(constant(u) * np.exp(inside_exp(u)))\\n\\n C1 = S0 * (0.5 + 1 / np.pi * quad(inte_mu, 0, np.inf)[0])\\n def inte_mu2(u): return np.real(phi_xt_temp(u) * np.exp(-i_ *\\n u * np.log(K / S0 * phi_xt_temp(-i_))) / (i_ * u))\\n\\n C2 = K * np.exp(-r * T) * (0.5 + 1 / np.pi * quad(inte_mu2, 0, np.inf)[0])\\n\\n return C1 - C2\",\n \"def extract(k):\\n global amount, _alarm\\n result = 0\\n if current_policy != 'double' and k < amount:\\n amount = amount - k \\n result = k\\n \\n elif current_policy == 'double' and k < amount and (amount - k > initial_amount * 0.1):\\n # print \\\"IN RESOURCE: k : %f, amount %f, amount - k: %f \\\" % (k, amount, amount - k)\\n amount = amount - k\\n result = k \\n \\n # Set the alarm when the resource reaches 30% of its original value:\\n if amount < initial_amount * 0.3:\\n _alarm = True\\n \\n return result\",\n \"def decay_rate_vs_p(pmax=100, L=102.4, p1=database['K+'],\\r\\n target_rate=53957518.001, decay_region=65):\\r\\n p_range = np.linspace(1, 100, 1000)\\r\\n rate = []\\r\\n for p in p_range:\\r\\n rate.append(decay_rate(L, p1, p, target_rate, decay_region)*1e-6)\\r\\n fig = plt.figure(figsize=[12, 4])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n ax.plot(p_range, rate, 'r', lw=2)\\r\\n ax.set_xlim(0, pmax)\\r\\n ax.set_ylim(0)\\r\\n ax.set_xlabel('p / GeV', fontsize=20)\\r\\n text = f'{p1.name} decays in decay region / MHz'\\r\\n ax.set_ylabel(text, fontsize=15)\\r\\n ax.axvline(75, color='k', lw=2, label='current setup')\\r\\n ax.legend(fontsize=20)\\r\\n ax.minorticks_on()\\r\\n ax.grid()\\r\\n plt.show()\\r\\n output = 'Maximum decays at p = {0:.1f} GeV --> decay rate = {1:.2f} MHz \\\\n'.format(p_range[np.argmax(rate)], np.max(rate))\\r\\n output += 'Current decays at p = 75 GeV --> decay rate = {0:.2f} MHz'.format(decay_rate(p=75)*1e-6)\\r\\n print(output)\\r\\n return\",\n \"def main():\\n # Retrieve csv_file name an max_investment from argument passed in console:\\n arg_csv_file, arg_max_investment = set_arg()\\n if arg_csv_file:\\n csv_file = arg_csv_file\\n else:\\n csv_file = 'dataset1_Python+P7.csv'\\n if arg_max_investment:\\n max_investment = float(arg_max_investment)\\n else:\\n max_investment = 500.00\\n\\n # Retrieve dataset:\\n base_dataset = open_convert_and_clean_csv(csv_file)\\n\\n # Retrieve solution:\\n start = time.perf_counter()\\n print()\\n print(f\\\"Processing with file '{csv_file}' containing {len(base_dataset)} shares...\\\")\\n print(f\\\"Maximum investment: {max_investment}€\\\")\\n print(\\\"Please wait...\\\")\\n computable_dataset = add_roi_to_dataset(convert_dataset_to_cents(base_dataset))\\n best_roi, combination = best_combination_dynamic(computable_dataset, max_investment)\\n\\n # Formatting results:\\n combination.sort(key=lambda x: x[2], reverse=True)\\n combination_in_euros = convert_dataset_to_euros(combination)\\n best_roi /= 100\\n # Following calculus is done on cent prices (combination) to avoid approximations with floats\\n shares_cost = calculate_shares_cost_sum(combination) / 100\\n\\n # Printing results:\\n print()\\n print(f\\\"Length of dataset: {len(computable_dataset)}\\\")\\n print(f\\\"Duration of Analysis: {elapsed_time_formatted(start)}\\\")\\n print()\\n print(f\\\"Best Return on investment after 2 years: {round(best_roi, 2)}€\\\")\\n print(f\\\"Number of shares to buy : {len(combination_in_euros)}\\\")\\n print(f\\\"Total cost: {round(shares_cost, 2)}€\\\")\\n print()\\n print(f\\\"Best combination of shares ordered by performance: \\\")\\n for share in combination_in_euros:\\n print(f\\\"{share[0]} | Price: {share[1]}€ | profit: {share[2]}%\\\")\\n print()\",\n \"def _get_penalty_data(self,x):\\n\\t\\n\\tfrom PyKEP import epoch, lambert_problem, propagate_lagrangian, fb_prop, DAY2SEC;\\n\\tfrom math import pi, acos, cos, sin;\\n\\timport numpy as np;\\n\\tfrom _mass_penalty import get_rp_ra_Trev\\n\\t\\n\\tTrajectory = [];\\n\\t\\n\\t#1 - we 'decode' the chromosome recording the various times of flight (days) in the list T for convenience\\n\\tT = x[3::4]\\n\\t\\n\\t# reconstruct properties that are known in _mga_incipit:\\n\\tself.seq = self.get_sequence();\\n\\tself.__n_legs = len(self.seq);\\n\\tself.common_mu = self.seq[0].mu_central_body\\n\\t\\n\\t#2 - We compute the epochs and ephemerides of the planetary encounters\\n\\tt_P = list([None] * (self.__n_legs))\\n\\tr_P = list([None] * (self.__n_legs))\\n\\tv_P = list([None] * (self.__n_legs))\\n\\tDV = list([None] * (self.__n_legs))\\n\\t\\n\\tfor i,planet in enumerate(self.seq):\\n\\t\\tt_P[i] = epoch(x[0]+sum(T[:i+1]))\\n\\t\\tr_P[i],v_P[i] = self.seq[i].eph(t_P[i])\\n\\n\\t#3 - We start with the first leg: a lambert arc\\n\\ttheta = 2*pi*x[1]\\n\\tphi = acos(2*x[2]-1)-pi/2\\n\\tr = [cos(phi)*sin(theta), cos(phi)*cos(theta), sin(phi)] #phi close to zero is in the moon orbit plane injection\\n\\tr = [JR*1000*d for d in r]\\n\\t\\n\\tl = lambert_problem(r,r_P[0],T[0]*DAY2SEC,self.common_mu, False, False)\\n\\n\\t#Lambert arc to reach seq[1]\\n\\tv_end_l = l.get_v2()[0]\\n\\tv_beg_l = l.get_v1()[0]\\n\\tTr = [tuple(r), v_beg_l, r_P[0], v_end_l, T[0]*DAY2SEC];\\n\\trPvec = np.asarray(r_P[0]);\\n\\tvPvec = np.asarray(v_end_l);\\n\\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\\n\\tvinf = vPvec - np.asarray(v_P[0]);\\n\\tTr = Tr + [vinf];\\n\\tTrajectory.append(Tr);\\n\\n\\t#First DSM occuring at the very beginning (will be cancelled by the optimizer)\\n\\tDV[0] = abs(np.linalg.norm(v_beg_l) - 3400)\\n\\n\\t#4 - And we proceed with each successive leg\\n\\tfor i in xrange(1,self.__n_legs):\\n\\t\\t#Fly-by \\n\\t\\tv_out = fb_prop(v_end_l,v_P[i-1],x[1+4*i]*self.seq[i-1].radius,x[4*i],self.seq[i-1].mu_self)\\n\\t\\t#s/c propagation before the DSM\\n\\t\\tr,v = propagate_lagrangian(r_P[i-1],v_out,x[4*i+2]*T[i]*DAY2SEC,self.common_mu)\\n\\t\\t# append r, v, etc. to the Trajectory:\\n\\t\\tTr = [r_P[i-1], v_out, r, v, x[4*i+2]*T[i]*DAY2SEC];\\n\\t\\trPvec = np.asarray(r);\\n\\t\\tvPvec = np.asarray(v);\\n\\t\\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\\n\\t\\tvinf = [];\\n\\t\\tTr = Tr + [vinf];\\n\\t\\tTrajectory.append(Tr);\\n\\t\\t\\n\\t\\t#Lambert arc to reach Earth during (1-nu2)*T2 (second segment)\\n\\t\\tdt = (1-x[4*i+2])*T[i]*DAY2SEC\\n\\t\\tl = lambert_problem(r,r_P[i],dt,self.common_mu, False, False)\\n\\t\\tv_end_l = l.get_v2()[0]\\n\\t\\tv_beg_l = l.get_v1()[0]\\n\\t\\t# append r, v, etc. to the Trajectory:\\n\\t\\tTr = [r, v_beg_l, r_P[i], v_end_l, (1-x[4*i+2])*T[i]*DAY2SEC];\\n\\t\\trPvec = np.asarray(r_P[i]);\\n\\t\\tvPvec = np.asarray(v_end_l);\\n\\t\\tTr = Tr + get_rp_ra_Trev(rPvec, vPvec);\\n\\t\\tvinf = vPvec - np.asarray(v_P[i]);\\n\\t\\tTr = Tr + [vinf];\\n\\t\\tTrajectory.append(Tr);\\n\\t\\t\\n\\t\\t\\n\\t\\t#DSM occuring at time nu2*T2\\n\\t\\tDV[i] = np.linalg.norm([a-b for a,b in zip(v_beg_l,v)])\\n\\treturn Trajectory;\",\n \"def generate_demand_ivt():\\n r = np.random.rand()\\n \\n # check the first cdf entry (index 0) \\n if r <= cdf[0]:\\n return demands[0]\\n # check the second cdf entry (index 1)\\n elif r <= cdf[1]:\\n return demands[1]\\n # check the third cdf entry (index 2)\\n elif r <= cdf[2]:\\n return demands[2]\\n # otherwise no need to check, it's the final CDF entry (index 3)\\n else:\\n return demands[3]\\n \\n \\\"\\\"\\\"\\n note: the code above could be replaced with the following for \\n loop which iterates over each array index i in demands\\n \\n for i in range(len(demands)):\\n if r <= cdf[i]:\\n return demands[i]\\n \\\"\\\"\\\"\",\n \"def get_decided_outlet_supply_air_absolute_humidity_for_cooling(\\n x_req_c: np.ndarray, v_supply: np.ndarray, x_hs_out_min_c: np.ndarray) -> np.ndarray:\\n\\n return np.maximum(np.sum(x_req_c * v_supply / v_supply.sum(axis=0), axis=0), x_hs_out_min_c)\",\n \"def get_default_rated_capacity(region: int, a_a: float) -> (float, float):\\n\\n # corrected value for effects of the external temperature to the capacity\\n f_ct = 1.05\\n\\n # corrected value for effects of the intermittent operation to the capacity\\n f_cl = 1.0\\n\\n if region == 8:\\n q_rtd_h = None\\n else:\\n q_rq_h = {\\n 1: 73.91,\\n 2: 64.32,\\n 3: 62.65,\\n 4: 66.99,\\n 5: 72.64,\\n 6: 61.34,\\n 7: 64.55,\\n }[region]\\n q_rtd_h = q_rq_h * a_a * f_ct * f_cl\\n\\n q_rq_c = {\\n 1: 37.61,\\n 2: 36.55,\\n 3: 42.34,\\n 4: 54.08,\\n 5: 61.69,\\n 6: 60.79,\\n 7: 72.53,\\n 8: 61.56,\\n }[region]\\n\\n q_rtd_c = q_rq_c * a_a * f_ct * f_cl\\n\\n return q_rtd_h, q_rtd_c\",\n \"def calc_annual_electric_savings (self):\\n price = self.diesel_prices\\n #TODO add rural v non rural\\n self.base_generation_cost = self.electric_diesel_reduction * price\\n\\n\\n self.proposed_generation_cost = self.maintenance_cost\\n\\n self.annual_electric_savings = self.base_generation_cost - \\\\\\n self.proposed_generation_cost\\n #~ print 'self.annual_electric_savings',self.annual_electric_savings\",\n \"def calculate(self, catalogue, config, completeness=None):\\n # Input checks\\n cmag, ctime, ref_mag, dmag, config = input_checks(catalogue,\\n config,\\n completeness)\\n ival = 0\\n tolerance = 1E-7\\n number_intervals = np.shape(ctime)[0]\\n b_est = np.zeros(number_intervals, dtype=float)\\n neq = np.zeros(number_intervals, dtype=float)\\n nyr = np.zeros(number_intervals, dtype=float)\\n\\n for ival in range(0, number_intervals):\\n id0 = np.abs(ctime - ctime[ival]) < tolerance\\n m_c = np.min(cmag[id0])\\n if ival == 0:\\n id1 = np.logical_and(\\n catalogue.data['year'] >= (ctime[ival] - tolerance),\\n catalogue.data['magnitude'] >= (m_c - tolerance))\\n nyr[ival] = float(catalogue.end_year) - ctime[ival] + 1.\\n elif ival == number_intervals - 1:\\n id1 = np.logical_and(\\n catalogue.data['year'] < (ctime[ival - 1] - tolerance),\\n catalogue.data['magnitude'] >= (m_c - tolerance))\\n nyr[ival] = ctime[ival - 1] - ctime[ival]\\n else:\\n id1 = np.logical_and(\\n catalogue.data['year'] >= (ctime[ival] - tolerance),\\n catalogue.data['year'] < (ctime[ival - 1] - tolerance))\\n id1 = np.logical_and(\\n id1, catalogue.data['magnitude'] > (m_c - tolerance))\\n nyr[ival] = ctime[ival - 1] - ctime[ival]\\n neq[ival] = np.sum(id1)\\n # Get a- and b- value for the selected events\\n temp_rec_table = recurrence_table(catalogue.data['magnitude'][id1],\\n dmag,\\n catalogue.data['year'][id1])\\n\\n aki_ml = AkiMaxLikelihood()\\n b_est[ival] = aki_ml._aki_ml(temp_rec_table[:, 0],\\n temp_rec_table[:, 1],\\n dmag, m_c)[0]\\n ival += 1\\n total_neq = np.float(np.sum(neq))\\n bval = self._harmonic_mean(b_est, neq)\\n sigma_b = bval / np.sqrt(total_neq)\\n aval = self._calculate_a_value(bval, total_neq, nyr, cmag, ref_mag)\\n sigma_a = self._calculate_a_value(bval + sigma_b, total_neq, nyr,\\n cmag, ref_mag)\\n\\n if not config['reference_magnitude']:\\n aval = np.log10(aval)\\n sigma_a = np.log10(sigma_a) - aval\\n else:\\n sigma_a = sigma_a - aval\\n return bval, sigma_b, aval, sigma_a\",\n \"def curDemand(curPrice, prevPrice, demandIntcpt, k1, k2, a, b, coff):\\n\\t# price dependent\\n\\tpdm = curPrice - priceMin\\n\\tpdp = curPrice - prevPrice\\n\\tq = demandIntcpt + k1 * pdm + k2 * pdm * pdm - a * shock(plus(pdp)) + b * shock(minus(pdp)) \\n\\t\\n\\t# cyclic \\n\\tq += demCycAmp * math.sin(2.0 * math.pi * coff / demCycPer)\\n\\t\\n\\t# random\\n\\tq += np.random.normal(0, randDemSd)\\n\\t\\n\\tq = plus(q)\\n\\treturn q\",\n \"def calc_SC_module(tilt_angle_deg, IAM_b_vector, IAM_d_vector, I_direct_vector, I_diffuse_vector, Tamb_vector_C, n0, c1, c2,\\n mB0_r, mB_max_r, mB_min_r, C_eff_Jperm2K, t_max, aperture_area_m2, dP1, dP2, dP3, dP4, Cp_fluid_JperkgK, Tin_C, Leq, l_ext, l_int, Nseg):\\n\\n # local variables\\n msc_max_kgpers = mB_max_r * aperture_area_m2 / 3600 # maximum mass flow [kg/s]\\n\\n # Do the calculation of every time step for every possible flow condition\\n # get states where highly performing values are obtained.\\n specific_flows_kgpers = [np.zeros(8760), (np.zeros(8760) + mB0_r) * aperture_area_m2 / 3600,\\n (np.zeros(8760) + mB_max_r) * aperture_area_m2 / 3600,\\n (np.zeros(8760) + mB_min_r) * aperture_area_m2 / 3600, np.zeros(8760), np.zeros(8760)] # in kg/s\\n specific_pressure_losses_Pa = [np.zeros(8760), (np.zeros(8760) + dP2) * aperture_area_m2, (np.zeros(8760) + dP3) * aperture_area_m2,\\n (np.zeros(8760) + dP4) * aperture_area_m2, np.zeros(8760), np.zeros(8760)] # in Pa\\n\\n # generate empty lists to store results\\n temperature_out = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n temperature_in = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n temperature_mean = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n supply_out_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n supply_losses_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n auxiliary_electricity_kW = [np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760), np.zeros(8760)]\\n supply_out_pre = np.zeros(8760)\\n supply_out_total_kW = np.zeros(8760)\\n mcp_kWperK = np.zeros(8760)\\n\\n # calculate absorbed radiation\\n tilt = radians(tilt_angle_deg)\\n q_rad_vector = np.vectorize(calc_q_rad)(n0, IAM_b_vector, I_direct_vector, IAM_d_vector, I_diffuse_vector,\\n tilt) # absorbed solar radiation in W/m2 is a mean of the group\\n for flow in range(6):\\n mode_seg = 1 # mode of segmented heat loss calculation. only one mode is implemented.\\n TIME0 = 0\\n DELT = 1 # timestep 1 hour\\n delts = DELT * 3600 # convert time step in seconds\\n Tfl = np.zeros([3, 1]) # create vector to store value at previous [1] and present [2] time-steps\\n DT = np.zeros([3, 1])\\n Tabs = np.zeros([3, 1])\\n STORED = np.zeros([600, 1])\\n TflA = np.zeros([600, 1])\\n TflB = np.zeros([600, 1])\\n TabsB = np.zeros([600, 1])\\n TabsA = np.zeros([600, 1])\\n q_gain_Seg = np.zeros([101, 1]) # maximum Iseg = maximum Nseg + 1 = 101\\n\\n for time in range(8760):\\n Mfl_kgpers = specific_flows_kgpers[flow][time] # [kg/s]\\n if time < TIME0 + DELT / 2:\\n # set output values to the appropriate initial values\\n for Iseg in range(101, 501): # 400 points with the data\\n STORED[Iseg] = Tin_C\\n else:\\n # write average temperature of all segments at the end of previous time-step\\n # as the initial temperature of the present time-step\\n for Iseg in range(1, Nseg + 1): # 400 points with the data\\n STORED[100 + Iseg] = STORED[200 + Iseg] # thermal capacitance node temperature\\n STORED[300 + Iseg] = STORED[400 + Iseg] # absorber node temperature\\n\\n # calculate stability criteria\\n if Mfl_kgpers > 0:\\n stability_criteria = Mfl_kgpers * Cp_fluid_JperkgK * Nseg * (DELT * 3600) / (C_eff_Jperm2K * aperture_area_m2)\\n if stability_criteria <= 0.5:\\n print ('ERROR: stability criteria' + str(stability_criteria) + 'is not reached. aperture_area: '\\n + str(aperture_area_m2) + 'mass flow: ' + str(Mfl_kgpers))\\n\\n # calculate average fluid temperature and average absorber temperature at the beginning of the time-step\\n Tamb_C = Tamb_vector_C[time]\\n q_rad_Wperm2 = q_rad_vector[time]\\n Tfl[1] = 0\\n Tabs[1] = 0\\n for Iseg in range(1, Nseg + 1):\\n Tfl[1] = Tfl[1] + STORED[100 + Iseg] / Nseg # mean fluid temperature\\n Tabs[1] = Tabs[1] + STORED[300 + Iseg] / Nseg # mean absorber temperature\\n\\n ## first guess for Delta T\\n if Mfl_kgpers > 0:\\n Tout_C = Tin_C + (q_rad_Wperm2 - (c1 + 0.5) * (Tin_C - Tamb_C)) / (Mfl_kgpers * Cp_fluid_JperkgK / aperture_area_m2)\\n Tfl[2] = (Tin_C + Tout_C) / 2 # mean fluid temperature at present time-step\\n else:\\n Tout_C = Tamb_C + q_rad_Wperm2 / (c1 + 0.5)\\n Tfl[2] = Tout_C # fluid temperature same as output\\n DT[1] = Tfl[2] - Tamb_C # difference between mean absorber temperature and the ambient temperature\\n\\n # calculate q_gain with the guess for DT[1]\\n q_gain_Wperm2 = calc_q_gain(Tfl, Tabs, q_rad_Wperm2, DT, Tin_C, Tout_C, aperture_area_m2, c1, c2, Mfl_kgpers,\\n delts, Cp_fluid_JperkgK, C_eff_Jperm2K, Tamb_C)\\n\\n A_seg_m2 = aperture_area_m2 / Nseg # aperture area per segment\\n # multi-segment calculation to avoid temperature jump at times of flow rate changes.\\n for Iseg in range(1, Nseg + 1):\\n # get temperatures of the previous time-step\\n TflA[Iseg] = STORED[100 + Iseg]\\n TabsA[Iseg] = STORED[300 + Iseg]\\n if Iseg > 1:\\n Tin_Seg_C = Tout_Seg_C\\n else:\\n Tin_Seg_C = Tin_C\\n\\n if Mfl_kgpers > 0 and mode_seg == 1: # same heat gain/ losses for all segments\\n Tout_Seg_K = ((Mfl_kgpers * Cp_fluid_JperkgK * (Tin_Seg_C + 273.15)) / A_seg_m2 -\\n (C_eff_Jperm2K * (Tin_Seg_C + 273.15)) / (2 * delts) + q_gain_Wperm2 +\\n (C_eff_Jperm2K * (TflA[Iseg] + 273.15) / delts)) / (Mfl_kgpers * Cp_fluid_JperkgK / A_seg_m2 + C_eff_Jperm2K / (2 * delts))\\n Tout_Seg_C = Tout_Seg_K - 273.15 # in [C]\\n TflB[Iseg] = (Tin_Seg_C + Tout_Seg_C) / 2\\n else: # heat losses based on each segment's inlet and outlet temperatures.\\n Tfl[1] = TflA[Iseg]\\n Tabs[1] = TabsA[Iseg]\\n q_gain_Wperm2 = calc_q_gain(Tfl, Tabs, q_rad_Wperm2, DT, Tin_Seg_C, Tout_C, A_seg_m2, c1, c2,\\n Mfl_kgpers, delts, Cp_fluid_JperkgK, C_eff_Jperm2K, Tamb_C)\\n Tout_Seg_C = Tout_C\\n\\n if Mfl_kgpers > 0:\\n TflB[Iseg] = (Tin_Seg_C + Tout_Seg_C) / 2\\n Tout_Seg_C = TflA[Iseg] + (q_gain_Wperm2 * delts) / C_eff_Jperm2K\\n else:\\n TflB[Iseg] = Tout_Seg_C\\n\\n #TflB[Iseg] = Tout_Seg\\n q_fluid_Wperm2 = (Tout_Seg_C - Tin_Seg_C) * Mfl_kgpers * Cp_fluid_JperkgK / A_seg_m2\\n q_mtherm_Whperm2 = (TflB[Iseg] - TflA[Iseg]) * C_eff_Jperm2K / delts # total heat change rate of thermal capacitance\\n q_balance_error = q_gain_Wperm2 - q_fluid_Wperm2 - q_mtherm_Whperm2\\n if abs(q_balance_error) > 1:\\n time = time # re-enter the iteration when energy balance not satisfied\\n q_gain_Seg[Iseg] = q_gain_Wperm2 # in W/m2\\n\\n # resulting net energy output\\n q_out_kW = (Mfl_kgpers * Cp_fluid_JperkgK * (Tout_Seg_C - Tin_C)) / 1000 #[kW]\\n Tabs[2] = 0\\n # storage of the mean temperature\\n for Iseg in range(1, Nseg + 1):\\n STORED[200 + Iseg] = TflB[Iseg]\\n STORED[400 + Iseg] = TabsB[Iseg]\\n Tabs[2] = Tabs[2] + TabsB[Iseg] / Nseg\\n\\n # outputs\\n temperature_out[flow][time] = Tout_Seg_C\\n temperature_in[flow][time] = Tin_C\\n supply_out_kW[flow][time] = q_out_kW\\n temperature_mean[flow][time] = (Tin_C + Tout_Seg_C) / 2 # Mean absorber temperature at present\\n\\n # q_gain = 0\\n # TavgB = 0\\n # TavgA = 0\\n # for Iseg in range(1, Nseg + 1):\\n # q_gain = q_gain + q_gain_Seg[Iseg] * A_seg_m2 # [W]\\n # TavgA = TavgA + TflA[Iseg] / Nseg\\n # TavgB = TavgB + TflB[Iseg] / Nseg\\n #\\n # # OUT[9] = q_gain/Area_a # in W/m2\\n # q_mtherm = (TavgB - TavgA) * C_eff * aperture_area / delts\\n # q_balance_error = q_gain - q_mtherm - q_out\\n\\n # OUT[11] = q_mtherm\\n # OUT[12] = q_balance_error\\n if flow < 4:\\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\\n Leq, l_int, aperture_area_m2) # in kW\\n if flow == 3:\\n q1 = supply_out_kW[0]\\n q2 = supply_out_kW[1]\\n q3 = supply_out_kW[2]\\n q4 = supply_out_kW[3]\\n E1 = auxiliary_electricity_kW[0]\\n E2 = auxiliary_electricity_kW[1]\\n E3 = auxiliary_electricity_kW[2]\\n E4 = auxiliary_electricity_kW[3]\\n # calculate optimal mass flow and the corresponding pressure loss\\n specific_flows_kgpers[4], specific_pressure_losses_Pa[4] = calc_optimal_mass_flow(q1, q2, q3, q4, E1, E2, E3, E4, 0,\\n mB0_r, mB_max_r, mB_min_r, 0,\\n dP2, dP3, dP4, aperture_area_m2)\\n if flow == 4:\\n # calculate pumping electricity when operatres at optimal mass flow\\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\\n Leq, l_int, aperture_area_m2) # in kW\\n dp5 = specific_pressure_losses_Pa[flow]\\n q5 = supply_out_kW[flow]\\n m5 = specific_flows_kgpers[flow]\\n # set points to zero when load is negative\\n specific_flows_kgpers[5], specific_pressure_losses_Pa[5] = calc_optimal_mass_flow_2(m5, q5, dp5)\\n\\n if flow == 5: # optimal mass flow\\n supply_losses_kW[flow] = np.vectorize(calc_qloss_network)(specific_flows_kgpers[flow], l_ext, aperture_area_m2,\\n temperature_mean[flow], Tamb_vector_C, msc_max_kgpers)\\n supply_out_pre = supply_out_kW[flow].copy() + supply_losses_kW[flow].copy()\\n auxiliary_electricity_kW[flow] = np.vectorize(calc_Eaux_SC)(specific_flows_kgpers[flow], specific_pressure_losses_Pa[flow],\\n Leq, l_int, aperture_area_m2) # in kW\\n supply_out_total_kW = supply_out_kW[flow].copy() + 0.5 * auxiliary_electricity_kW[flow].copy() - supply_losses_kW[flow].copy() # eq.(58) _[J. Fonseca et al., 2016]\\n mcp_kWperK = specific_flows_kgpers[flow] * (Cp_fluid_JperkgK / 1000) # mcp in kW/K\\n\\n result = [supply_losses_kW[5], supply_out_total_kW, auxiliary_electricity_kW[5], temperature_out[5], temperature_in[5], mcp_kWperK]\\n q_rad_per_panel = q_rad_vector*aperture_area_m2\\n return result\",\n \"def M_D_1(arrival_time,max_time,service_time=1/90):\\n #conversion in seconds\\n max_seconds = max_time*60*60\\n sim_time = 0.0 # simulation time\\n t_1 = 0.0 # time for next event (arrival)\\n t_2 = max_seconds # time for next event (departure)\\n t_n = 0.0 #last event time--> tempo dell'ultimo avvenimento generico\\n t_b = 0.0 # last start of busy time--> tempo in cui la queue inizia ad essere non vuota per l'ultima volta\\n c = 0 # numero di servizi completati\\n queue_aircraft = [] # number of aircraft in the queue\\n aircraft = 0\\n arrival = [] # time of arrival\\n attesa = [] # attesa per gli aerei-->NON SICURO CHE SI CALCOLI COSI'\\n # simulation loop\\n while(sim_time < max_seconds):\\n if(t_1<t_2): #event1:arrival\\n sim_time = t_1\\n arrival.append(t_1)\\n aircraft += 1\\n queue_aircraft.append(aircraft)\\n t_n = sim_time\\n t_1 = sim_time + rm.expovariate(arrival_time)\\n if(aircraft==1):\\n t_b = sim_time\\n t_2 = sim_time + 1/service_time\\n else:\\n sim_time = t_2\\n aircraft = aircraft -1\\n queue_aircraft.append(aircraft)\\n t_n = sim_time\\n attesa.append( t_2 - arrival[c])\\n c+=1\\n if(aircraft>0):\\n t_2=sim_time + 1/service_time\\n else:\\n t_2 = max_seconds\\n\\n\\n\\n\\n return queue_aircraft,arrival,attesa\",\n \"def qssa(k11=5e-8, k=3.3e-10, k10=1e-6, mn=30):\\n density = 1.42 * 1000 # the density of Delrin NC100, [g/dm3]\\n cs = density / mn # reactant groups concentration, [mol/L]\\n mass_loss = np.zeros_like(t)\\n rs = np.zeros_like(t)\\n acid_cons = np.array(c_water)\\n for i in range(steps-1):\\n # assume the reaction only happen with pH < 3 situation\\n if ph[i] < 4:\\n rs[i] = ((k10 * cs + k11) / (k11 + k + k10 * cs) - 1) * k10 * cs * acid_cons[i]\\n acid_cons[i + 1] = acid_cons[i] - abs(rs[i] * t_step) + S_drop * abs(N1) / V_drop * t_step\\n mass_loss[i+1] = mass_loss[i] + abs(rs[i] * t_step * mn)\\n else:\\n continue\\n volume_loss = mass_loss /density\\n pH_C = -np.log10(acid_cons) # the pH value with reaction consumption\\n depth = volume_loss / S_rand # the penetration depth for single droplet, [dm]\\n if t.shape[0] > 300000:\\n # assume the HCl gas supplying will maintain until the pH is -1.\\n try:\\n place = np.where(acid_cons > 10)\\n loc = int(place[0][0])\\n except IndexError:\\n loc = steps\\n acid_cons[loc:] = acid_cons[loc-1]\\n mass_loss[loc:] = mass_loss[loc-1]\\n for i in range(loc-1, t.shape[0]-1):\\n rs[i] = ((k10 * cs + k11) / (k11 + k + k10 * cs) - 1) * k10 * cs * acid_cons[i]\\n acid_cons[i + 1] = acid_cons[i] - abs(rs[i] * t_step) # + S_drop * abs(N1) / V_drop * t_step\\n mass_loss[i + 1] = mass_loss[i] + abs(rs[i] * t_step * mn)\\n volume_loss = mass_loss / density\\n pH_C = - np.log10(acid_cons) # the pH value with reaction consumption\\n depth = volume_loss / S_rand # the penetration depth for single droplet\\n rs[t.shape[0]-1] = rs[t.shape[0]-2]\\n rs = abs(rs)\\n return mass_loss, volume_loss, acid_cons, pH_C, depth, rs\",\n \"def next_point(self):\\n if self.verbose:\\n print(\\\"Computing acquisition function...\\\")\\n if self.acquisition_function == 'cb':\\n acq, pred = acqfunc.confidence_bound(\\n self.surrogate_model, self.X_full,\\n alpha=self.alpha, beta=self.beta)\\n elif self.acquisition_function == 'ei':\\n acq, pred = acqfunc.expected_improvement(\\n self.surrogate_model, self.X_full,\\n self.X_sparse, xi=self.xi)\\n elif self.acquisition_function == 'poi':\\n acq, pred = acqfunc.probability_of_improvement(\\n self.surrogate_model, self.X_full,\\n self.X_sparse, xi=self.xi)\\n elif isinstance(self.acquisition_function, types.FunctionType):\\n acq, pred = self.acquisition_function(\\n self.surrogate_model, self.X_full, self.X_sparse)\\n else:\\n raise NotImplementedError(\\n \\\"Choose between 'cb', 'ei', and 'poi' acquisition functions or define your own\\\")\\n self.gp_predictions.append(pred)\\n if self.mask is None:\\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\\n vals_list = acq[indices_list][::-1][:self.batch_size].tolist()\\n indices_list = np.dstack(indices_list)[0][::-1][:self.batch_size].tolist()\\n else:\\n acq = self.mask*acq\\n indices_list = np.unravel_index(np.argsort(acq.ravel()), acq.shape)\\n vals_list = acq[indices_list]\\n vals_list = vals_list[~np.isnan(vals_list)][::-1]\\n indices_list = np.dstack(indices_list)[0]\\n indices_list = indices_list[:len(vals_list)][::-1]\\n vals_list = vals_list[:self.batch_size].tolist()\\n indices_list = indices_list[:self.batch_size].tolist()\\n if not self.batch_update:\\n return vals_list, indices_list\\n if self.batch_dscale is None:\\n batch_dscale_ = self.surrogate_model.model.kernel.lengthscale.mean().item()\\n else:\\n batch_dscale_ = self.batch_dscale\\n vals_list, indices_list = self.update_points(\\n vals_list, indices_list, batch_dscale_)\\n return vals_list, indices_list\",\n \"def choose_prime_inst(given_start_date,given_end_date):\\r\\n\\r\\n #extracting primary dates where instruments are active from csv file\\r\\n inst_prime_dates = pd.read_csv(ref_path / 'GOES_primary_assignments.csv', header=3)\\r\\n\\r\\n #figuring out which instrument is primary for given start date\\r\\n for d in range(len(inst_prime_dates['Start Date'])):\\r\\n change_date = parse(inst_prime_dates['Start Date'][d])\\r\\n if given_start_date >= change_date.date():\\r\\n prime_inst = inst_prime_dates['EPEAD Primary'][d]\\r\\n backup_inst = inst_prime_dates['EPEAD Secondary'][d]\\r\\n end_date = parse(inst_prime_dates['Start Date'][d+1]).date()\\r\\n\\r\\n #if no prime instrument available, have to choose which instrument\\r\\n #to use based on which instruments have data for this date\\r\\n if str(prime_inst) == 'nan':\\r\\n if str(backup_inst) == 'nan':\\r\\n print('no information about primary instrument available.'\\r\\n 'Choosing instrument based on active date ranges')\\r\\n alternate_output = choose_inst(given_start_date,given_end_date)\\r\\n\\r\\n return(alternate_output)\\r\\n else:\\r\\n prime_inst = backup_inst\\r\\n\\r\\n break\\r\\n\\r\\n prime_inst = str(prime_inst).split('.')[0]\\r\\n\\r\\n #reformatting instrument name\\r\\n if len(prime_inst) == 2:\\r\\n inst_str = str(prime_inst)\\r\\n elif len(prime_inst) == 1:\\r\\n inst_str = '0' + str(prime_inst)\\r\\n\\r\\n print('GOES-%s is the primary instrument for given start time' %inst_str)\\r\\n\\r\\n #checking to make sure this primary instrument actually has data\\r\\n year = str(given_start_date).split('-')[0]\\r\\n month = str(given_start_date).split('-')[1]\\r\\n url = ('https://satdat.ngdc.noaa.gov/sem/goes/data/avg/'+ year + '/' +\\r\\n month + '/goes' + inst_str)\\r\\n\\r\\n try:\\r\\n request.urlopen(url)\\r\\n print('GOES-%s has data available' %inst_str)\\r\\n instrument = 'GOES-' + inst_str\\r\\n print('we are using %s as our instrument for observations' %instrument)\\r\\n\\r\\n except request.HTTPError:\\r\\n #if primary instrument doesn't have data for this date, using backup instrument\\r\\n print('GOES-%s does NOT have data available' %inst_str)\\r\\n\\r\\n #reformatting backup instrument\\r\\n if len(str(backup_inst)) == 2:\\r\\n inst_str = str(backup_inst)\\r\\n elif len(str(backup_inst)) ==1:\\r\\n inst_str = '0' + str(backup_inst)\\r\\n\\r\\n print('checking for data from backup instrument GOES-%s' %inst_str)\\r\\n\\r\\n url = ('https://satdat.ngdc.noaa.gov/sem/goes/data/avg/'+ year + '/'\\r\\n + month + '/goes' + inst_str)\\r\\n\\r\\n #checking to see if backup instrument has data for this date, if not have\\r\\n #to manually choose which instrument to use based off which instruments\\r\\n #have data available\\r\\n try:\\r\\n request.urlopen(url)\\r\\n print('backup instrument data found - using backup instrument')\\r\\n instrument = 'GOES-' + inst_str\\r\\n print('we are using %s as our instrument for observations'\\r\\n %instrument)\\r\\n\\r\\n except request.HTTPError:\\r\\n print('no knowledge of backup or primary instrument - choosing '\\r\\n 'instrument based on available data')\\r\\n alternate_output = choose_inst(given_start_date,given_end_date)\\r\\n\\r\\n return(alternate_output)\\r\\n\\r\\n return([instrument,end_date])\",\n \"def calc(self,index,counter_values):\\n gr = self.grSign * self.grPitch['Value'].value\\n m = self.mSign * self.mPitch['Value'].value\\n \\n offsetG,offsetM = self.checkOffset()\\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\\n alpha = (2.0*theta) + beta\\n numerator = (math.sin(alpha) + math.sin(beta))\\n denominator = (self.DiffrOrder * self.look_at_grx())\\n wavelength = numerator / denominator\\n \\n if wavelength == 0.0:\\n energy_physicalmot = 0.0\\n else:\\n energy_physicalmot = self.hc / wavelength\\n #if self.FixedM2Pit: \\n Cff = math.cos(beta)/math.cos(alpha)\\n if energy_physicalmot < 0 :\\n #warning: wavelength se vuelve negativo ... ??????\\n energy_physicalmot = energy_physicalmot *(-1) \\n \\n # Real Energy is equal to the energy calculated by the encoders\\n # minus an offset that depends on the same energy calculated by the \\n # encoders:\\n # E_physicalmot = Ereal + offset\\n # with offset = a*Ereal + b\\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \\n a_coeff = self.EnergyDP.a_offset_coeff\\n b_coeff = self.EnergyDP.b_offset_coeff\\n numerator = energy_physicalmot - b_coeff\\n denominator = 1 + a_coeff\\n energy = numerator / denominator\\n \\n if index == 1:\\n return energy\\n elif index == 2:\\n return Cff\",\n \"def get_FAAM_mineral_dust_calibration(instrument='PCASP', rtn_values=True):\\n # Location and name of calibration files?\\n folder = '{}/FAAM/'.format(get_local_folder('ARNA_data'))\\n if instrument == 'PCASP':\\n # NOTE: range ~0.1-4 microns\\n filename = 'PCASP1_faam_20200128_v001_r000_cal.nc'\\n # NOTE: dust values are a nc subgroup!\\n # group = 'bin_cal'\\n group = 'bin_cal/mineral_dust'\\n # group = 'flow_cal'\\n # The real part of the refractive index was taken as 1.53 which is a common value and is in the OPAC database. It is quite a bit smaller than the 1.547 that was reported by Weinzierl et al. [2011] but has been shown to have a relatively weak effect on the instrument response. The values of the imaginary part were based on references in Ryder et al. [2019] along with the frequency distribution of k(550nm) presented in fig 9 of Ryder et al. [2013]. So the minimum value was extended from 0.0015i to 0.001i. Calculating the bin boundaries with these multiple Mie curves was done with Gaussian centre-weighted averaging with 0.001i and 0.0024i being +/-2 sigma extreme values.\\n elif instrument == 'CDP':\\n # NOTE: range ~4-120 microns\\n filename = 'CDP1_faam_20200208_v001_r000_cal.nc'\\n # NOTE: dust values are a nc subgroup!\\n group = 'master_cal/mineral_dust'\\n # Open and return the widths and\\n ds = xr.open_dataset(folder+filename, group=group)\\n # Get values for bin centres and widths in microns (1E-6 metres)\\n BinWidths = ds['dia_width'].values.flatten()\\n BinCentres = ds['dia_centre'].values.flatten()\\n d = {'BinWidths': BinWidths, 'BinCentres': BinCentres}\\n if rtn_values:\\n return d\\n else:\\n return ds\",\n \"def __init__(self):\\r\\n \\r\\n # Define temporal range\\r\\n self.timelimit = np.zeros(2,dtype=datetime.datetime)\\r\\n self.timelimit[0] = datetime.datetime(1990,1,1)\\r\\n self.timelimit[1] = datetime.datetime(2050,1,1)\\r\\n \\r\\n ### emissions \\r\\n \\r\\n # Load in historical emissions by sector.\\r\\n self.year_E_hist_ccc, self.total_E_hist_ccc, self.sector_E_hist_ccc, self.sector_name_E, self.num_years_E_hist = load_historical_emissions()\\r\\n # Load in government emissions forecast.\\r\\n self.year_E_fore_gov, self.elms_E_fore_gov, self.total_E_fore_gov, self.total_E_fore_gov_95CI, sector_E_fore_gov, sector_name_E_fore_gov, self.num_years_E_fore = load_precovid_emission_gov_estimate()\\r\\n \\r\\n # Define Targets\\r\\n self.paris_wb_2 = (1-0.8) * self.total_E_hist_ccc[0]\\r\\n self.net_zero = 0 \\r\\n \\r\\n # Reorder to be consistent \\r\\n self.num_E_sectors = len(self.sector_name_E) \\r\\n org_hist_gov = np.zeros(self.num_E_sectors,dtype=int) \\r\\n \\r\\n for sec1 in range(0,self.num_E_sectors):\\r\\n \\r\\n for sec2 in range(0,self.num_E_sectors):\\r\\n \\r\\n if self.sector_name_E[sec1] == sector_name_E_fore_gov[sec2]:\\r\\n \\r\\n org_hist_gov[sec1] = sec2\\r\\n \\r\\n break\\r\\n \\r\\n elif (self.sector_name_E[sec1] == 'Land use, land use change and forestry' and sector_name_E_fore_gov[sec2] == 'LULUCF'):\\r\\n \\r\\n org_hist_gov[sec1] = sec2\\r\\n \\r\\n break\\r\\n \\r\\n \\r\\n # sector name short form (for plotting)\\r\\n \\r\\n self.sector_name_E_sf = np.array(['EneS','Bus','Tran','Pub','Res','Agr','IndP','LULUCF','WM'])\\r\\n self.sector_E_fore_gov = sector_E_fore_gov[org_hist_gov,:]\\r\\n\\r\\n ### economy\\r\\n \\r\\n # Load in historical economic data\\r\\n self.year_gdp_hist_ons, self.gdp_hist_ons, self.num_years_gdp_hist = load_annual_GDP_ons()\\r\\n self.month_gdp_hist_ons, self.gdp_hist_ons_mnth, self.num_months_gdp_hist = load_covid_GDP_ons() # By month\\r\\n \\r\\n # Load in projection of GDP\\r\\n self.year_gdp_fore_gov, self.elms_gdp_fore_gov, self.frac_change_gdp_fore_gove, self.num_years_gdp_fore = load_precovid_annual_GDP_estimate()\\r\\n \\r\\n # Find forecasted absolute values of GDP\\r\\n self.gdp_fore_gov = np.zeros(self.num_years_E_fore)\\r\\n \\r\\n for yr1 in range(0,self.num_years_E_fore):\\r\\n \\r\\n # Match Absolute Historical value to GDP before forecast year otherwise use percent change\\r\\n if self.elms_E_fore_gov[yr1] == False:\\r\\n \\r\\n for yr2 in range(0,self.num_years_gdp_hist):\\r\\n \\r\\n if self.year_gdp_hist_ons[yr1] == self.year_gdp_hist_ons[yr2]:\\r\\n \\r\\n self.gdp_fore_gov[yr1] = self.gdp_hist_ons[yr2]\\r\\n \\r\\n break\\r\\n \\r\\n else:\\r\\n \\r\\n break\\r\\n \\r\\n self.gdp_fore_gov[self.elms_E_fore_gov] = self.gdp_fore_gov[self.elms_E_fore_gov==False][-1] * (1+np.cumsum(self.frac_change_gdp_fore_gove[self.elms_gdp_fore_gov]))\\r\\n \\r\\n ### carbon intensity (eta)\\r\\n self.eta_gdp_hist = np.zeros(self.num_years_E_hist)\\r\\n\\r\\n # Historical \\r\\n for yr1 in range(0,self.num_years_gdp_hist):\\r\\n \\r\\n for yr2 in range(0,self.num_years_E_hist):\\r\\n \\r\\n if self.year_gdp_hist_ons[yr1] == self.year_E_hist_ccc[yr2]:\\r\\n \\r\\n self.eta_gdp_hist[yr1] = self.total_E_hist_ccc[yr2]/self.gdp_hist_ons[yr1]\\r\\n \\r\\n break\\r\\n # Forecast\\r\\n self.eta_gdp_fore = self.total_E_fore_gov/self.gdp_fore_gov\\r\\n \\r\\n ### COVID 19 Deaths\\r\\n self.day_mort_gov, self.mort_per_day_gov, self.R_per_day_gov = load_COVID19_mort()\\r\\n \\r\\n ### Google mobility\\r\\n self.day_m_google, self.m_google = load_google_mobility()\\r\\n \\r\\n self.tau_us, self.tau_as, self.Y_run, self.eta_run, self.E_run, self.R_run, self.m_run, self.mu_run = run_simulations()\\r\\n \\r\\n \\r\\n self.num_sec = len(self.tau_us)\\r\\n self.startdate_run = datetime.datetime(2020,1,31)\\r\\n self.endate_run = datetime.datetime(2050,1,1)\\r\\n self.num_days_run = len(self.Y_run[:,0])\\r\\n self.date_run = np.zeros(self.num_days_run,dtype=datetime.datetime)\\r\\n self.date_run[0] = self.startdate_run\\r\\n for day in range(1,self.num_days_run):\\r\\n \\r\\n self.date_run[day] = self.date_run[day-1] + datetime.timedelta(days=1)\\r\\n \\r\\n return\",\n \"def get_cape(temp,pres,dewpt,hght,startp,startt,startdp,totalcape=False): \\n\\n # Check units\\n # Init temp is startt in C, Init dew point is stwrtdp,\\n # pressure levels are in hPa \\n temp = temp - 273.15 # convert temperature to celsius\\n dewpt = dewpt - 273.15 # convert dewpoint to celsius\\n pres = pres/100 # convert pressure to hPa\\n \\n \\n inds = np.where( (pres < startp) ) \\n tmp = pres[inds]\\n del pres\\n #pres = tmp[::-1]\\n pres = tmp[:]\\n del tmp \\n startp = startp/100\\n \\n tmp = temp[inds]\\n del temp\\n #temp = tmp[::-1]\\n temp = tmp[:]\\n del tmp \\n\\n tmp = dewpt[inds]\\n del dewpt\\n #dewpt = tmp[::-1]\\n dewpt = tmp[:]\\n del tmp \\n\\n tmp = hght[inds]\\n del hght\\n #hght = tmp[::-1]\\n hght = tmp[:]\\n del tmp \\n\\n \\n # Get Sub-LCL traces \\n presdry,tempdry,tempiso=dry_ascent(startp,startt-degCtoK,startdp-degCtoK) \\n \\n\\n # make lcl variables explicit\\n P_lcl=presdry[-1]\\n T_lcl=tempdry[-1]\\n\\n # Now lift a wet parcel from the intersection point\\n # preswet=linspace(P_lcl,100,101)\\n preswet,tempwet=moist_ascent(P_lcl,T_lcl)\\n\\n # tparcel is the concatenation of tempdry and \\n # tempwet, and so on.\\n \\n tparcel=np.concatenate((tempdry,tempwet[1:]))\\n pparcel=np.concatenate((presdry,preswet[1:]))\\n\\n # Interpolating the environmental profile onto the \\n # parcel pressure coordinate\\n # tempenv=interp(preswet,pres[::-1],temp[::-1])\\n ## NEW, for total column:\\n tempenv=interp(pparcel,pres[::-1],temp[::-1])\\n\\n\\n # now solve for the equlibrium levels above LCL\\n # (all of them, including unstable ones)\\n # eqlev,stab=solve_eq(preswet[::-1],(tempwet-tempenv)[::-1])\\n # NEW, for total column:\\n # On second thought, we don't really want/need\\n # any equilibrium levels below LCL\\n # eqlev,stab=solve_eq(pparcel[::-1],(tparcel-tempenv)[::-1])\\n # This is equivalent to the old statement :\\n eqlev,stab=solve_eq(pparcel[pparcel<=P_lcl][::-1],\\\\\\n (tparcel-tempenv)[pparcel<=P_lcl][::-1])\\n\\n aa = tparcel-tempenv\\n\\n # Sorting index by decreasing pressure\\n I=np.argsort(eqlev)[::-1]\\n eqlev=eqlev[I]; stab=stab[I]\\n\\n # temperatures at the equilibrium level\\n # tempeq=interp(eqlev,preswet[::-1],tempenv[::-1])\\n ## NEW, for total column:\\n tempeq=interp(eqlev,pparcel[::-1],tparcel[::-1])\\n\\n # This helps with debugging\\n # for ii,eq in enumerate(eqlev):\\n # print \\\"%5.2f %5.2f %2d\\\"%(eq,tempeq[ii],stab[ii])\\n\\n # need environmental temperature at LCL\\n tenv_lcl=interp(P_lcl,pparcel[::-1],tempenv[::-1])\\n\\n isstab=np.where(stab==1.,True,False)\\n unstab=np.where(stab==1.,False,True) \\n\\n if eqlev.shape[0]==0:\\n # no unstable layers in entire profile\\n # because the parcel never crosses the tenv\\n P_lfc=float('NaN')\\n P_el=float('NaN')\\n elif T_lcl>tenv_lcl:\\n # check LCL to see if this is unstable\\n P_lfc=P_lcl\\n if totalcape:\\n P_el=eqlev[isstab][-1]\\n else:\\n P_el=eqlev[isstab][0]\\n elif eqlev.shape[0]>1:\\n # Parcel is stable at LCL so LFC is the \\n # first unstable equilibrium level and \\n # \\\"EQ\\\" level is the first stable equilibrium \\n # level\\n P_lfc=eqlev[unstab][0]\\n if totalcape:\\n P_el=eqlev[isstab][-1]\\n else:\\n P_el=eqlev[isstab][0]\\n else:\\n # catch a problem... if there is only\\n # one eqlev and it's stable (this is \\n # unphysical), then it could be a vertical\\n # resolution thing. This is a kind of \\n # \\\"null\\\" option\\n try:\\n\\t P_el=eqlev[isstab][0]\\n P_lfc=eqlev[isstab][0]\\n except:\\n\\t P_el=eqlev[unstab][0]\\n P_lfc=eqlev[unstab][0]\\t\\n\\t\\n if np.isnan(P_lfc):\\n return P_lcl,P_lfc,P_el,0,0\\n\\n # need to handle case where dwpt is not available \\n # above a certain level for any reason. Most simplest \\n # thing to do is set it to a reasonably low value; \\n # this should be a conservative approach!\\n \\n #dwpt=dewpt.copy().soften_mask()\\n [inds] = np.where(np.isnan(dewpt))\\n dwpt = dewpt\\n dwpt[inds] = dwpt.min()\\n \\n # raise ValueError\\n #if dwpt[(pres>=P_el).data*(pres<P_lfc).data].mask.any():\\n # print \\\"WARNING: substituting dwpt.min() for masked values of DWPT in this sounding\\\"\\n #dwpt[dwpt.mask]=dwpt.min()\\n # dwptenv=interp(preswet,pres[::-1],dwpt[::-1])\\n # NEW:\\n\\n dwptenv=interp(pparcel,pres[::-1],dwpt[::-1])\\n\\n\\n \\n #if hght[(pres>=P_el).data].mask.any():\\n # raise NotImplementedError, \\\"TODO: Implement standard atmosphere to substitute missing heights\\\"\\n # hghtenv=interp(preswet,pres[::-1],self.soundingdata['hght'][::-1])\\n # NEW:\\n hghtenv=interp(pparcel,pres[::-1],hght[::-1])\\n \\n\\n # Areas of POSITIVE Bouyancy\\n # cond1=(tempwet>=tempenv)*(preswet<=P_lfc)*(preswet>P_el)\\n # NEW:\\n cond1=(tparcel>=tempenv)*(pparcel<=P_lfc)*(pparcel>P_el)\\n # Areas of NEGATIVE Bouyancy\\n # cond2=(tempwet<tempenv)*(preswet<=P_lcl)*(preswet>P_el)\\n # NEW:\\n if totalcape:\\n cond2=(tparcel<tempenv)*(pparcel>P_el)\\n else:\\n cond2=(tparcel<tempenv)*(pparcel>P_lfc)\\n # Do CAPE calculation\\n # 1. Virtual temperature of parcel... remember it's saturated above LCL.\\n # e_parcel=SatVap(tempwet)\\n # Tv_parcel=VirtualTemp(tempwet+degCtoK,preswet*100.,e_parcel)\\n # e_env=SatVap(dwptenv)\\n # Tv_env=VirtualTemp(tempenv+degCtoK,preswet*100.,e_env)\\n # NEW:\\n e_parcel=SatVap(tparcel)\\n Tv_parcel=VirtualTemp(tparcel+degCtoK,pparcel*100.,e_parcel)\\n e_env=SatVap(dwptenv)\\n Tv_env=VirtualTemp(tempenv+degCtoK,pparcel*100.,e_env)\\n\\n CAPE=trapz(9.81*(Tv_parcel[cond1]-Tv_env[cond1])/Tv_env[cond1],hghtenv[cond1])\\n CIN=trapz(9.81*(Tv_parcel[cond2]-Tv_env[cond2])/Tv_env[cond2],hghtenv[cond2])\\n\\n return P_lcl,P_lfc,P_el,CAPE,CIN\",\n \"def specvol(SA, CT, p):\\n\\n SA = np.maximum(SA, 0)\\n\\n xs = np.sqrt(sfac * SA + soffset)\\n ys = CT * 0.025\\n z = p * 1e-4\\n\\n specific_volume = (v000\\n + xs * (v100 + xs * (v200 + xs * (v300 + xs * (v400 + xs * (v500\\n + xs * v600)))))\\n + ys * (v010\\n + xs * (v110 + xs * (v210 + xs * (v310 + xs * (v410 + xs * v510))))\\n + ys * (v020 + xs * (v120 + xs * (v220 + xs * (v320 + xs * v420)))\\n + ys * (v030 + xs * (v130 + xs * (v230 + xs * v330))\\n + ys * (v040 + xs * (v140 + xs * v240)\\n + ys * (v050 + xs * v150 + ys * v060)))))\\n + z * (v001\\n + xs * (v101 + xs * (v201 + xs * (v301 + xs * (v401 + xs * v501))))\\n + ys * (v011 + xs * (v111 + xs * (v211 + xs * (v311 + xs * v411)))\\n + ys * (v021 + xs * (v121 + xs * (v221 + xs * v321))\\n + ys * (v031 + xs * (v131 + xs * v231)\\n + ys * (v041 + xs * v141 + ys * v051))))\\n + z * (v002\\n + xs * (v102 + xs * (v202 + xs * (v302 + xs * v402)))\\n + ys * (v012 + xs * (v112 + xs * (v212 + xs * v312))\\n + ys * (v022 + xs * (v122 + xs * v222)\\n + ys * (v032 + xs * v132 + ys * v042)))\\n + z * (v003\\n + xs * (v103 + xs * v203)\\n + ys * (v013 + xs * v113 + ys * v023)\\n + z * (v004 + xs * v104 + ys * v014\\n + z * (v005 + z * v006))))))\\n\\n return specific_volume\",\n \"def acquisition(self):\\r\\n fs, _ = self.gp.predict(self.gp.X)\\r\\n next_fs, vars = self.gp.predict(self.X_s)\\r\\n opt = np.min(fs)\\r\\n improves = opt - next_fs - self.xsi\\r\\n Z = improves / vars\\r\\n eis = improves * norm.cdf(Z) + vars * norm.pdf(Z)\\r\\n return self.X_s[np.argmax(eis)], eis\",\n \"def get_requested_supply_air_temperature_for_cooling(\\n theta_sur_c: np.ndarray, theta_ac: np.ndarray, l_d_cs: np.ndarray, v_d_supply: np.ndarray,\\n psi: float, l_duct: np.ndarray) -> np.ndarray:\\n\\n c = get_specific_heat()\\n rho = get_air_density()\\n\\n l_duct = np.array(l_duct).reshape(1,5).T\\n\\n theta_req_c = theta_sur_c - (theta_sur_c - theta_ac + l_d_cs * 10 ** 6 / (v_d_supply * c * rho)) \\\\\\n * np.exp(psi * l_duct * 3600 / (v_d_supply * c * rho))\\n\\n return np.minimum(theta_req_c, theta_ac)\",\n \"def sample_consumption():\\n product = Product(\\\"NameA\\\", 15, 17.85, 0.07, \\\"oak\\\", 0.08, \\\"ENplusA1\\\",\\n \\\"Pelletics.cz\\\", date(2020, 12, 20))\\n delivery = Delivery(product, \\\"Pellets2Home\\\", 7350, 42500,\\n date(2020, 12, 20))\\n some_datetime = datetime(2020, 11, 20, 14, 22, 46, 0)\\n consumption = Consumption(some_datetime, delivery, 30, \\\"30 kgs\\\")\\n return consumption\",\n \"def get_rates(c, a, K, t, nu=lambda t: 1.0, mu=lambda t: 1.0, b=lambda S: 1.0,\\r\\n d=lambda S: 1.0, availability_function=None):\\r\\n # compute stimulus: interaction mat. x ag. conc. x competition\\r\\n if availability_function is not None:\\r\\n # antigenic trigger vector (1 entry per clone)\\r\\n antigenic_trigger = c.dot(K)\\r\\n S = K.dot(a * availability_function(antigenic_trigger))\\r\\n # no competition function\\r\\n else:\\r\\n # stimulus for clone i= interaction matrix\\r\\n S = K.dot(a)\\r\\n\\r\\n # returns absolute rate, total rate\\r\\n bS, dS = b(S) * nu(t), d(S) * mu(t)\\r\\n return bS, dS\",\n \"def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):\",\n \"def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\\n phi = 0.0\\n\\n ## Approach A - NREL Approach\\n if approach_call == \\\"A\\\":\\n\\n phi = float(Q_load_W) / float(Q_design_W)\\n eta_max = 0.425 # from energy.gov\\n\\n if phi >= phi_threshold: # from NREL-Shape\\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\\n\\n if phi < phi_threshold:\\n if phi <= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\\n\\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3.0 + \\\\\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\\n\\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\\\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\\n\\n eta_therm_max = 0.45 # constant, after energy.gov\\n\\n if phi < phi_threshold:\\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\\n\\n else:\\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\\n\\n ## Approach B - Empiric Approach\\n if approach_call == \\\"B\\\":\\n\\n if Q_design_W > 0:\\n phi = float(Q_load_W) / float(Q_design_W)\\n\\n else:\\n phi = 0\\n\\n eta_el_max = 0.39\\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\\n\\n eta_el = eta_el_max * eta_el_score\\n eta_therm = eta_therm_max * eta_therm_score\\n\\n if phi < 0.2:\\n eta_el = 0\\n\\n return eta_el, eta_therm\",\n \"def _nextObservation(self):\\n frame = np.array(self.df.loc[(self.currentStep - (self.time_lag - 1)):self.currentStep,['return_Low','return_Volume']].values)\\n obs = (frame,np.array([self.balance/10000,self.buy_amount/10000,self.sell_amount/10000])) # standardize the value\\n return obs\",\n \"def get_beta(self, epoch, beta_start=None, beta_end=None):\\r\\n if beta_start is None:\\r\\n beta_start = self.beta_start\\r\\n if beta_end is None:\\r\\n beta_end = self.beta_end\\r\\n\\r\\n if epoch < beta_start:\\r\\n return self.beta0\\r\\n elif beta_start <= epoch <= beta_end:\\r\\n if self.schedule_type == 'constant':\\r\\n return self.beta0\\r\\n elif self.schedule_type == 'linear':\\r\\n return (self.beta0\\r\\n + (self.beta1 - self.beta0) * (epoch - beta_start)\\r\\n / (beta_end - beta_start))\\r\\n elif self.schedule_type == 'cosine':\\r\\n return self.cosine_annealing(epoch, beta_start, beta_end)\\r\\n elif self.schedule_type == 'cosine-restarts':\\r\\n cycle_len = (beta_end - beta_start) // self.cycles\\r\\n cycle_idx = (epoch - beta_start) // cycle_len\\r\\n start_epoch = beta_start + cycle_len * cycle_idx\\r\\n end_epoch = beta_start + cycle_len * (cycle_idx + 1)\\r\\n return self.cosine_annealing(epoch, start_epoch, end_epoch)\\r\\n else:\\r\\n raise ValueError('Unsupported schedule type {}'\\r\\n .format(self.schedule_type))\\r\\n else:\\r\\n return self.beta1\",\n \"def AmericanBinomialPricer(pricing_engine, option, data):\\r\\n\\r\\n\\r\\n expiry = option.expiry\\r\\n strike = option.strike\\r\\n (spot, rate, volatility, dividend) = data.get_data()\\r\\n steps = pricing_engine.steps\\r\\n nodes = steps + 1\\r\\n dt = expiry / steps \\r\\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \\r\\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\\r\\n pu = (np.exp(rate * dt) - d) / (u - d)\\r\\n pd = 1 - pu\\r\\n disc = np.exp(-rate * expiry)\\r\\n spotT = 0.0\\r\\n payoffT = 0.0\\r\\n callT = 0.0\\r\\n putT= 0.0\\r\\n #call\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n callT = max(callT, spotT-strike)\\r\\n price = disc * payoffT\\r\\n #put\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n putT = max(putT, strike-spot)\\r\\n price = disc * payoffT\\r\\n \\r\\n return price\",\n \"def calculate_expected_return(beta, alpha, risk_free_rate, market_returns):\\n return risk_free_rate + beta * (market_returns - risk_free_rate)\",\n \"def beta_range_s_circular(s,sma):\\n #sma**2. = s**2. + y**2.\\n if s > sma: #failure mode/nonphysical\\n s = sma\\n y = np.sqrt(sma**2.-s**2.)\\n beta_min = np.pi/2. - np.arctan2(y,s)\\n beta_max = np.pi/2. + np.arctan2(y,s)\\n return beta_min, beta_max\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59520787","0.57533324","0.5703326","0.56623435","0.560426","0.5583759","0.55615014","0.5517298","0.5457148","0.54422075","0.53810215","0.53772193","0.5371446","0.53696233","0.5366299","0.5357143","0.5323624","0.53230184","0.5311603","0.5301882","0.52647996","0.5262116","0.5241638","0.5225254","0.5214253","0.52052003","0.5204419","0.5199606","0.5179427","0.5175669","0.5174242","0.5164181","0.513559","0.51343226","0.51206154","0.5110665","0.5107141","0.5105078","0.50880134","0.50723565","0.5067815","0.50666517","0.50665367","0.5064309","0.5059056","0.5052029","0.5049494","0.5046216","0.50342923","0.50338966","0.50330347","0.502398","0.50212574","0.5019749","0.5018276","0.50175905","0.50145936","0.50083816","0.50029767","0.49992263","0.49874187","0.49807245","0.4975722","0.49688253","0.49678877","0.4966858","0.4964492","0.496242","0.4960456","0.49562427","0.495264","0.49507076","0.49473894","0.49467406","0.49280748","0.4922737","0.49185663","0.4914938","0.4887124","0.4884939","0.48847646","0.48712993","0.48636758","0.48591992","0.4856111","0.4854738","0.485134","0.48459938","0.4835193","0.48304638","0.48255762","0.48255447","0.48228148","0.48137364","0.48135713","0.4810946","0.48053202","0.48039645","0.4803252","0.48007485"],"string":"[\n \"0.59520787\",\n \"0.57533324\",\n \"0.5703326\",\n \"0.56623435\",\n \"0.560426\",\n \"0.5583759\",\n \"0.55615014\",\n \"0.5517298\",\n \"0.5457148\",\n \"0.54422075\",\n \"0.53810215\",\n \"0.53772193\",\n \"0.5371446\",\n \"0.53696233\",\n \"0.5366299\",\n \"0.5357143\",\n \"0.5323624\",\n \"0.53230184\",\n \"0.5311603\",\n \"0.5301882\",\n \"0.52647996\",\n \"0.5262116\",\n \"0.5241638\",\n \"0.5225254\",\n \"0.5214253\",\n \"0.52052003\",\n \"0.5204419\",\n \"0.5199606\",\n \"0.5179427\",\n \"0.5175669\",\n \"0.5174242\",\n \"0.5164181\",\n \"0.513559\",\n \"0.51343226\",\n \"0.51206154\",\n \"0.5110665\",\n \"0.5107141\",\n \"0.5105078\",\n \"0.50880134\",\n \"0.50723565\",\n \"0.5067815\",\n \"0.50666517\",\n \"0.50665367\",\n \"0.5064309\",\n \"0.5059056\",\n \"0.5052029\",\n \"0.5049494\",\n \"0.5046216\",\n \"0.50342923\",\n \"0.50338966\",\n \"0.50330347\",\n \"0.502398\",\n \"0.50212574\",\n \"0.5019749\",\n \"0.5018276\",\n \"0.50175905\",\n \"0.50145936\",\n \"0.50083816\",\n \"0.50029767\",\n \"0.49992263\",\n \"0.49874187\",\n \"0.49807245\",\n \"0.4975722\",\n \"0.49688253\",\n \"0.49678877\",\n \"0.4966858\",\n \"0.4964492\",\n \"0.496242\",\n \"0.4960456\",\n \"0.49562427\",\n \"0.495264\",\n \"0.49507076\",\n \"0.49473894\",\n \"0.49467406\",\n \"0.49280748\",\n \"0.4922737\",\n \"0.49185663\",\n \"0.4914938\",\n \"0.4887124\",\n \"0.4884939\",\n \"0.48847646\",\n \"0.48712993\",\n \"0.48636758\",\n \"0.48591992\",\n \"0.4856111\",\n \"0.4854738\",\n \"0.485134\",\n \"0.48459938\",\n \"0.4835193\",\n \"0.48304638\",\n \"0.48255762\",\n \"0.48255447\",\n \"0.48228148\",\n \"0.48137364\",\n \"0.48135713\",\n \"0.4810946\",\n \"0.48053202\",\n \"0.48039645\",\n \"0.4803252\",\n \"0.48007485\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.494033"},"document_rank":{"kind":"string","value":"74"}}},{"rowIdx":84680,"cells":{"query":{"kind":"string","value":"Compute the aggregate capital stock and employment, K and N FORWARD from Chebyshev polynomials"},"document":{"kind":"string","value":"def CalculateChebyPaths(self):\n Kmin, Kmax = self.Kmin, self.Kmax\n self.apath = array([0 for y in range(self.T)], dtype=float)\n self.cpath = array([0 for y in range(self.T)], dtype=float)\n self.npath = array([0 for y in range(self.T)], dtype=float)\n # generate each generation's asset, consumption and labor supply forward\n for y in range(self.T-1): # y = 0, 1,..., 58\n self.cpath[y] = self.chebeval(array([self.apath[y]]),self.ac[y],Kmin,Kmax)\n # if self.cpath[y] < 0:\n # self.cpath[y] = 0\n if y >= self.W:\n income = self.b\n else:\n self.npath[y] = self.chebeval(array([self.apath[y]]),self.an[y],Kmin,Kmax)\n income = (1-self.tau)*self.w*self.npath[y]\n self.apath[y+1] = (1+self.r)*self.apath[y] + income - self.cpath[y]\n self.upath[y] = self.util(self.cpath[y], self.npath[y])\n # the oldest generation's consumption and labor supply\n self.cpath[self.T-1] = (1+self.r)*self.apath[self.T-1] + self.b\n # self.cpath[self.T-1] = self.chebeval(array([self.apath[self.T-1]]),self.ac[self.T-1],Kmin,Kmax)\n self.upath[self.T-1] = self.util(self.cpath[self.T-1], self.npath[self.T-1])\n # print self.cpath, self.apath, self.npath"},"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 chebyshev_polynomial(X, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n T_k = list()\n T_k.append(sp.eye(X.shape[0]).tocsr())\n T_k.append(X)\n\n def chebyshev_recurrence(T_k_minus_one, T_k_minus_two, X):\n X_ = sp.csr_matrix(X, copy=True)\n return 2 * X_.dot(T_k_minus_one) - T_k_minus_two\n\n for i in range(2, k+1):\n T_k.append(chebyshev_recurrence(T_k[-1], T_k[-2], X))\n\n return T_k","def incumbant_firm(self, wage):\n \n \n \n # a. demand for capital (capital policy function)\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\n \n # b. demand of labor (labor policy function)\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\n \n # c. incumbant profit\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\n \n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\n W = pi / (1-self.rho)\n \n return pol_k, pol_n, pi, W","def Fx_case_B_Chris(z, x, gamma):\n \n if z == 0 and x == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n alp = alpha(z, x, beta2)\n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n\n kap = 2*(alp - z)/beta\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\n \n N1 = sin2a - beta*kap\n N2 = (1+x)*sin2a - beta*kap\n D = kap - beta*(1+x)*sin2a\n \n #out = (1+x)*(N1*N2 )/D**3\n\n ### SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\n NSC = (1 + beta2 - beta*kap*sin2a + x - cos2a*(1 + beta2*(1 + x)) ) / (gamma**2-1) \n out = (1+x)*(N1*N2 + NSC)/D**3\n return out","def calculate_profit(self):","def _ei_halluc_acq(x):\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\n Z = (mu - curr_best) / sigma\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)","def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\n total_capital = capital * leverage\n df = data\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\n lambda x: len(x))\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\n df['profit'] = df.eval('(sell-buy)*qty')\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\n df['net_profit'] = df.eval('profit - commission - slippage')\n return df","def AmericanBinomialPricer(pricing_engine, option, data):\r\n\r\n\r\n expiry = option.expiry\r\n strike = option.strike\r\n (spot, rate, volatility, dividend) = data.get_data()\r\n steps = pricing_engine.steps\r\n nodes = steps + 1\r\n dt = expiry / steps \r\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \r\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\r\n pu = (np.exp(rate * dt) - d) / (u - d)\r\n pd = 1 - pu\r\n disc = np.exp(-rate * expiry)\r\n spotT = 0.0\r\n payoffT = 0.0\r\n callT = 0.0\r\n putT= 0.0\r\n #call\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n callT = max(callT, spotT-strike)\r\n price = disc * payoffT\r\n #put\r\n for i in range(nodes):\r\n spotT = spot * (u ** (steps - i)) * (d ** (i))\r\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \r\n spotT = spotT/d\r\n putT = max(putT, strike-spot)\r\n price = disc * payoffT\r\n \r\n return price","def Fx_case_C(z, x, gamma, alp, lamb):\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n eta = eta_case_C(z, x, beta2, alp, lamb)\n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a)\n \n #N1 = (1 + beta2)*(1+x)\n #N2 = -(1 + beta2*(1+x)**2)*cos2a\n #N3 = (eta - beta*kap + beta2*lamb*(1+x))*sin2a\n #return (N1+N2+N3)/D**3\n\n N_Ex = 1+x - cos2a + (eta - beta*kap)*sin2a\n N_By = beta*( (1+x)*cos2a - 1 - lamb*sin2a )\n \n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\n \n return (1+x)*(N_Ex - beta*N_By)/D**3","def stockdon2006(H,L,B):\n \n # Make sure parameters are double\n H = np.double(H)\n L = np.double(L)\n B = np.double(B)\n \n # Compute incident swash (equation 11) \n incSwash = 1.1 / 2 * 0.75 * B * (H*L)**0.5\n \n # Infragravity swash (Equation 12)\n igSwash = 1.1 / 2 * 0.06 * (H*L)**0.5\n \n # Compute R2% (Equation 19)\n setup = 1.1 * 0.35 * B * ((H * L)**0.5)\n swash = 1.1 / 2.0 * (H*L * (0.563 * B**2 + 0.004))**0.5 \n r2 = setup + swash\n \n return r2,setup,incSwash,igSwash","def sexp(p,n,res_field=RR):\n assert n>=2, \"Carleman matrix must at least be of size 2 to retrieve the coefficients. But given was \" + repr(n)\n CM = p.carleman_matrix(n)\n ev = [ r[0] for r in CM.charpoly().roots(QQbar) ]\n assert len(ev) == n, \"Carleman matrix must have exactly \" + repr(n) + \"eigenvalues, but has \" + repr(len(ev))\n\n #We want to compute:\n #sum over k: evk^t*(CM-ev1*I)*(CM-ev2*I)*. omit k * (CM-evn*I)/(evk-ev1)*.. omit k *(evk-evn)\n Char = [0]*n\n for k in range(n):\n #here is possibility for improvement of precision\n #to separate the fractional from the root parts\n #expanding the product\n Char[k] = CM - ev[k]*identity_matrix(n)\n\n #we want to have the first row of the product of the matrices\n #thatswhy we mulitply in front with:\n prod = vector(QQbar,[0,1]+[0]*(n-2))\n prodwo = [0]*n\n for k in range(n):\n prodwo[k]=prod #these are the first terms until k-1\n\n #no need to continue\n if k == n-1:\n break\n\n #and we add the terms starting with k+1\n for i in range(k+1,n):\n prodwo[k] = prodwo[k] * Char[i]\n\n prod = prod * Char[k]\n\n sprodwo = [0]*n\n for k in range(n):\n if k==0:\n sprodwo[k] = ev[k] - ev[1]\n start = 2\n else:\n sprodwo[k] = ev[k] - ev[0]\n start = 1\n\n for i in range(start,n):\n if i != k:\n sprodwo[k] = sprodwo[k] * (ev[k] - ev[i])\n\n for k in range(n):\n print ev[k]\n print prodwo[k][0]/sprodwo[k]\n print res_field\n #return lambda t: sum(res_field(ev[k])**t*res_field(prodwo[k][0]/sprodwo[k]) for k in range(n))\n return [ev,[prodwo[k][0]/sprodwo[k] for k in range(n)]]","def chebyshev_polynomials(adj, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0]))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k+1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return sparse_to_tuple(t_k)","def chebyshev_polynomials(adj, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0]))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k+1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return sparse_to_tuple(t_k)","def Es_case_B(z, x, gamma):\n \n if z == 0 and x == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n #alp = alpha(z, x, beta2)\n alp = alpha_exact_case_B_brentq(z, x, beta)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n\n kap = 2*(alp - z)/beta\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\n \n N1 = cos2a - (1+x)\n N2 = (1+x)*sin2a - beta*kap\n D = kap - beta*(1+x)*sin2a\n \n #print(N1, N2, D)\n \n # SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\n NSC = (sin2a - beta*kap *cos2a)/ (gamma**2-1) \n \n return (N1*N2)/D**3\n #return (N1*N2 + NSC)/D**3","def chebyshev_polynomials(adj, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (\n 2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0]))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k + 1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return sparse_to_tensor(t_k)","def chebyshev_polynomials(adj, k):\n # print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0], dtype=adj.dtype) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0], dtype=adj.dtype)\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0], dtype=adj.dtype))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True, dtype=adj.dtype)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k+1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return t_k","def aks( n ):\n\n def aks_mod( polynomial , r ):\n \"\"\"\n This function is used in aks.\n polynomial modulo ( x^r - 1 )\n \"\"\"\n aks_mod = polynomial.coefficients\n total = aks_mod[ : r ]\n aks_mod = aks_mod[ r : ]\n while len(aks_mod) - 1 >= r :\n for i in range(r):\n total[i] += aks_mod[i]\n aks_mod = aks_mod[ r : ]\n for i in range(len(aks_mod)):\n total[i] += aks_mod[i]\n return array_poly_mod( total , polynomial.mod )\n\n lg = math.log( n , 2 )\n k = int( lg * lg )\n\n if arith1.powerDetection( n )[ 1 ] != 1: #Power Detection\n print(\" n is not prime \")\n return False\n\n start = 3\n while 1:\n d = arith1.gcd.gcd( start , n )\n if 1 < d < n:\n print(\"n is not prime\")\n return False\n x = n % start\n N = x\n for i in range( 1 , k + 1 ):\n if N == 1:\n break\n N = ( N * x ) % start\n if i == k:\n r = start\n break\n start += 1\n d = arith1.gcd.gcd( r , n )\n if 1 < d < n:\n print(\" n is not prime \")\n return False\n if n <= r:\n print(\" n is prime \")\n return True\n\n e = multiplicative.euler( r ) #Cyclotomic Conguence\n e = math.sqrt( e )\n e = int( e * lg )\n for b in range( 1 , e+1 ):\n f = array_poly_mod( [ b , 1 ] , n )\n total = array_poly_mod( [ 1 ] , n )\n count = n\n while count > 0:\n if count & 1:\n total = total * f\n total = aks_mod( total , r )\n f = f.power()\n f = aks_mod( f , r )\n count = count >> 1\n total_poly = total.coefficients_to_dict()\n if total_poly != { 0 : b , n % r : 1 }:\n print(\" n is not prime \")\n return False\n print(\" n is prime \")\n return True","def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):","def calc_Cinv_FC(P_design_W, FC_cost_data):\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\n # capacity for the corresponding technology from the database\n if P_design_W < FC_cost_data['cap_min'][0]:\n P_design_W = FC_cost_data['cap_min'][0]\n FC_cost_data = FC_cost_data[\n (FC_cost_data['cap_min'] <= P_design_W) & (FC_cost_data['cap_max'] > P_design_W)]\n\n Inv_a = FC_cost_data.iloc[0]['a']\n Inv_b = FC_cost_data.iloc[0]['b']\n Inv_c = FC_cost_data.iloc[0]['c']\n Inv_d = FC_cost_data.iloc[0]['d']\n Inv_e = FC_cost_data.iloc[0]['e']\n Inv_IR = FC_cost_data.iloc[0]['IR_%']\n Inv_LT = FC_cost_data.iloc[0]['LT_yr']\n Inv_OM = FC_cost_data.iloc[0]['O&M_%'] / 100\n\n InvC = Inv_a + Inv_b * (P_design_W) ** Inv_c + (Inv_d + Inv_e * P_design_W) * log(P_design_W)\n\n Capex_a_FC_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\n Opex_fixed_FC_USD = InvC * Inv_OM\n Capex_FC_USD = InvC\n\n return Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD","def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\n\n \"\"\"\n This function calculates American Opportunity Credit\n for up to four eligible students\n\n \"\"\"\n\n # Expense should not exceed the cap of $4000.\n if _cmp == 1:\n\n c87482 = max(0., min(e87482, 4000.))\n c87487 = max(0., min(e87487, 4000.))\n c87492 = max(0., min(e87492, 4000.))\n c87497 = max(0., min(e87497, 4000.))\n else:\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\n\n # Credit calculated as 100% of the first $2000 expense plus\n # 25% of amount exceeding $2000.\n if max(0, c87482 - 2000) == 0:\n c87483 = c87482\n else:\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\n\n if max(0, c87487 - 2000) == 0:\n c87488 = c87487\n else:\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\n\n if max(0, c87492 - 2000) == 0:\n c87493 = c87492\n else:\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\n\n if max(0, c87497 - 2000) == 0:\n c87498 = c87497\n else:\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\n\n # Sum of credits of all four students.\n c87521 = c87483 + c87488 + c87493 + c87498\n\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\n c87521)","def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\n phi = 0.0\n\n ## Approach A - NREL Approach\n if approach_call == \"A\":\n\n phi = float(Q_load_W) / float(Q_design_W)\n eta_max = 0.425 # from energy.gov\n\n if phi >= phi_threshold: # from NREL-Shape\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\n\n if phi < phi_threshold:\n if phi <= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\n\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\n eta_el = eta_max * 2 / 3.0 + \\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\n\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\n\n eta_therm_max = 0.45 # constant, after energy.gov\n\n if phi < phi_threshold:\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\n\n else:\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\n\n ## Approach B - Empiric Approach\n if approach_call == \"B\":\n\n if Q_design_W > 0:\n phi = float(Q_load_W) / float(Q_design_W)\n\n else:\n phi = 0\n\n eta_el_max = 0.39\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\n\n eta_el = eta_el_max * eta_el_score\n eta_therm = eta_therm_max * eta_therm_score\n\n if phi < 0.2:\n eta_el = 0\n\n return eta_el, eta_therm","def IC(stock):\n return Invested_Book_Capital(stock)","def griewankfcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n sumcomp = np.zeros((x.shape[0], 1))\n prodcomp = np.ones((x.shape[0], 1))\n\n for i in range(n):\n sumcomp += x[:, i : i + 1] ** 2\n prodcomp *= np.cos(x[:, i : i + 1] / np.sqrt(i + 1))\n\n scores = (sumcomp / 4000) - prodcomp + 1\n return scores","def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] is None:\n pass\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\n self.buys_made += 1\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\n self.shares_own = self.stock_quantity\n self.buys_made += 1\n else:\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\n self.final_capital = self.final_capital % data['Close'].iloc[i]\n #print(self.shares_own)\n\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\n pass\n else:\n if (self.buys_made + self.sells_made) == 0:\n pass\n else:\n self.final_capital += self.shares_own * data['Close'].iloc[i]\n self.shares_own = 0\n self.sells_made +=1\n #Checar si es el momento mas alto o bajo de ganancias\n if self.shares_own == 0:\n if (self.highest_point is None\n or self.highest_point < self.final_capital):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > self.final_capital\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n else:\n if (self.highest_point is None\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\n self.highest_point = self.final_capital\n if (self.lowest_point is None\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\n or self.lowest_point == 0):\n self.lowest_point = self.final_capital\n self.calcRealFinalCapital()\n self.calcDiferencePercentage()","def chebyshev_polynomials(adj, k):\n # print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0]))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k+1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return sparse_to_tuple(t_k)","def DispCurve(c,x,B,a,N,K):\n return B+np.square(a*(x/(1+x+(K*((c-N)/55.5)))));","def binomial_coefficient3(n, k):\n return reduce(lambda a, b: a * (n - b) / (b + 1), xrange(k), 1)","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 ackleyfcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n ninverse = 1 / n\n sum1 = np.sum(x**2, axis=1)\n sum2 = np.sum(np.cos(2 * np.pi * x), axis=1)\n\n scores = (\n 20\n + np.exp(1)\n - (20 * np.exp(-0.2 * np.sqrt(ninverse * sum1)))\n - np.exp(ninverse * sum2)\n )\n return scores","def Fx_case_A(z, x, gamma, alp):\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n \n eta = eta_case_A(z, x, beta2, alp)\n kap = (2*(alp - z) + eta)/beta # kappa for case A\n #kap = sqrt( eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*eta*(1+x)*sin2a) \n \n # Yunhai's version\n #N1 = (1 + beta2)*(1+x)\n #N2 = -(1 + beta2*(1+x)**2)*cos2a\n #N3 = (eta - beta*kap)*sin2a\n #return (N1+N2+N3)/D**3\n \n N_Ex = 1+x - cos2a + (eta - beta*kap)*sin2a\n N_By = beta*( (1+x)*cos2a - 1 )\n \n D = kap - beta*(eta + (1+x)*sin2a)\n \n return (1+x)*(N_Ex - beta*N_By)/D**3","def lfriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\r\n n = len(args[0])\r\n data = apply(pstats.abut,tuple(args))\r\n for i in range(len(data)):\r\n data[i] = rankdata(data[i])\r\n ssbn = 0\r\n for i in range(k):\r\n ssbn = ssbn + sum(args[i])**2\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, chisqprob(chisq,k-1)","def chi2sf(x, k):","def afriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, '\\nLess than 3 levels. Friedman test not appropriate.\\n'\r\n n = len(args[0])\r\n data = apply(pstats.aabut,args)\r\n data = data.astype(N.float_)\r\n for i in range(len(data)):\r\n data[i] = arankdata(data[i])\r\n ssbn = asum(asum(args,1)**2)\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, achisqprob(chisq,k-1)","def powAlpha( n ):\n return (1-betaval)*Fib(n) + Fib(n-1)\n #return Fib(n+1) - Fib(n) * betaval","def Es_case_C(z, x, gamma, alp, lamb):\n\n if z == 0 and x == 0 and alp == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n eta = eta_case_C(z, x, beta2, alp, lamb)\n \n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a) \n \n N = lamb + sin2a + (eta - beta*kap)*cos2a\n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\n \n return N/D**3","def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\n m_over_N = float(m)/N \n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)","def curve_with_hillcoef(ph, pka, hillcoef):\n# return hillcoef * ph - pka\n return 1/(1+10**(hillcoef*(pka-ph)))","def sell_function(data_points, n_days):\n\n prediction_df = model_arima(data_points, n_days)\n\n # Calculates the profit for each day predicted taking into account running\n # costs and compares it with the highest profit so far.\n profit_array = [None] * (n_days + 1)\n\n for count in range(n_days):\n price = prediction_df.iloc[count][\"Prediction\"]\n profit_array[count + 1] = price\n\n return profit_array","def _curve_fitting(self, phase, info):\n start_date = info[self.START]\n end_date = info[self.END]\n population = info[self.N]\n trend = Trend(\n self.jhu_data, population, self.country, province=self.province,\n start_date=start_date, end_date=end_date\n )\n trend.analyse()\n df = trend.result()\n if trend.rmsle() > self.max_rmsle:\n df[f\"{self.S}{self.P}\"] = None\n # Get min value for vline\n r_value = int(df[self.R].min())\n # Rename the columns\n phase = self.INITIAL if phase == \"0th\" else phase\n df = df.rename({f\"{self.S}{self.P}\": f\"{phase}{self.P}\"}, axis=1)\n df = df.rename({f\"{self.S}{self.A}\": f\"{phase}{self.A}\"}, axis=1)\n df = df.rename({f\"{self.R}\": f\"{phase}_{self.R}\"}, axis=1)\n return (df, r_value)","def _IC(df): # Balance\n # No adjustments for cash-flow and off-balance sheet yet\n return Invested_Book_Capital(df)","def Fx_case_B(z, x, gamma):\n \n if z == 0 and x == 0:\n return 0\n \n beta2 = 1-1/gamma**2\n beta = sqrt(beta2)\n \n alp = alpha(z, x, beta2)\n sin2a = sin(2*alp)\n cos2a = cos(2*alp) \n\n kap = 2*(alp - z)/beta\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\n \n N1 = sin2a - beta*(1+x)*kap\n N2 = (1+x)*sin2a - beta*kap\n D = kap - beta*(1+x)*sin2a\n \n return N1*N2/D**3","def getK2(inp):\n\treturn 0.9/(1-math.exp(-getLambda(inp)))","def testAggregateCorrectly_simple(self):\n\n\tscaler = pf.LinearScaler()\n\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\n\tesc = pf.NoEscalationEscalator()\n\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\n\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\n\n\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\n\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\n\tend_date = dt.datetime(2034,12,31)\n\tvex1.preferred_units['variable_consumption'] = 'kW*hr'\t\n\tvex1.build_vex_schedule(end_date)\t\t#Do we need a term here? Yes? How do we control this...through the production? #maybe this should just be passed as an argument\n\n\tdates = [dt.datetime(2015,01,31), dt.datetime(2016,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\n ###!!!###Still need values here!\t--should really test escalation here to be sure\n vals_cost = [22320,22320,22320,22320]\n vals_cons = [360000,360000,360000,360000]\n \t\n for d, v1, v2 in zip(dates, vals_cons, vals_cost):\n self.assertAlmostEqual(v1, vex1.schedule.loc[d, 'variable_consumption'],4)\n\t self.assertAlmostEqual(v2, vex1.schedule.loc[d, 'variable_costs'],4)","def lp_acent(A,b,c,x_0):\n #Parameters\n b = b.flatten()\n c = c.flatten()\n ALPHA = 0.01\n BETA = 0.5\n EPSILON = 1e-6\n MAXITERS = 100\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\n print 'failed' \n return 0\n #m = len(b)\n #n = len(x_0)\n lambda_hist = []\n x = x_0\n for iter in range(MAXITERS):\n # H = np.diag(1/np.power(x,3))\n g = c-np.power(x,-1)\n #print g.shape\n #solving KKT system\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\n lambda_hist.append(lambdasqr/2)\n if lambdasqr/2 <= EPSILON:\n break\n # backtracking line search\n t = 1\n # brin the point inside the domain\n while np.min(x+t*dx)<=0:\n t =BETA*t\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\n t = BETA*t\n x = x+t*dx\n if iter == MAXITERS:\n print 'ERROR: MAXITERS reached'\n else:\n #plt.figure()\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\n return x,w,lambda_hist","def f(X_,K_):\r\n return max(exp(X_)-K_,0)","def incr(self, f_out, verbose=False, haltk=0):\n\n import numpy\n\n m = self.m\n n = self.n\n k = self.k\n d = self.d\n\n # If k == -1, we have a full polynomial, so we add 1 to the constant coefficient.\n if k == -1:\n if len(self.amaxvals[0]) > 0 and self.amaxvals[0]:\n self.a[0] = self.amaxvals[0].pop()\n for i in range(0,m):\n f_out[i] = self.a[i]\n return\n else:\n if verbose:\n print(\" finished\")\n\n # Already reached maximum, so \"carry the 1\" to find the next value of k.\n k += 1\n while k < m and len(self.amaxvals[k]) == 0:\n k += 1\n if k < m:\n self.a[k] = self.amaxvals[k].pop()\n k -= 1\n\n # If we are working through an initialization routine, treat that.\n elif haltk and k == haltk-1:\n if len(self.maxvals[k]) == 0:\n k += 1\n while k <= m-1 and len(self.amaxvals[k]) == 0:\n k += 1\n if k < m:\n self.a[k] = self.amaxvals[k].pop()\n k -= 1\n\n # If in the previous step we finished all possible values of\n # the lastmost coefficient, so we must compute bounds on the next coefficient.\n # Recall k == n-1 implies iteration is complete.\n while k < m-1:\n # maxoutflag flags a required abort along the way\n maxoutflag = False\n\n # Recall k == -1 means all coefficients are good to go.\n while k >= 0 and (not haltk or k >= haltk):\n if verbose:\n print(k, \":\", end=\"\")\n for i in range(self.m + 1):\n print(self.a[i], end=\"\")\n print(\"\")\n\n if k == m-2:\n # We only know the value of a[n-1], the trace.\n bl = max(math.ceil(1.7719*self.n), ((self.a[m-1]**2).trace()*1./m))\n br = 1./m*(self.a[m-1]**2).trace() + \\\n self.gamma*(1./(m**d)*self.B/self.dF)**(1./(self.n-d))\n br = math.floor(br)\n\n # Check for trivially empty.\n if bl > br:\n if verbose:\n print(\" \", br, \">\", bl)\n maxoutflag = 1\n break\n\n if verbose >= 2:\n print(\" bl, br:\", bl, br)\n\n # Enumerate all elements of Z_F with T_2 <= br\n T2s = []\n trace_elts_found = False\n for i in range(len(self.trace_elts)):\n tre = self.trace_elts[i]\n if tre[0] <= bl and tre[1] >= br:\n trace_elts_found = True\n if verbose >= 2:\n print(\" found copy!\")\n for theta in tre[2]:\n if theta.trace() >= bl and theta.trace() <= br:\n T2s.append(theta)\n break\n if not trace_elts_found:\n T2s = self.F._positive_integral_elements_with_trace([bl,br])\n self.trace_elts.append([bl,br,T2s])\n\n # Now ensure that T2 satisfies the correct parity condition\n am2s = []\n for t2 in T2s:\n am2 = (self.a[m-1]**2-t2)/2\n if am2.is_integral():\n ispositive = True\n for v in self.Foo:\n ispositive = ispositive and v((m-1)*self.a[m-1]**2-2*m*am2) > 0\n if ispositive:\n am2s.append(am2)\n\n if verbose >= 2:\n print(\" am2s:\", am2s)\n\n # If none survive, break!\n if len(am2s) == 0:\n if verbose:\n print(\" finished\")\n maxoutflag = 1\n break\n\n self.amaxvals[m-2] = am2s\n self.a[m-2] = self.amaxvals[m-2].pop()\n\n # Initialize the second derivative.\n self.b_lower = [-1./m*(v(self.a[m-1]) +\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\n self.b_upper = [-1./m*(v(self.a[m-1]) -\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\n self.beta[k] = [[self.b_lower[i], -self.Foo[i](self.a[m-1])/m, self.b_upper[i]] for i in range(d)]\n self.gnk[k] = [0, (m-1)*self.a[m-1], m*(m-1)/2]\n\n if verbose >= 2:\n print(\" betak:\", self.beta[k])\n else:\n # Compute the roots of the derivative.\n self.gnk[k+1][0] = self.a[k+1]\n gnk = self.gnk[k+1]\n self.beta[k] = [numpy.roots([v(gnk[len(gnk)-1-i]) for i in range(len(gnk))]).tolist() for v in self.Foo]\n\n try:\n for i in range(d):\n self.beta[k][i].sort()\n except TypeError:\n if verbose:\n print(\" betak:\", self.beta[k])\n maxoutflag = True\n break\n\n # Check for double roots\n for i in range(len(self.beta[k][0])-1):\n if abs(self.beta[k][0][i] - self.beta[k][0][i+1]) < 2*eps_global:\n # This happens reasonably infrequently, so calling\n # the Python routine should be sufficiently fast...\n f = self.Fx(self.gnk[k+1])\n df = self.Fx(self.gnk[k+2])\n if gcd(f,df) != 1:\n if verbose:\n print(\" gnk has multiple factor!\")\n maxoutflag = True\n break\n if maxoutflag:\n break\n\n if k == m-3:\n self.b_lower = [-1./m*(v(self.a[m-1]) +\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\n self.b_upper = [-1./m*(v(self.a[m-1]) -\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\n elif k == m-4:\n # New bounds from Lagrange multiplier in degree 3.\n bminmax = [lagrange_degree_3(m,v(self.a[m-1]),v(self.a[m-2]),v(self.a[m-3])) for v in self.Foo]\n self.b_lower = [bminmax[i][0] for i in range(len(bminmax))]\n self.b_upper = [bminmax[i][1] for i in range(len(bminmax))]\n\n self.beta[k] = [[self.b_lower[i]] + self.beta[k][i] + [self.b_upper[i]] for i in range(len(self.beta[k]))]\n\n if verbose >= 2:\n print(\" betak:\", self.beta[k])\n\n # Compute next g_(m-(k+1)), k times the formal integral of g_(m-k).\n self.gnk[k] = [self.F.primitive_element()*0] + [self.gnk[k+1][i-1]*(k+1)/i for i in range(1,m-k+1)]\n gnk = self.gnk[k]\n gnks = [ [v(gnk[len(gnk)-1-i]) for i in range(len(gnk))] for v in self.Foo ]\n gnkm1 = self.gnk[k+1]\n gnkm1s = [ [v(gnkm1[len(gnkm1)-1-i]) for i in range(len(gnkm1))] for v in self.Foo ]\n mk = m-(k+1)\n\n if verbose >= 2:\n print(\" gnk:\", self.gnk[k])\n print(\" gnks:\", gnks)\n\n # Compute upper and lower bounds which guarantee one retains\n # a polynomial with all real roots.\n betak = self.beta[k]\n akmin = [-numpy.polyval(gnks[j], betak[j][mk+1]) - \\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk+1]))*eps_global for j in range(self.d)]\n for i in range(1,(mk+1)//2+1):\n # Use the fact that f(z) <= f(x)+|f'(x)|eps if |x-z| < eps\n # for sufficiently small eps, f(z) = 0, and f''(z) < 0.\n akmin = [max(akmin[j],\n -numpy.polyval(gnks[j], betak[j][mk+1-2*i]) - \\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk+1-2*i])*eps_global)) for j in range(self.d)]\n\n akmax = [-numpy.polyval(gnks[j], betak[j][mk]) + \\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk]))*eps_global for j in range(self.d)]\n for i in range(1,mk//2+1):\n akmax = [min(akmax[j],\n -numpy.polyval(gnks[j], betak[j][mk-2*i]) + \\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk-2*i])*eps_global)) for j in range(self.d)]\n\n if verbose >= 2:\n print(\" akmin:\", akmin)\n print(\" akmax:\", akmax)\n\n for i in range(self.d):\n if akmin[i] > akmax[i]:\n if verbose:\n print(\" \", akmin[i], \">\", akmax[i])\n maxoutflag = 1\n break\n if maxoutflag:\n break\n\n self.amaxvals[k] = integral_elements_in_box(self.F, [[akmin[i],akmax[i]] for i in range(d)])\n if k == 0:\n a0s = [0, -sum([self.a[i] for i in range(1,m+1)]),\n -sum([self.a[i]*(-1)**i for i in range(1,m+1)]),\n -sum([self.a[i]*2**i for i in range(1,m+1)]),\n -sum([self.a[i]*(-2)**i for i in range(1,m+1)])]\n for a0 in a0s:\n try:\n self.amaxvals[0].remove(a0)\n except Exception:\n pass\n\n if verbose:\n print(\" amaxvals[k]:\", self.amaxvals[k])\n if len(self.amaxvals[k]) == 0:\n if verbose:\n print(\" finished\")\n maxoutflag = True\n break\n self.a[k] = self.amaxvals[k].pop()\n\n self.k -= 1\n k -= 1\n\n if not maxoutflag:\n self.k = k\n for i in range(m):\n f_out[i] = self.a[i]\n return\n else:\n k += 1\n while k < m and len(self.amaxvals[k]) == 0:\n k += 1\n if k < m:\n self.a[k] = self.amaxvals[k].pop()\n k -= 1\n\n # k == n-1, so iteration is complete; return the zero polynomial (of degree n+1).\n self.k = k\n f_out[m] = 0\n return","def testAggregateCorrectly(self):\n\n\tscaler = pf.LinearScaler()\n\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(1, '1/gal'))\n\tesc = pf.NoEscalationEscalator()\n\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\n\n\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2012,01,01))\n\n\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \"P&T\", scaler = scaler, size_basis = uv.UnitVal(1, '1/(kW*hr)'))\n\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\n\n\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\n\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\n\n\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\n vals = [202320,202320,202320,202320]\n\tend_date = dt.datetime(2034,12,31)\n\tcosts = pf.VariableCosts()\n costs.add_variable_expense(vex1)\n costs.add_variable_expense(vex2)\n costs.build_vex_schedule(end_date)\n\t\n for d, v in zip(dates, vals):\n self.assertAlmostEqual(v, costs.schedule.loc[d, 'variable_costs'],4)","def LangmuirCurve(x, B,a,N,K):\n return B+np.square(a*(((x+N+(55.5/K))-np.sqrt(np.square(x+N+(55.5/K))-(4*x*N)))/(2*N)));","def compute_increase_rate(input_data):\n rates = {}\n for comp in input_data:\n stock_prices = input_data[comp][1]\n rates[comp] = []\n for i in range(len(stock_prices)-1):\n # Add a new increase rate to the dictionary\n rates[comp].append((stock_prices[i] - stock_prices[i+1])/stock_prices[i+1])\n return rates","def _K(s):\n p = 0\n for k in range(-10, 10, 1):\n p += (-1)**k * np.exp(-2 * k**2 * s**2)\n return p","def get_func(k_center,enk,I,gamma,gamma_k):\n\n def lorentzian_k(k):\n return 1./np.pi * gamma_k / ( (k-k_center)**2 + gamma_k**2)\n\n def lorentzian(k,omega):\n return I * gamma / ( (omega-enk)**2 + gamma**2) * lorentzian_k(k)\n\n return lorentzian","def curve_no_hillcoef(ph, pka):\n# return ph - pka\n return 1/(10**(pka-ph)+1)","def stock_market(no_profiles: int) -> tuple:\n all_companies = []\n Stocks = namedtuple(\"Stocks\", 'name symbol open high close company_weight')\n MkValue_ = random.uniform(1000, 50000, 100)\n wts_ = random.uniform(0, 1, 100)\n wts_ = wts_/sum(wts_)\n\n for _ in range(100):\n name = fake.company()\n open_ = round(MkValue_[_]*wts_[_],2)\n close = round(open_ * random.uniform(0.7, 1.15), 2)\n high = round(open_ * random.uniform(0.85, 1.15), 2)\n if high < open_:\n high = open_\n if high < close:\n high = close\n\n all_companies.append(\n Stocks(name=name, symbol=symbol(name), open=open_, high=round(high, 2), close=round(close, 2), company_weight=round(wts_[_], 4)))\n\n stock_index = round(\n sum(x.open * x.company_weight for x in all_companies), 4)\n highest_for_day = round(\n sum(x.high * x.company_weight for x in all_companies), 2)\n lowest_close_for_day = round(\n sum(x.close * x.company_weight for x in all_companies), 2)\n\n # print(f\"\\n------------------------------------Top 100 listed companies on Fake Stock Exchange------------------------------------\")\n # [print(x) for x in sorted(all_companies, key=lambda x:x.symbol)]\n # print(f\"\\n--------------Main details on {date.today()}--------------\")\n # print(f\"\\nStart of the day: {stock_index}\")\n # print(f\"Highest for the day: {highest_for_day}\")\n # print(f\"Lowest close for the day: {lowest_close_for_day}\")\n return sorted(all_companies, key=lambda x: x.symbol), stock_index, highest_for_day, lowest_close_for_day","def getIdealSec(context, data): #This replaced before_trading_start(context, data)\n record(Leverage = \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t context.account.leverage,pos=len(context.portfolio.positions))\n context.output = pipeline_output('my_pipeline')\n #print('Pipeout: ')\n #print(context.output)\n \n # These are the securities that we are interested in trading each day.\n # Note: As it stands, the securities in this list are from two different industries (defense and\n # consumer electronics). Although more computationally expensive then dividing them out into their \n # two respective industries prior to cross correlating, leaving them in the same matrix/data set and \n # cross correlating them gives us a way to 'check' that the crosscorrelation is valid, since securities within the same industry should typically cross correlate to a higher degree than across industries. ***\n context.security_list = context.output.index \n context.defenseList = context.output[context.output['defenseFilt']].index.tolist()\n #print(context.defenseList)\n context.autoList = context.output[context.output['autoFilt']].index.tolist()\n #print(context.autoList)\n context.chemList = context.output[context.output['chemFilt']].index.tolist()\n #print(context.chemList)\n context.techList = context.output[context.output['techFilt']].index.tolist()\n #print(context.techList)\n context.depList = context.output[context.output['depFilt']].index.tolist()\n # Within each sector, calculate the mean (and max, since we may choose only to trade the maximally correlated securities regardless of industry) crosscorrelation between all combinations of stocks. \n #This will only run every trading day to prevent computational expense. In that \n #respect, performs identically to a pipeline add-on (but allows the use of \"history\") \n #Try block here incase pipe returns no valid securities. \n try:\n \tprice_history = np.transpose(data.history(context.security_list, fields=\"price\", bar_count=context.lookback,frequency=\"1m\"))\n \tprice_history=price_history.as_matrix()\n except:\n price_history=[[0],[0],[0]]\n #This returns three arrays, containing a filtered set of maximally cross correlated securities within the last time range (given by context.lookback), their associated (and filtered) time delays corresponding to their maximum correlation, and the degree of their correlation in the given time frame. Essentially, since tau has already been filtered for, the degree of their correlation should be used as a confidence feature to make predictions off of, and tau should be used to determine when to make purchases/sales. \n #hCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context)\n #The best securities to trade using this algorithm (each day) are listed in the below lists ***\n try:\n \thCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context) \n except: \n print('Crosscorr Failed')\n maxSecs,hCorrVals,timeDelays,short_timeDelays=[],[],[],[]\n #\"Globalize\" the returned information so that we can handle these commodities every minute. \n context.Securities=maxSecs\n context.CorrVals=hCorrVals\n context.timeDelays=short_timeDelays #************Used to be timeDelays, now however, we calculate a more recent tau\n context.actionList,context.timerList,context.tradeList,context.tradingNow=[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities) #list of zeros indicating that no stocks should currently be trading\n #(Note that all stocks should be sold at end of every tradinng day.) ","def find_coeff(depth, period = 2*pi):\n\tfund_feq = 2 * pi / period\n\tAK = []\n\talphaK = []\n\n\tfor n in range(1, depth+1):\n\t\tdef a_function(x, i):\n\t\t\treturn input_function(x) * cos(i * fund_feq * x)\n\t\tdef b_function(x, i):\n\t\t\treturn input_function(x) * sin(i * fund_feq * x)\n\t\t(a, err) = quad(a_function, 0, period, n)\n\t\tan = 2 * a / period\n\t\t(b, err) = quad(b_function, 0, period, n)\n\t\tbn = 2 * b / period\n\t\tAk = math.sqrt(an**2 + bn**2)\n\t\tAK.append(Ak)\n\t\talphak = math.asin(an/Ak)\n\t\talphaK.append(alphak)\n\treturn (AK, alphaK)","def coef_val():\n\n basepath = path.join(path.dirname(path.realpath('__file__')), 'data')\n fdata = basepath + path.sep + 'VAWTPolySurfaceCoef_pub.csv' # published coefficients from paper\n # fdata = basepath + path.sep + 'VAWTPolySurfaceCoef.csv' # polynomial surface fitting coefficients\n\n loc1 = np.zeros(10)\n loc2 = np.zeros(10)\n loc3 = np.zeros(10)\n spr1 = np.zeros(10)\n spr2 = np.zeros(10)\n skw1 = np.zeros(10)\n skw2 = np.zeros(10)\n scl1 = np.zeros(10)\n scl2 = np.zeros(10)\n scl3 = np.zeros(10)\n\n f = open(fdata)\n csv_f = csv.reader(f)\n\n i = 0\n for row in csv_f:\n if i != 0:\n loc1[i-1] = float(row[0])\n loc2[i-1] = float(row[1])\n loc3[i-1] = float(row[2])\n spr1[i-1] = float(row[3])\n spr2[i-1] = float(row[4])\n skw1[i-1] = float(row[5])\n skw2[i-1] = float(row[6])\n scl1[i-1] = float(row[7])\n scl2[i-1] = float(row[8])\n scl3[i-1] = float(row[9])\n i += 1\n\n f.close()\n\n return loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3","def backtest(self, strategy): \n \n # load data\n data = self.import_data(currency_ids = np.unique(self.signals.currency_id),\n start_date = self.start_date,\n end_date = self.end_date)\n \n # add cash and columns for currencies\n data[\"capital\"] = 0\n data[\"actions\"] = \"\" # should become a dictW \n data[\"description\"] = \"\"\n data[\"capital\"].iloc[0] = self.initial_capital\n data[\"worth_usd\"] = 0\n \n for currency_id in np.unique(self.signals.currency_id):\n data[currency_id + '_position'] = 0\n \n # a sell or buy can influence subsequent positions, so calculate iteratively\n for observation in range(1, len(data.index)):\n \n date = data.index[observation]\n \n # investment this period is zero\n investment_capital_period = 0\n \n # amount of currency_ids initially same as last period\n for currency_id in np.unique(self.signals.currency_id):\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] \n \n # at each point, compute size of each position (cash and currencies), and record actions\n if(data.index[observation] in self.signals.index):\n \n action_df = pd.DataFrame(columns=list([\"Currency\",\"NominalAmount\", \"CapitalAmount\"]))\n \n # could be multiple actions\n for index, action in self.signals.loc[date].iterrows(): \n currency_id = action['currency_id']\n signal = action['signal']\n \n # Buy\n if signal == 1:\n \n # buy for 10% currency_id\n investment_capital = data[\"capital\"].iloc[observation-1] * 0.10 \n\n # estimate how many coins\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\n \n # calculate exact capital needed\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\n investment_capital_period = investment_capital_period + investment_capital_exact \n \n # change the amount of currency hold\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] + investment_nominal\n \n # report action by appending a Series to the (empty) dataframe\n action_df = action_df.append(pd.Series({\"Currency\": currency_id, \n \"NominalAmount\": investment_nominal, \n \"CapitalAmount\": investment_capital_exact}),ignore_index=True)\n \n # report description\n data[\"description\"].iloc[observation] = (data[\"actions\"].iloc[observation] + \"\\n Buy \" + \n str(investment_nominal) + \" \" + str(currency_id) + \n \" for \" + str(investment_capital_exact))\n \n # Sell\n if signal == -1:\n \n # sell currency_id for 10% of total capital\n investment_capital = data[\"capital\"].iloc[observation-1] * 0.10 \n \n # estimate how many coins\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\n \n # calculate exact capital needed\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\n investment_capital_period = investment_capital_period - investment_capital_exact\n \n # change the amount of currency hold\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] - investment_nominal\n \n # report action\n action_df = action_df.append(pd.Series({\"Currency\": currency_id, \n \"NominalAmount\": investment_nominal, \n \"CapitalAmount\": investment_capital_exact}),ignore_index=True)\n \n # report description\n data[\"description\"].iloc[observation] = data[\"actions\"].iloc[observation] + \"Sell \" + str(investment_nominal) + \" \" + str(currency_id) + \" for \" + str(investment_capital_exact)\n \n # report actions\n data[\"actions\"].iloc[observation] = action_df.to_json()\n \n # calculate resulting cash capital\n data[\"capital\"].iloc[observation] = data[\"capital\"].iloc[observation-1] - investment_capital_period\n \n # calculate worth by capital (usd) and each currency * price\n data[\"worth_usd\"].iloc[observation] = data[\"capital\"].iloc[observation] \n return data","def powBeta( n ):\n return (1-alphaval)*Fib(n) + Fib(n-1)\n #return Fib(n+1) - Fib(n) * alphaval","def phosfracs(h,ks):\n k1p,k2p,k3p = ks\n h3po4 = h*h*h\n h2po4 = k1p*h*h\n hpo4 = k1p*k2p*h\n po4 = k1p*k2p*k3p\n denom = h3po4 + h2po4 + hpo4 + po4\n h3po4 /= denom\n h2po4 /= denom\n hpo4 /= denom\n po4 /= denom\n return h3po4,h2po4,hpo4,po4","def _compute_empirical_ffreq(self):\n empirical_ffreq = dict().fromkeys(self.features)\n for feature in self.features:\n empirical_ffreq[feature] = sum(\n [self.indicator_func((_feature, feature))\n for _x, _y in self.train_set\n for _feature in _x]\n )\n return empirical_ffreq","def HFCALC(N, R, Zeta1, Zeta2, Za, Zb, G):\n # Calculate one and two electron integrals\n Intgrl(N, R, Zeta1, Zeta2, Za, Zb)\n # Put all integals into array\n Colect(N, R, Zeta1, Zeta2, Za, Zb)\n # Perform the SCF calculation\n SCF(N, R, Zeta1, Zeta2, Za, Zb, G)\n return","def roccurve(signals, bkgs, cut_function, cut_values):\n eff_sig, n_pass_sig, n_total_sig = get_eff(svjflatanalysis.iterate(signals), cut_function, cut_values)\n eff_bkg, n_pass_bkg, n_total_bkg = get_eff(svjflatanalysis.iterate(bkgs), cut_function, cut_values)\n return eff_sig, eff_bkg, n_pass_sig, n_pass_bkg, n_total_sig, n_total_bkg","def _m_to_F_on_basis(self, la):\n Sym = self._kBoundedRing.ambient()\n kB = Sym.kBoundedSubspace(self.k, t=1)\n h = kB.khomogeneous()\n ks = kB.kschur()\n return sum( h(ks(x)).coefficient(la) * self(x) for x in PartitionsGreatestLE(sum(la), self.k))","def bfgs_method(x0, eps=1e-6, H0=np.eye(18),c1=1e-4):\n k = 0 # initialize num of outer iterations.\n inner_k = 0 # initialize inner k iteration.\n old_xk = None\n alpha_original = 1\n alpha = np.copy(alpha_original)\n xk = x0 # intitialize x.\n Hk = H0 # initialize H, positive definite matrix.\n I = np.eye(len(x0)) # idenitity matrix of 2 by 2.\n\n alpha_vec = []\n f_vec = []\n grad_vec = []\n inner_k = []\n conv_c = []\n\n while np.linalg.norm(rosen_der(xk)) > eps:\n pk = -Hk @ rosen_der(xk)\n\n xk_next = xk + alpha * pk\n ink = 0\n print(xk)\n while rosen(xk_next) > rosen(xk) + c1 * alpha * (pk.T @ rosen_der(xk)):\n \"\"\" find a step size that will satisfy Armijo-Goldstein inequality. Modify alpha. \"\"\"\n alpha = 0.1* alpha\n xk_next = xk + alpha * pk\n ink += 1\n\n inner_k.append(abs(int(ink)))\n\n xk_next = xk + alpha * pk\n\n sk = xk_next - xk\n\n yk = rosen_der(xk_next) - rosen_der(xk)\n\n rho = 1 / (yk.T @ sk)\n\n Hk = np.copy((I - rho * sk @ yk.T) @ Hk @ (I - rho * yk @ sk.T) + rho * sk @ sk.T)\n\n old_xk = np.copy(xk)\n xk = np.copy(xk_next)\n\n alpha_vec.append(alpha)\n f_vec.append(rosen(xk))\n grad_vec.append(np.linalg.norm(rosen_der(xk)))\n alpha = np.copy(alpha_original)\n print(f_vec[-1])\n\n k += 1\n\n return xk, k, inner_k, alpha_vec, f_vec, grad_vec","def calcAdl(self):\n adl = []\n for i,j in enumerate(self.stock_data['Close']):\n #Calculating money flow measure\n mfm_nom = ((j-self.stock_data['Low'][i])-(self.stock_data['High'][i]))\n mfm_deno = self.stock_data['High'][i]-self.stock_data['Low'][i]\n mfm = mfm_nom/mfm_deno\n #Calculating money flow volume\n mfv = mfm*self.stock_data['Volume'][i]\n #Calculating accumulated distributin line\n if not adl:\n print(mfm)\n adl.append(mfv)\n else:\n print(adl)\n adl.append(mfv+adl)\n def_dates, def_points, k = self.angle(self.dates, adl, self.type) \n return k","def test_gamma_basis_hon(self):\n def row_generator():\n return [random.betavariate(0.5, 0.5) for i in range(self.d)]\n\n self._test_sample_basis_hon(row_generator)","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def gamma(self):\r\n raise NotImplementedError('not implemented yet, will use spouge approximation')","def _ucb_halluc_acq(x):\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\n return mu + beta_th * sigma","def _ucb_halluc_acq(x):\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\n return mu + beta_th * sigma","def func_hollomon(eps,k,n):\n return k * eps**n","def RKC2(m,epsilon=0):\n import sympy\n one = sympy.Rational(1)\n\n x=sympy.Symbol('x')\n Tm=sympy.polys.orthopolys.chebyshevt_poly(m,x)\n\n w0=one+sympy.Rational(epsilon,m**2)\n w1=sympy.Rational(Tm.diff().subs(x,w0),Tm.diff(x,2).subs(x,w0))\n\n alpha=snp.zeros([m+1,m])\n beta=snp.zeros([m+1,m])\n\n b=snp.zeros(m+1)\n a=snp.zeros(m+1)\n mu=snp.zeros(m+1)\n nu=snp.zeros(m+1)\n mut=snp.zeros(m+1)\n gamt=snp.zeros(m+1)\n\n T2 = sympy.polys.orthopolys.chebyshevt_poly(2,x)\n b[0]=sympy.Rational(T2.diff(x,2).subs(x,w0),(T2.diff().subs(x,w0))**2)\n\n b[1]=one/w0\n mut[1] = b[1]*w1\n alpha[1,0]=one\n beta[1,0]=mut[1]\n\n for j in range(2,m+1):\n Tj=sympy.polys.orthopolys.chebyshevt_poly(j,x)\n b[j] = sympy.Rational(Tj.diff(x,2).subs(x,w0),(Tj.diff().subs(x,w0))**2)\n\n a[j] = one-b[j]*Tj.subs(x,w0)\n mu[j]= 2*b[j]*w0/b[j-1]\n nu[j]= -b[j]/b[j-2]\n mut[j] = mu[j]*w1/w0\n gamt[j] = -a[j-1]*mut[j]\n\n alpha[j,0]=one-mu[j]-nu[j]\n alpha[j,j-1]=mu[j]\n alpha[j,j-2]=nu[j]\n beta[j,j-1]=mut[j]\n beta[j,0]=gamt[j]\n\n shortname='RKC'+str(m)+'2'\n name = 'Runge-Kutta-Chebyshev ('+str(m)+',2)'\n return ExplicitRungeKuttaMethod(alpha=alpha,beta=beta,name=name,shortname=shortname)","def findAShin(self):\n #return reduce(lambda x, y: x*y, [self.DoS[key].get_price() for key in self.DoS] )\n a = array([self.DoS[key].get_Price() for key in self.DoS])\n return a.prod()**(1.0/len(a))","def alpha_rf(port_returns, risk_free_rate, market_returns, b):\n\n # the portfolio Alpha is given by the below equation, as stated by the Capital Asset Pricing Model\n alpha = np.mean(port_returns) - risk_free_rate + b*(np.mean(market_returns) - risk_free_rate)\n\n return alpha","def alpha_rf(port_returns, risk_free_rate, market_returns, b):\n\n # the portfolio Alpha is given by the below equation, as stated by the Capital Asset Pricing Model\n alpha = np.mean(port_returns) - risk_free_rate + b*(np.mean(market_returns) - risk_free_rate)\n\n return alpha","def trading_alg(self,table_name = None, buy_now = False, strategy_name = \"sma9\"):\n \n self.bs.buyed_stocks = 0\n self.bs.money = self.bs.startCredit\n spy_stocks = self.load_data(table_name = table_name, symbols = [\"SPY\"])\n spy_stocks = FinI.add_indicators(spy_stocks)\n \n if self.symbols:\n symbols = self.symbols\n else:\n symbols = self.db.get_symbols()\n\n # symbols = [\"INTC\",\"BYND\",\"ZM\",\"NKE\",\"HIMX\",\"JKS\",\"ENPH\",\"DUK\",\"GE\",\"DIS\",\"LEVI\",\"NVAX\",\"SLCA\",\"GPS\"]\n \n for symbol in symbols:\n print(\"symbol: \" + str(symbol))\n \n sub_data = self.load_data(table_name = table_name, symbols = symbol)\n if len(sub_data) < 1:\n break\n\n self.bt_stocks = FinI.add_indicators(sub_data)\n self.bt_stocks = FinI.add_fib(self.bt_stocks)\n # print(self.bt_stocks)\n print(self.bt_stocks[\"sma30\"])\n print(\"calculating percent change:\" + str(symbol))\n # sub_data = self.stocks.loc[self.stocks.sym ==symbol[0]].sort_values(by='index')\n \n self.symbols = symbol[0]\n \n # self.prev_stock = sub_data.iloc[0]\n # self.bt_stocks.iloc[0] = sub_data.iloc[0]\n\n # self.sell_marks = self.sell_marks.iloc[0:0]\n # self.buy_marks = self.buy_marks.iloc[0:0]\n self.bs.transactions = 0\n self.bs.profit_perc = 0\n \n # trend_indicator = \n # TODO mechanism for select strategies\n # self.ts_boll(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks)\n self.ts_eval(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks, strategy_logic = strategy_name)\n\n # call the method with passed and assembled name\n # method = getattr(self, 'ts_' + strategy_name)\n # method(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks, strategy_name = strategy_name)","def _ei_acq(x):\n mu, sigma = gp.eval(x, uncert_form='std')\n Z = (mu - curr_best) / sigma\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)","def calculate_alphabeta(self, p, prec):\n var('x')\n sqrtdelta = None\n try:\n M = Qp(p, prec).extension(x ** 2 - self.constants.delta, names=\"padicroot\")\n sqrtdelta = M.gen(0)\n except NotImplementedError:\n try:\n M = Qp(p, prec)\n sqrtdelta = M(self.constants.delta).sqrt()\n except NotImplementedError:\n # Exceptional case.\n M = Qp(p, prec).extension(x ** 2 - self.constants.A * x - self.constants.B, names=\"padicroot\")\n alpha = M.gen(0)\n beta = self.constants.A - alpha\n return (alpha, beta)\n\n alpha = (self.constants.A + sqrtdelta) / 2\n beta = self.constants.A - alpha\n return (alpha, beta)","def rosenbrockfcn(x: np.ndarray) -> np.ndarray:\n scores = np.zeros((x.shape[0], 1))\n n = x.shape[1]\n assert n >= 1, \"Given input X cannot be empty\"\n a = 1\n b = 100\n for i in range(n - 1):\n scores += b * ((x[:, i + 1] - (x[:, i] ** 2)) ** 2) + (\n (a - x[:, i]) ** 2\n )\n return scores","def OLSV2_HA(code):\n if len(code)==6:\n if (code[0]=='6')|(code[0]=='9'):\n code='SS_'+code\n _get_index_data('000001')\n index1='SS_000001'\n else:\n code='SZ_'+code\n _get_index_data('399001')\n index1='SZ_399001'\n elif len(code)==4:\n code='HK_'+code\n index1='HK_HSI'\n else:\n print('Input Wrong code.')\n\n pre_code='YAHOO/'\n ticker=pre_code+code\n index1=pre_code+index1\n\n fn='./Quandl/'+ticker+'.csv'\n ind='./Quandl/'+index1+'.csv'\n\n df=pd.read_csv(fn,parse_dates=True,index_col=0)\n dff1=df[['Open','High','Low','Close','Volume','Adjusted Close']].copy()\n print ('Caculating the analysing 1/4 statistics:')\n print (dff1.describe(),'\\n')\n dfi=pd.read_csv(ind,parse_dates=True,index_col=0)\n df['cpct']=df['Close'].pct_change()\n df['vpct']=df['Volume'].pct_change()\n dfi['indpct']=dfi['Close'].pct_change()\n\n rets=pd.concat([df['cpct'],dfi['indpct'],df['vpct']],axis=1)\n rets=rets.dropna(how='any')\n #print (rets)\n\n X=np.array(rets.iloc[:,1:3])\n X=sm.add_constant(X)\n #print(X)\n\n Y=np.array(rets.iloc[:,0])\n\n\n #y=np.dot(X,beta)+e\n model=sm.OLS(Y,X)\n results=model.fit()\n print (results.summary())\n \n print (\"The params for the model:\",results.params)\n print (\"The std for the model:\",results.bse)\n return results","def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn","def solve_stationary_equilibrium(self) :\n \n \n \n \n #a. find the equilibrium wage given the tax rate and subsidy\n w_ss = self.find_equilibrium_wage(self.w0_guess, self.w1_guess)\n \n #b. obtain firm policy functions and discount present value factors\n W_e , pol_k, pol_n, pi, W, pol_enter = self.entry_condition(w_ss)\n \n \n #c. obtain the invariant distribution \n \n #i. normalized invariant distribution over firms\n mu_hat = pol_enter/self.lambdaa * self.joint_pdf\n \n #ii. labor market clearing (section 3.5), agg demand for labor\n N_ss = np.sum(np.sum(pol_n*mu_hat, axis=0))\n \n #iii. ss equilibrium level of entry (mass of entrants)\n E_star = 1/N_ss \n \n #iv. rescale invariant distribution over firms, mu(s,tau)\n mu = E_star*mu_hat\n \n #d. marginal distributions\n \n #i. sum over subsidies, except, taxes of stationary distribution\n distrib_stationary = np.sum(mu, axis=1)\n total_mass = np.sum(distrib_stationary)\n \n #ii. marginal stationary distribution over productivity\n pdf_stationary = distrib_stationary / total_mass\n cdf_stationary = np.cumsum(pdf_stationary)\n \n #iii. stationary distribution over number of employed \n distrib_emp = (pol_n[:,2] * pdf_stationary)/ np.sum(pol_n[:,2] * pdf_stationary)\n pdf_emp = distrib_emp / np.sum(distrib_emp)\n cdf_emp = np.cumsum(pdf_emp)\n \n #e. Aggregate statistics\n \n Y_ss = np.sum(np.sum( self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma*mu, axis=0)) #ss output\n K_ss = np.sum(np.sum(pol_k*mu, axis=0)) #ss capital\n TFP_ss = Y_ss/(N_ss*E_star)/(K_ss/(N_ss*E_star))**self.alpha\n total_employment = np.dot(self.labor_demand_rel, distrib_stationary)\n average_firm_size = total_employment / total_mass\n \n #output share of subsidy, excemption, taxed\n Y_set = np.sum(self.grid_s_matrix * pol_k**self.alpha*pol_n**self.gamma*mu, axis=0) / Y_ss\n \n Y_sub_percent = Y_set[0] #output share of establishments that are receiving a subsidy, Y_s/Y\n Y_exempt_percent = Y_set[1]\n Y_taxed__Percent = Y_set[2]\n \n #the total subsidies paid out to establishments receiving subsidies as a fraction of output. numerator takes first column which is subsidy (S/Y)\n subsidy_size = np.sum(-self.tau_output[:,0]*self.grid_s_matrix[:,0]*pol_k[:,0]**self.alpha \\\n *pol_n[:,0]**self.gamma*mu[:,0]-self.tau_capital[:,0]*self.ret \\\n *pol_k[:,0]*mu[:,0]-self.tau_labor[:,0]*w_ss* \\\n pol_n[:,0]*mu[:,0]) / Y_ss\n \n \n return Y_ss, K_ss, TFP_ss, average_firm_size, E_star, Y_set, subsidy_size, N_ss, w_ss, cdf_stationary, cdf_emp","def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\n total_days=df.shape[0]\n today_invt_dict=invt_dict\n invt_daily_list=[] # invt after today's transaction\n net_wealth_list=[]\n\n for i in range(total_days):\n if i==0:\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\n elif i==total_days-1: # last day\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\n invt_daily_list.append(today_invt_dict)\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\n \n PrintResult(\"Baseline Strategy\", net_wealth_list)\n plt.plot(net_wealth_list)\n plt.title(\"Baseline (1st day buy->hold->last day sell) Strategy\")\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\n plt.show()\n return","def compute_returns(rewards, gamma=1.0):\n n = 0\n G = []\n while n < len(rewards):\n G.append(0) \n for i in range(n,len(rewards)):\n G[n] += (gamma**(i-n))*rewards[i]\n n+=1\n\n return G","def eval_costh_phi_fold_HX(data):\n return data.costh_HX_fold, data.phi_HX_fold","def get_alphas(portfolio_returns,risk_free,market_returns,betas):\r\n \r\n R = portfolio_returns\r\n Rf = risk_free\r\n Beta = betas\r\n Rm = market_returns\r\n alpha = R - Rf - (Beta*(Rm-Rf))\r\n \r\n return alpha","def cheb_poly(x, n):\n if n == 0:\n return anp.array([1 for i in x])\n elif n == 1:\n return x\n else:\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\n\n raise NotImplementedError(\"Problem 6 Incomplete\")","def eval_abs_costh_phi_fold_HX(data):\n return data.costh_HX_fold.abs(), data.phi_HX_fold","def hr_egn(A, B, R, x0):\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Degree and degree of preferences\n d = np.zeros([N, 2])\n d[:, 0] = np.dot(A, np.ones(N))\n\n for v in range(N):\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\n\n # Player v neighborhood\n k = np.zeros([N, S], dtype='double')\n for v in range(N):\n for u in range(N):\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\n # Weights the neighborhood\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\n\n # This variable is the increments that x0 receives, the derivative\n x = np.zeros([N, S], dtype='double')\n # This is the unit vector with 1 in some entry\n es = np.zeros(S, dtype='int')\n\n # Phi and gamma\n p = 0\n g = 0\n\n # Auxiliary variables for better clarity\n aux1 = 0\n aux2 = 0\n\n # Here is the derivative calculation\n # We first test if all payoffs are the same so we do less comparisons\n if B.ndim == 2:\n for v in range(N):\n for s in range(S):\n # Set es value\n es[s] = 1\n for u in range(N):\n if v == u:\n # Same payoff personal equation\n # First we will do the dot products\n # e_s*B*k_v\n aux1 = np.dot(es, np.dot(B, k[v, :]))\n # x_v*B*k_v\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\n # Finally we subtract them to multiply by r_vv\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Same payoff social equation\n # x_u*B*e_s\n aux1 = np.dot(x0[u, :], np.dot(B, es))\n # x_u*B*x_v\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n else:\n for v in range(N):\n for s in range(S):\n # Same thing as before, but now with individual payoffs\n es[s] = 1\n for u in range(N):\n if v == u:\n # Individual payoffs personal equation\n # e_s*B_v*k_v\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\n # x_u*B_v*k_v\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Individual payoffs social equation\n # x_u*B_u*e_s\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\n # x_u*B_u*x_v\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n return x","def _ucb_acq(x):\n mu, sigma = gp.eval(x, uncert_form='std')\n return mu + beta_th * sigma","def _ucb_acq(x):\n mu, sigma = gp.eval(x, uncert_form='std')\n return mu + beta_th * sigma","def calc_annual_heating_savings (self):\n price = (self.diesel_prices + self.cd['heating fuel premium'])\n\n #~ self.base_heating_cost =\n\n #~ self.proposed_heating_cost =\n\n\n\n\n self.annual_heating_savings = self.reduction_diesel_used * price\n #~ print 'self.annual_heating_savings',self.annual_heating_savings","def ackley(x):\n a = 20.0\n b = 0.2\n c = 2.0 * np.pi\n\n n = np.size(x)\n s1 = np.sum(x**2)\n s2 = np.sum(np.cos(c * x))\n f = (-a * np.exp(-b * np.sqrt(1.0 / n * s1)) - np.exp(1.0 / n * s2) + a +\n np.exp(1.0))\n\n return f","def dblcal(self, lowstrike, highstrike, expiry1, expiry2):\n assert lowstrike < highstrike\n assert pd.Timestamp(expiry1) < pd.Timestamp(expiry2)\n _rows1 = {}\n _rows2 = {}\n _prices1 = {}\n _prices2 = {}\n _index = ['Near Call', 'Far Call', 'Call Ratio', 'Near Put', 'Far Put', \n 'Put Ratio', 'Near to Far Ratio', 'Debit', 'Underlying_Price', 'Quote_Time']\n _metrics = pd.DataFrame(index=_index, columns=['Value'])\n _errmsg = \"No key for {} strike {} {}\"\n _opttype = 'call'\n _rows1[_opttype] = _relevant_rows(self.data, (highstrike, expiry1, _opttype),\n _errmsg.format(expiry1, highstrike, _opttype))\n _prices1[_opttype] = _getprice(_rows1[_opttype])\n _rows2[_opttype] = _relevant_rows(self.data, (highstrike, expiry2, _opttype),\n _errmsg.format(expiry2, highstrike, _opttype))\n _prices2[_opttype] = _getprice(_rows2[_opttype])\n _metrics.loc['Near Call', 'Value'] = _prices1[_opttype]\n _metrics.loc['Far Call', 'Value'] = _prices2[_opttype]\n _metrics.loc['Call Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\n _metrics.loc['Underlying_Price', 'Value'], _metrics.loc['Quote_Time', 'Value'] =\\\n _getkeys(_rows1[_opttype], ['Underlying_Price', 'Quote_Time'])\n _opttype = 'put'\n _rows1[_opttype] = _relevant_rows(self.data, (lowstrike, expiry1, _opttype),\n _errmsg.format(expiry1, lowstrike, _opttype))\n _prices1[_opttype] = _getprice(_rows1[_opttype])\n _rows2[_opttype] = _relevant_rows(self.data, (lowstrike, expiry2, _opttype),\n _errmsg.format(expiry2, lowstrike, _opttype))\n _prices2[_opttype] = _getprice(_rows2[_opttype])\n _metrics.loc['Near Put', 'Value'] = _prices1[_opttype]\n _metrics.loc['Far Put', 'Value'] = _prices2[_opttype]\n _metrics.loc['Put Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\n _neartot = sum(_prices1.values())\n _fartot = sum(_prices2.values())\n _metrics.loc['Near to Far Ratio', 'Value'] = float(_neartot) / _fartot\n _metrics.loc['Debit', 'Value'] = _fartot - _neartot\n return _metrics","def parab(C,gamma):\r\n return 5.678 - ((1.234 - C)**2 + (3.456 - gamma)**2)","def chebcoef(self,f,n,m,Kmin,Kmax):\n z = -cos((linspace(1,m,m)*2-1)*pi/(2*m*1.0))\n x = (z+1)*(Kmax-Kmin)/2.0 + Kmin\n y = f(x)\n # print 'x, f(x):', x, y\n T0 = ones(m)\n T1 = z\n a = zeros(n+1)\n a[0] = sum(y)/(m*1.0)\n a[1] = dot(y,T1)/dot(T1,T1)\n for i in range(2,n+1):\n T = 2*z*T1 - T0\n a[i] = dot(y,T)/(dot(T,T)*1.0)\n T0 = T1\n T1 = T\n return a","def pareto_frontier(cmrf,featlist) :\n\tQ = []\n\ttaboodict = {}\n\tnStates = len(featlist)\n\tfeat1,feat2 = featlist\n\tEaxa,Xa = cmrf.decode(feat1)\n\tEbxb,Xb = cmrf.decode(feat2)\n\tif Xa == Xb : \n\t\treturn [Xa],[(Eaxa,Ebxb)]\n\tEaxb = cmrf.score(Xb,feat1)\n\tEbxa = cmrf.score(Xa,feat2)\n\tQ.append((Xa,Xb))\n\tfrontier,frontier_energy = [],[]\n\tfrontier.extend([Xa,Xb])\n\tfrontier_energy.extend([(Eaxa,Ebxa),(Eaxb,Ebxb)])\n\ttaboodict[(Eaxa,Ebxa)] = 1;\n\ttaboodict[(Eaxb,Ebxb)] = 1;\n\twhile len(Q) > 0 :\n\t\t### Optimize \n\t\tXa,Xb = Q[0]\n\t\tQ = Q[1:] # Dequeue\n\t\tEaxb = cmrf.score(Xb,feat1)\n\t\tEbxa = cmrf.score(Xa,feat2)\t\n\t\tEaxa = cmrf.score(Xa,feat1)\n\t\tEbxb = cmrf.score(Xb,feat2)\t\n\t\tm = (Ebxa - Ebxb)/(Eaxa-Eaxb)\n\t\tif m > 0 : \n\t\t\t#stop()\n\t\t\tsys.stderr.write(\"### WARNING : Slope > 0. Cvxhull failed\")\n\t\t\treturn frontier,frontier_energy\n\t\tthetaa = -m/(1-m)\n\t\tthetab = 1/(1-m)\n\t\ttmrf = TMRF(cmrf,[thetaa,thetab],[feat1,feat2])\n\t\tXab = tmrf.decode()[1]\n\t\tEaxab = cmrf.score(Xab,feat1)\n\t\tEbxab = cmrf.score(Xab,feat2)\n\t\tif Xab != Xa and Xab != Xb and \\\n\t\t\tnot taboodict.has_key((Eaxab,Ebxab)) :\n\t\t\t# Check almost equal condition\n\t\t\tif any(map(lambda(x):almost_eq(Eaxab,x[0] or \\\n\t\t\t\talmost_eq(Ebxab,x[1])),taboodict.keys())) : \n\t\t\t\tcontinue\n\t\t\t\t\t\n\t\t\tfrontier.append(Xab)\n\t\t\tfrontier_energy.append((Eaxab,Ebxab))\n\t\t\ttaboodict[(Eaxab,Ebxab)]=1\n\t\t\tQ.extend([(Xa,Xab),(Xab,Xb)])\n\t# Calculate energy of frontier elements\t\n\treturn frontier,frontier_energy","def calc_capital_costs (self):\n powerhouse_control_cost = 0\n if not self.cd['switchgear suitable for renewables']:\n powerhouse_control_cost = self.cd['switchgear cost']\n\n #~ road_needed = self.comp_specs['road needed for transmission line']\n\n\n if str(self.comp_specs['transmission capital cost'])\\\n != 'UNKNOWN':\n transmission_line_cost = \\\n int(self.comp_specs['transmission capital cost'])\n else:\n if str(self.comp_specs['distance to resource']) \\\n != 'UNKNOWN':\n distance = \\\n float(self.comp_specs\\\n ['distance to resource'])\n transmission_line_cost = \\\n distance*self.comp_specs['est. transmission line cost']\n\n secondary_load_cost = 0\n if self.comp_specs['secondary load']:\n secondary_load_cost = self.comp_specs['secondary load cost']\n\n if str(self.comp_specs['generation capital cost']) \\\n != 'UNKNOWN':\n wind_cost = \\\n int(self.comp_specs['generation capital cost'])\n self.cost_per_kw = np.nan\n else:\n for i in range(len(self.comp_specs['estimated costs'])):\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\n self.load_offset_proposed:\n if i == len(self.comp_specs['estimated costs']) - 1:\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n continue\n\n cost = float(self.comp_specs['estimated costs'].iloc[i])\n break\n\n wind_cost = self.load_offset_proposed * cost\n self.cost_per_kw = cost\n\n #~ print powerhouse_control_cost\n #~ print transmission_line_cost\n #~ print secondary_load_cost\n #~ print wind_cost\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\n secondary_load_cost + wind_cost\n\n #~ print 'self.capital_costs',self.capital_costs","def compute_effective_quantities(r, cosmo, p=None, P0=3e4, ell=0):\n assert 'Z' in r.columns\n assert 'NZ' in r.columns\n\n # weights\n w_fkp = 1. / (1 + r['NZ']*P0)\n if p is not None:\n w1 = fnl_weight(r['Z'], p=p)\n w2 = bias_weight(r['Z'], cosmo, ell=ell)\n else:\n w1 = w2 = 1.0\n\n # effective redshift\n A = (r['Z'] * r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\n norm = (r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\n z_eff = A/norm\n\n # effective nbar\n A = (r['NZ'] * r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\n nbar_eff = A/norm\n\n return z_eff, nbar_eff","def holland(p_values, control):\n\n # Initial Checking\n if type(p_values) == pd.DataFrame:\n algorithms = p_values.columns\n p_values = p_values.values\n elif type(p_values) == np.ndarray:\n algorithms = np.array([\"Alg%d\" % alg for alg in range(p_values.shape[1])])\n\n if type(control) == str:\n control = int(np.where(algorithms == control)[0])\n if control is None:\n raise ValueError(\"Initialization ERROR. Incorrect value for control.\")\n\n # --------------------------------------------------------------------------\n # ------------------------------- Procedure --------------------------------\n # --------------------------------------------------------------------------\n k = p_values.shape[1]\n\n # sort p-values p(0) <= p(1) <= ... <= p(k-1)\n argsorted_pvals = np.argsort(p_values[0, :])\n\n APVs = np.zeros((k - 1, 1))\n comparison = []\n for i in range(k - 1):\n comparison.append(algorithms[control] + \" vs \" + algorithms[argsorted_pvals[i]])\n aux = k - 1 - np.arange(i + 1)\n v = np.max(1 - (1 - p_values[0, argsorted_pvals[: (i + 1)]]) ** aux)\n APVs[i, 0] = np.min([v, 1])\n return pd.DataFrame(data=APVs, index=comparison, columns=[\"Holland\"])","def prob3(x0 = 0, K = 9):\n #Code from prob1start\n x = sy.symbols('x')\n exp = (sy.sin(x) + 1)**(sy.sin(sy.cos(x)))\n der = sy.simplify(sy.diff(exp, x))\n \n f = sy.lambdify(x, exp)\n f1 = sy.lambdify(x, der)\n #Code from prob 1 end\n \n #just for ease of coding...\n difD = np.array(x0)\n \n #Initialize what I want\n FDQ1 = []\n FDQ2 = []\n BDQ1 = []\n BDQ2 = []\n CDQ2 = []\n CDQ4 = []\n N = []\n correct = f1(x0)\n \n #Get errors\n for i in range(0, K):\n n = 10**(-i)\n \n N.append(n)\n \n FDQ1.append(np.abs(correct - fdq1(f, difD, h = n)))\n \n FDQ2.append(np.abs(correct - fdq2(f, difD, h = n)))\n \n BDQ1.append(np.abs(correct - bdq1(f, difD, h = n)))\n \n BDQ2.append(np.abs(correct - bdq2(f, difD, h = n)))\n \n CDQ2.append(np.abs(correct - cdq2(f, difD, h = n)))\n \n CDQ4.append(np.abs(correct - cdq4(f, difD, h = n)))\n \n #Plot results\n plt.loglog(N, FDQ1, label = \"Order 1 Forward\")\n plt.loglog(N, FDQ2, label = \"Order 2 Forward\")\n plt.loglog(N, BDQ1, label = \"Order 1 Backward\")\n plt.loglog(N, BDQ2, label = \"Order 2 Backward\")\n plt.loglog(N, CDQ2, label = \"Order 2 Centered\")\n plt.loglog(N, CDQ4, label = \"Order 4 Centered\")\n \n #Tidy results\n plt.xlabel(\"h\")\n plt.ylabel(\"Absolute Error\")\n plt.title(\"title for approximate derivative errors graphs that isn\\'t in book\")\n plt.legend(loc = 2)\n plt.show()\n return\n raise NotImplementedError(\"Problem 3 Incomplete\")"],"string":"[\n \"def chebyshev_polynomial(X, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n T_k = list()\\n T_k.append(sp.eye(X.shape[0]).tocsr())\\n T_k.append(X)\\n\\n def chebyshev_recurrence(T_k_minus_one, T_k_minus_two, X):\\n X_ = sp.csr_matrix(X, copy=True)\\n return 2 * X_.dot(T_k_minus_one) - T_k_minus_two\\n\\n for i in range(2, k+1):\\n T_k.append(chebyshev_recurrence(T_k[-1], T_k[-2], X))\\n\\n return T_k\",\n \"def incumbant_firm(self, wage):\\n \\n \\n \\n # a. demand for capital (capital policy function)\\n pol_k = (self.alpha /(self.ret *(1+self.tau_capital)))**((1-self.gamma)/(1-self.gamma-self.alpha)) \\\\\\n * (self.gamma /(wage * (1+self.tau_labor)))**(self.gamma/(1-self.gamma-self.alpha)) \\\\\\n * (self.grid_s_matrix*(1-self.tau_output))**(1/(1-self.alpha-self.gamma))\\n \\n # b. demand of labor (labor policy function)\\n pol_n = (1+self.tau_capital) * self.ret * self.gamma / ((1+self.tau_labor) * wage * self.alpha) * pol_k\\n #pol_n = ((smatrix*(1-self.tau_output) * gamma) / wage)**(1/(1-gamma)) * pol_k**(alpha/(1-gamma))\\n \\n # c. incumbant profit\\n pi=(1-self.tau_output) * self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma \\\\\\n - (1+self.tau_labor)* wage * pol_n - (1+self.tau_capital) * self.ret * pol_k - self.cf\\n \\n # d. discounted present value of an incumbent establishment, W(s,pol_k(s,theta))\\n W = pi / (1-self.rho)\\n \\n return pol_k, pol_n, pi, W\",\n \"def Fx_case_B_Chris(z, x, gamma):\\n \\n if z == 0 and x == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n alp = alpha(z, x, beta2)\\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n\\n kap = 2*(alp - z)/beta\\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\\n \\n N1 = sin2a - beta*kap\\n N2 = (1+x)*sin2a - beta*kap\\n D = kap - beta*(1+x)*sin2a\\n \\n #out = (1+x)*(N1*N2 )/D**3\\n\\n ### SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\\n NSC = (1 + beta2 - beta*kap*sin2a + x - cos2a*(1 + beta2*(1 + x)) ) / (gamma**2-1) \\n out = (1+x)*(N1*N2 + NSC)/D**3\\n return out\",\n \"def calculate_profit(self):\",\n \"def _ei_halluc_acq(x):\\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\\n Z = (mu - curr_best) / sigma\\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)\",\n \"def get_output(data, capital=100000, leverage=1, commission=0, slippage=0):\\n total_capital = capital * leverage\\n df = data\\n df['cnt'] = df.groupby('timestamp')['symbol'].transform(\\n lambda x: len(x))\\n df['qty'] = (total_capital/df['cnt']/df['price']).round()\\n df['profit'] = df.eval('(sell-buy)*qty')\\n df['commission'] = df.eval('(sell+buy)*qty') * commission * 0.01\\n df['slippage'] = df.eval('(sell+buy)*qty') * slippage * 0.01\\n df['net_profit'] = df.eval('profit - commission - slippage')\\n return df\",\n \"def AmericanBinomialPricer(pricing_engine, option, data):\\r\\n\\r\\n\\r\\n expiry = option.expiry\\r\\n strike = option.strike\\r\\n (spot, rate, volatility, dividend) = data.get_data()\\r\\n steps = pricing_engine.steps\\r\\n nodes = steps + 1\\r\\n dt = expiry / steps \\r\\n u = np.exp((rate * dt) + volatility * np.sqrt(dt)) \\r\\n d = np.exp((rate * dt) - volatility * np.sqrt(dt))\\r\\n pu = (np.exp(rate * dt) - d) / (u - d)\\r\\n pd = 1 - pu\\r\\n disc = np.exp(-rate * expiry)\\r\\n spotT = 0.0\\r\\n payoffT = 0.0\\r\\n callT = 0.0\\r\\n putT= 0.0\\r\\n #call\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n callT = max(callT, spotT-strike)\\r\\n price = disc * payoffT\\r\\n #put\\r\\n for i in range(nodes):\\r\\n spotT = spot * (u ** (steps - i)) * (d ** (i))\\r\\n payoffT += option.payoff(spotT) * binom.pmf(steps - i, steps, pu) \\r\\n spotT = spotT/d\\r\\n putT = max(putT, strike-spot)\\r\\n price = disc * payoffT\\r\\n \\r\\n return price\",\n \"def Fx_case_C(z, x, gamma, alp, lamb):\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n eta = eta_case_C(z, x, beta2, alp, lamb)\\n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a)\\n \\n #N1 = (1 + beta2)*(1+x)\\n #N2 = -(1 + beta2*(1+x)**2)*cos2a\\n #N3 = (eta - beta*kap + beta2*lamb*(1+x))*sin2a\\n #return (N1+N2+N3)/D**3\\n\\n N_Ex = 1+x - cos2a + (eta - beta*kap)*sin2a\\n N_By = beta*( (1+x)*cos2a - 1 - lamb*sin2a )\\n \\n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\\n \\n return (1+x)*(N_Ex - beta*N_By)/D**3\",\n \"def stockdon2006(H,L,B):\\n \\n # Make sure parameters are double\\n H = np.double(H)\\n L = np.double(L)\\n B = np.double(B)\\n \\n # Compute incident swash (equation 11) \\n incSwash = 1.1 / 2 * 0.75 * B * (H*L)**0.5\\n \\n # Infragravity swash (Equation 12)\\n igSwash = 1.1 / 2 * 0.06 * (H*L)**0.5\\n \\n # Compute R2% (Equation 19)\\n setup = 1.1 * 0.35 * B * ((H * L)**0.5)\\n swash = 1.1 / 2.0 * (H*L * (0.563 * B**2 + 0.004))**0.5 \\n r2 = setup + swash\\n \\n return r2,setup,incSwash,igSwash\",\n \"def sexp(p,n,res_field=RR):\\n assert n>=2, \\\"Carleman matrix must at least be of size 2 to retrieve the coefficients. But given was \\\" + repr(n)\\n CM = p.carleman_matrix(n)\\n ev = [ r[0] for r in CM.charpoly().roots(QQbar) ]\\n assert len(ev) == n, \\\"Carleman matrix must have exactly \\\" + repr(n) + \\\"eigenvalues, but has \\\" + repr(len(ev))\\n\\n #We want to compute:\\n #sum over k: evk^t*(CM-ev1*I)*(CM-ev2*I)*. omit k * (CM-evn*I)/(evk-ev1)*.. omit k *(evk-evn)\\n Char = [0]*n\\n for k in range(n):\\n #here is possibility for improvement of precision\\n #to separate the fractional from the root parts\\n #expanding the product\\n Char[k] = CM - ev[k]*identity_matrix(n)\\n\\n #we want to have the first row of the product of the matrices\\n #thatswhy we mulitply in front with:\\n prod = vector(QQbar,[0,1]+[0]*(n-2))\\n prodwo = [0]*n\\n for k in range(n):\\n prodwo[k]=prod #these are the first terms until k-1\\n\\n #no need to continue\\n if k == n-1:\\n break\\n\\n #and we add the terms starting with k+1\\n for i in range(k+1,n):\\n prodwo[k] = prodwo[k] * Char[i]\\n\\n prod = prod * Char[k]\\n\\n sprodwo = [0]*n\\n for k in range(n):\\n if k==0:\\n sprodwo[k] = ev[k] - ev[1]\\n start = 2\\n else:\\n sprodwo[k] = ev[k] - ev[0]\\n start = 1\\n\\n for i in range(start,n):\\n if i != k:\\n sprodwo[k] = sprodwo[k] * (ev[k] - ev[i])\\n\\n for k in range(n):\\n print ev[k]\\n print prodwo[k][0]/sprodwo[k]\\n print res_field\\n #return lambda t: sum(res_field(ev[k])**t*res_field(prodwo[k][0]/sprodwo[k]) for k in range(n))\\n return [ev,[prodwo[k][0]/sprodwo[k] for k in range(n)]]\",\n \"def chebyshev_polynomials(adj, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0]))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k+1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return sparse_to_tuple(t_k)\",\n \"def chebyshev_polynomials(adj, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0]))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k+1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return sparse_to_tuple(t_k)\",\n \"def Es_case_B(z, x, gamma):\\n \\n if z == 0 and x == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n #alp = alpha(z, x, beta2)\\n alp = alpha_exact_case_B_brentq(z, x, beta)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n\\n kap = 2*(alp - z)/beta\\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\\n \\n N1 = cos2a - (1+x)\\n N2 = (1+x)*sin2a - beta*kap\\n D = kap - beta*(1+x)*sin2a\\n \\n #print(N1, N2, D)\\n \\n # SC term with prefactor 1/(gamma*beta)^2 = 1/(gamma^2-1)\\n NSC = (sin2a - beta*kap *cos2a)/ (gamma**2-1) \\n \\n return (N1*N2)/D**3\\n #return (N1*N2 + NSC)/D**3\",\n \"def chebyshev_polynomials(adj, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (\\n 2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0]))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k + 1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return sparse_to_tensor(t_k)\",\n \"def chebyshev_polynomials(adj, k):\\n # print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0], dtype=adj.dtype) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0], dtype=adj.dtype)\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0], dtype=adj.dtype))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True, dtype=adj.dtype)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k+1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return t_k\",\n \"def aks( n ):\\n\\n def aks_mod( polynomial , r ):\\n \\\"\\\"\\\"\\n This function is used in aks.\\n polynomial modulo ( x^r - 1 )\\n \\\"\\\"\\\"\\n aks_mod = polynomial.coefficients\\n total = aks_mod[ : r ]\\n aks_mod = aks_mod[ r : ]\\n while len(aks_mod) - 1 >= r :\\n for i in range(r):\\n total[i] += aks_mod[i]\\n aks_mod = aks_mod[ r : ]\\n for i in range(len(aks_mod)):\\n total[i] += aks_mod[i]\\n return array_poly_mod( total , polynomial.mod )\\n\\n lg = math.log( n , 2 )\\n k = int( lg * lg )\\n\\n if arith1.powerDetection( n )[ 1 ] != 1: #Power Detection\\n print(\\\" n is not prime \\\")\\n return False\\n\\n start = 3\\n while 1:\\n d = arith1.gcd.gcd( start , n )\\n if 1 < d < n:\\n print(\\\"n is not prime\\\")\\n return False\\n x = n % start\\n N = x\\n for i in range( 1 , k + 1 ):\\n if N == 1:\\n break\\n N = ( N * x ) % start\\n if i == k:\\n r = start\\n break\\n start += 1\\n d = arith1.gcd.gcd( r , n )\\n if 1 < d < n:\\n print(\\\" n is not prime \\\")\\n return False\\n if n <= r:\\n print(\\\" n is prime \\\")\\n return True\\n\\n e = multiplicative.euler( r ) #Cyclotomic Conguence\\n e = math.sqrt( e )\\n e = int( e * lg )\\n for b in range( 1 , e+1 ):\\n f = array_poly_mod( [ b , 1 ] , n )\\n total = array_poly_mod( [ 1 ] , n )\\n count = n\\n while count > 0:\\n if count & 1:\\n total = total * f\\n total = aks_mod( total , r )\\n f = f.power()\\n f = aks_mod( f , r )\\n count = count >> 1\\n total_poly = total.coefficients_to_dict()\\n if total_poly != { 0 : b , n % r : 1 }:\\n print(\\\" n is not prime \\\")\\n return False\\n print(\\\" n is prime \\\")\\n return True\",\n \"def big_analysis(beta0s=[0.5, 0.8, 1.1, 1.4, 1.7], ks=range(6), betaps=[1.2, 1.5, 2, 3]):\",\n \"def calc_Cinv_FC(P_design_W, FC_cost_data):\\n # if the Q_design is below the lowest capacity available for the technology, then it is replaced by the least\\n # capacity for the corresponding technology from the database\\n if P_design_W < FC_cost_data['cap_min'][0]:\\n P_design_W = FC_cost_data['cap_min'][0]\\n FC_cost_data = FC_cost_data[\\n (FC_cost_data['cap_min'] <= P_design_W) & (FC_cost_data['cap_max'] > P_design_W)]\\n\\n Inv_a = FC_cost_data.iloc[0]['a']\\n Inv_b = FC_cost_data.iloc[0]['b']\\n Inv_c = FC_cost_data.iloc[0]['c']\\n Inv_d = FC_cost_data.iloc[0]['d']\\n Inv_e = FC_cost_data.iloc[0]['e']\\n Inv_IR = FC_cost_data.iloc[0]['IR_%']\\n Inv_LT = FC_cost_data.iloc[0]['LT_yr']\\n Inv_OM = FC_cost_data.iloc[0]['O&M_%'] / 100\\n\\n InvC = Inv_a + Inv_b * (P_design_W) ** Inv_c + (Inv_d + Inv_e * P_design_W) * log(P_design_W)\\n\\n Capex_a_FC_USD = calc_capex_annualized(InvC, Inv_IR, Inv_LT)\\n Opex_fixed_FC_USD = InvC * Inv_OM\\n Capex_FC_USD = InvC\\n\\n return Capex_a_FC_USD, Opex_fixed_FC_USD, Capex_FC_USD\",\n \"def AmOppCr(_cmp, e87482, e87487, e87492, e87497):\\n\\n \\\"\\\"\\\"\\n This function calculates American Opportunity Credit\\n for up to four eligible students\\n\\n \\\"\\\"\\\"\\n\\n # Expense should not exceed the cap of $4000.\\n if _cmp == 1:\\n\\n c87482 = max(0., min(e87482, 4000.))\\n c87487 = max(0., min(e87487, 4000.))\\n c87492 = max(0., min(e87492, 4000.))\\n c87497 = max(0., min(e87497, 4000.))\\n else:\\n c87482, c87487, c87492, c87497 = 0., 0., 0., 0.\\n\\n # Credit calculated as 100% of the first $2000 expense plus\\n # 25% of amount exceeding $2000.\\n if max(0, c87482 - 2000) == 0:\\n c87483 = c87482\\n else:\\n c87483 = 2000 + 0.25 * max(0, c87482 - 2000)\\n\\n if max(0, c87487 - 2000) == 0:\\n c87488 = c87487\\n else:\\n c87488 = 2000 + 0.25 * max(0, c87487 - 2000)\\n\\n if max(0, c87492 - 2000) == 0:\\n c87493 = c87492\\n else:\\n c87493 = 2000 + 0.25 * max(0, c87492 - 2000)\\n\\n if max(0, c87497 - 2000) == 0:\\n c87498 = c87497\\n else:\\n c87498 = 2000 + 0.25 * max(0, c87497 - 2000)\\n\\n # Sum of credits of all four students.\\n c87521 = c87483 + c87488 + c87493 + c87498\\n\\n return (c87482, c87487, c87492, c87497, c87483, c87488, c87493, c87498,\\n c87521)\",\n \"def calc_eta_FC(Q_load_W, Q_design_W, phi_threshold, approach_call):\\n phi = 0.0\\n\\n ## Approach A - NREL Approach\\n if approach_call == \\\"A\\\":\\n\\n phi = float(Q_load_W) / float(Q_design_W)\\n eta_max = 0.425 # from energy.gov\\n\\n if phi >= phi_threshold: # from NREL-Shape\\n eta_el = eta_max - ((1 / 6.0 * eta_max) / (1.0 - phi_threshold)) * abs(phi - phi_threshold)\\n\\n if phi < phi_threshold:\\n if phi <= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3 * (phi / (phi_threshold * 118 / 520.0))\\n\\n if phi < 0.5 * phi_threshold and phi >= 118 / 520.0 * phi_threshold:\\n eta_el = eta_max * 2 / 3.0 + \\\\\\n eta_max * 0.25 * (phi - phi_threshold * 118 / 520.0) / (phi_threshold * (0.5 - 118 / 520.0))\\n\\n if phi > 0.5 * phi_threshold and phi < phi_threshold:\\n eta_el = eta_max * (2 / 3.0 + 0.25) + \\\\\\n 1 / 12.0 * eta_max * (phi - phi_threshold * 0.5) / (phi_threshold * (1 - 0.5))\\n\\n eta_therm_max = 0.45 # constant, after energy.gov\\n\\n if phi < phi_threshold:\\n eta_therm = 0.5 * eta_therm_max * (phi / phi_threshold)\\n\\n else:\\n eta_therm = 0.5 * eta_therm_max * (1 + eta_therm_max * ((phi - phi_threshold) / (1 - phi_threshold)))\\n\\n ## Approach B - Empiric Approach\\n if approach_call == \\\"B\\\":\\n\\n if Q_design_W > 0:\\n phi = float(Q_load_W) / float(Q_design_W)\\n\\n else:\\n phi = 0\\n\\n eta_el_max = 0.39\\n eta_therm_max = 0.58 # * 1.11 as this source gives eff. of HHV\\n eta_el_score = -0.220 + 5.277 * phi - 9.127 * phi ** 2 + 7.172 * phi ** 3 - 2.103 * phi ** 4\\n eta_therm_score = 0.9 - 0.07 * phi + 0.17 * phi ** 2\\n\\n eta_el = eta_el_max * eta_el_score\\n eta_therm = eta_therm_max * eta_therm_score\\n\\n if phi < 0.2:\\n eta_el = 0\\n\\n return eta_el, eta_therm\",\n \"def IC(stock):\\n return Invested_Book_Capital(stock)\",\n \"def griewankfcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n sumcomp = np.zeros((x.shape[0], 1))\\n prodcomp = np.ones((x.shape[0], 1))\\n\\n for i in range(n):\\n sumcomp += x[:, i : i + 1] ** 2\\n prodcomp *= np.cos(x[:, i : i + 1] / np.sqrt(i + 1))\\n\\n scores = (sumcomp / 4000) - prodcomp + 1\\n return scores\",\n \"def calc_earning(self, data=None):\\n result = Result()\\n if data is None:\\n data = self.security\\n self.calcDecision()\\n first_purchase_method = self.check_first_purchase_method()\\n for i in np.arange(len(data['Close'])):\\n if data['FinalDecision'].iloc[i] is None:\\n pass\\n elif data['FinalDecision'].iloc[i] == TransactionType.BUY:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.BUY:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n if first_purchase_method == FirstTransactionType.INIT_CAPITAL:\\n self.shares_own = int((self.init_capital/data['Close'].iloc[i]))\\n self.buys_made += 1\\n elif first_purchase_method == FirstTransactionType.STOCK_QUANTITY:\\n self.shares_own = self.stock_quantity\\n self.buys_made += 1\\n else:\\n self.shares_own = int(self.final_capital / data['Close'].iloc[i])\\n self.final_capital = self.final_capital % data['Close'].iloc[i]\\n #print(self.shares_own)\\n\\n elif data['FinalDecision'].iloc[i] == TransactionType.SELL:\\n if data['FinalDecision'].iloc[i-1] == TransactionType.SELL:\\n pass\\n else:\\n if (self.buys_made + self.sells_made) == 0:\\n pass\\n else:\\n self.final_capital += self.shares_own * data['Close'].iloc[i]\\n self.shares_own = 0\\n self.sells_made +=1\\n #Checar si es el momento mas alto o bajo de ganancias\\n if self.shares_own == 0:\\n if (self.highest_point is None\\n or self.highest_point < self.final_capital):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > self.final_capital\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n else:\\n if (self.highest_point is None\\n or self.highest_point < (self.shares_own * data['Close'].iloc[i])):\\n self.highest_point = self.final_capital\\n if (self.lowest_point is None\\n or self.lowest_point > (self.shares_own * data['Close'].iloc[i])\\n or self.lowest_point == 0):\\n self.lowest_point = self.final_capital\\n self.calcRealFinalCapital()\\n self.calcDiferencePercentage()\",\n \"def chebyshev_polynomials(adj, k):\\n # print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0]))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k+1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return sparse_to_tuple(t_k)\",\n \"def DispCurve(c,x,B,a,N,K):\\n return B+np.square(a*(x/(1+x+(K*((c-N)/55.5)))));\",\n \"def binomial_coefficient3(n, k):\\n return reduce(lambda a, b: a * (n - b) / (b + 1), xrange(k), 1)\",\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 ackleyfcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n ninverse = 1 / n\\n sum1 = np.sum(x**2, axis=1)\\n sum2 = np.sum(np.cos(2 * np.pi * x), axis=1)\\n\\n scores = (\\n 20\\n + np.exp(1)\\n - (20 * np.exp(-0.2 * np.sqrt(ninverse * sum1)))\\n - np.exp(ninverse * sum2)\\n )\\n return scores\",\n \"def Fx_case_A(z, x, gamma, alp):\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n \\n eta = eta_case_A(z, x, beta2, alp)\\n kap = (2*(alp - z) + eta)/beta # kappa for case A\\n #kap = sqrt( eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*eta*(1+x)*sin2a) \\n \\n # Yunhai's version\\n #N1 = (1 + beta2)*(1+x)\\n #N2 = -(1 + beta2*(1+x)**2)*cos2a\\n #N3 = (eta - beta*kap)*sin2a\\n #return (N1+N2+N3)/D**3\\n \\n N_Ex = 1+x - cos2a + (eta - beta*kap)*sin2a\\n N_By = beta*( (1+x)*cos2a - 1 )\\n \\n D = kap - beta*(eta + (1+x)*sin2a)\\n \\n return (1+x)*(N_Ex - beta*N_By)/D**3\",\n \"def lfriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.abut,tuple(args))\\r\\n for i in range(len(data)):\\r\\n data[i] = rankdata(data[i])\\r\\n ssbn = 0\\r\\n for i in range(k):\\r\\n ssbn = ssbn + sum(args[i])**2\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, chisqprob(chisq,k-1)\",\n \"def chi2sf(x, k):\",\n \"def afriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, '\\\\nLess than 3 levels. Friedman test not appropriate.\\\\n'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.aabut,args)\\r\\n data = data.astype(N.float_)\\r\\n for i in range(len(data)):\\r\\n data[i] = arankdata(data[i])\\r\\n ssbn = asum(asum(args,1)**2)\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, achisqprob(chisq,k-1)\",\n \"def powAlpha( n ):\\n return (1-betaval)*Fib(n) + Fib(n-1)\\n #return Fib(n+1) - Fib(n) * betaval\",\n \"def Es_case_C(z, x, gamma, alp, lamb):\\n\\n if z == 0 and x == 0 and alp == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n eta = eta_case_C(z, x, beta2, alp, lamb)\\n \\n kap = (2*(alp - z) + eta + lamb)/beta # kappa for case C\\n #kap = sqrt( lamb**2 + eta**2 + x**2 + 4*(1+x)*sin(alp)**2 + 2*(lamb + eta*(1+x))*sin2a + 2*lamb*eta*cos2a) \\n \\n N = lamb + sin2a + (eta - beta*kap)*cos2a\\n D = kap - beta*(eta + lamb*cos2a + (1+x)*sin2a)\\n \\n return N/D**3\",\n \"def compute_corollary_7a_gibbs_bound(empirical_gibbs_risk, m, N, KLQP, delta=0.05):\\n m_over_N = float(m)/N \\n complexity_term = 3 * log(m) * sqrt( m*(1.-m_over_N) ) \\n return compute_general_transductive_gibbs_bound(new_transductive_divergence, empirical_gibbs_risk, m, N, KLQP, delta, complexity_term)\",\n \"def curve_with_hillcoef(ph, pka, hillcoef):\\n# return hillcoef * ph - pka\\n return 1/(1+10**(hillcoef*(pka-ph)))\",\n \"def sell_function(data_points, n_days):\\n\\n prediction_df = model_arima(data_points, n_days)\\n\\n # Calculates the profit for each day predicted taking into account running\\n # costs and compares it with the highest profit so far.\\n profit_array = [None] * (n_days + 1)\\n\\n for count in range(n_days):\\n price = prediction_df.iloc[count][\\\"Prediction\\\"]\\n profit_array[count + 1] = price\\n\\n return profit_array\",\n \"def _curve_fitting(self, phase, info):\\n start_date = info[self.START]\\n end_date = info[self.END]\\n population = info[self.N]\\n trend = Trend(\\n self.jhu_data, population, self.country, province=self.province,\\n start_date=start_date, end_date=end_date\\n )\\n trend.analyse()\\n df = trend.result()\\n if trend.rmsle() > self.max_rmsle:\\n df[f\\\"{self.S}{self.P}\\\"] = None\\n # Get min value for vline\\n r_value = int(df[self.R].min())\\n # Rename the columns\\n phase = self.INITIAL if phase == \\\"0th\\\" else phase\\n df = df.rename({f\\\"{self.S}{self.P}\\\": f\\\"{phase}{self.P}\\\"}, axis=1)\\n df = df.rename({f\\\"{self.S}{self.A}\\\": f\\\"{phase}{self.A}\\\"}, axis=1)\\n df = df.rename({f\\\"{self.R}\\\": f\\\"{phase}_{self.R}\\\"}, axis=1)\\n return (df, r_value)\",\n \"def _IC(df): # Balance\\n # No adjustments for cash-flow and off-balance sheet yet\\n return Invested_Book_Capital(df)\",\n \"def Fx_case_B(z, x, gamma):\\n \\n if z == 0 and x == 0:\\n return 0\\n \\n beta2 = 1-1/gamma**2\\n beta = sqrt(beta2)\\n \\n alp = alpha(z, x, beta2)\\n sin2a = sin(2*alp)\\n cos2a = cos(2*alp) \\n\\n kap = 2*(alp - z)/beta\\n #kap = sqrt(x**2 + 4*(1+x)*sin(alp)**2) # kappa for case B\\n \\n N1 = sin2a - beta*(1+x)*kap\\n N2 = (1+x)*sin2a - beta*kap\\n D = kap - beta*(1+x)*sin2a\\n \\n return N1*N2/D**3\",\n \"def getK2(inp):\\n\\treturn 0.9/(1-math.exp(-getLambda(inp)))\",\n \"def testAggregateCorrectly_simple(self):\\n\\n\\tscaler = pf.LinearScaler()\\n\\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/gal'))\\n\\tesc = pf.NoEscalationEscalator()\\n\\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\\n\\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2015,01,01))\\n\\n\\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(100, '1/(kW*hr)'))\\n\\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\\n\\tend_date = dt.datetime(2034,12,31)\\n\\tvex1.preferred_units['variable_consumption'] = 'kW*hr'\\t\\n\\tvex1.build_vex_schedule(end_date)\\t\\t#Do we need a term here? Yes? How do we control this...through the production? #maybe this should just be passed as an argument\\n\\n\\tdates = [dt.datetime(2015,01,31), dt.datetime(2016,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\\n ###!!!###Still need values here!\\t--should really test escalation here to be sure\\n vals_cost = [22320,22320,22320,22320]\\n vals_cons = [360000,360000,360000,360000]\\n \\t\\n for d, v1, v2 in zip(dates, vals_cons, vals_cost):\\n self.assertAlmostEqual(v1, vex1.schedule.loc[d, 'variable_consumption'],4)\\n\\t self.assertAlmostEqual(v2, vex1.schedule.loc[d, 'variable_costs'],4)\",\n \"def lp_acent(A,b,c,x_0):\\n #Parameters\\n b = b.flatten()\\n c = c.flatten()\\n ALPHA = 0.01\\n BETA = 0.5\\n EPSILON = 1e-6\\n MAXITERS = 100\\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\\n print 'failed' \\n return 0\\n #m = len(b)\\n #n = len(x_0)\\n lambda_hist = []\\n x = x_0\\n for iter in range(MAXITERS):\\n # H = np.diag(1/np.power(x,3))\\n g = c-np.power(x,-1)\\n #print g.shape\\n #solving KKT system\\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\\n lambda_hist.append(lambdasqr/2)\\n if lambdasqr/2 <= EPSILON:\\n break\\n # backtracking line search\\n t = 1\\n # brin the point inside the domain\\n while np.min(x+t*dx)<=0:\\n t =BETA*t\\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\\n t = BETA*t\\n x = x+t*dx\\n if iter == MAXITERS:\\n print 'ERROR: MAXITERS reached'\\n else:\\n #plt.figure()\\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\\n return x,w,lambda_hist\",\n \"def f(X_,K_):\\r\\n return max(exp(X_)-K_,0)\",\n \"def incr(self, f_out, verbose=False, haltk=0):\\n\\n import numpy\\n\\n m = self.m\\n n = self.n\\n k = self.k\\n d = self.d\\n\\n # If k == -1, we have a full polynomial, so we add 1 to the constant coefficient.\\n if k == -1:\\n if len(self.amaxvals[0]) > 0 and self.amaxvals[0]:\\n self.a[0] = self.amaxvals[0].pop()\\n for i in range(0,m):\\n f_out[i] = self.a[i]\\n return\\n else:\\n if verbose:\\n print(\\\" finished\\\")\\n\\n # Already reached maximum, so \\\"carry the 1\\\" to find the next value of k.\\n k += 1\\n while k < m and len(self.amaxvals[k]) == 0:\\n k += 1\\n if k < m:\\n self.a[k] = self.amaxvals[k].pop()\\n k -= 1\\n\\n # If we are working through an initialization routine, treat that.\\n elif haltk and k == haltk-1:\\n if len(self.maxvals[k]) == 0:\\n k += 1\\n while k <= m-1 and len(self.amaxvals[k]) == 0:\\n k += 1\\n if k < m:\\n self.a[k] = self.amaxvals[k].pop()\\n k -= 1\\n\\n # If in the previous step we finished all possible values of\\n # the lastmost coefficient, so we must compute bounds on the next coefficient.\\n # Recall k == n-1 implies iteration is complete.\\n while k < m-1:\\n # maxoutflag flags a required abort along the way\\n maxoutflag = False\\n\\n # Recall k == -1 means all coefficients are good to go.\\n while k >= 0 and (not haltk or k >= haltk):\\n if verbose:\\n print(k, \\\":\\\", end=\\\"\\\")\\n for i in range(self.m + 1):\\n print(self.a[i], end=\\\"\\\")\\n print(\\\"\\\")\\n\\n if k == m-2:\\n # We only know the value of a[n-1], the trace.\\n bl = max(math.ceil(1.7719*self.n), ((self.a[m-1]**2).trace()*1./m))\\n br = 1./m*(self.a[m-1]**2).trace() + \\\\\\n self.gamma*(1./(m**d)*self.B/self.dF)**(1./(self.n-d))\\n br = math.floor(br)\\n\\n # Check for trivially empty.\\n if bl > br:\\n if verbose:\\n print(\\\" \\\", br, \\\">\\\", bl)\\n maxoutflag = 1\\n break\\n\\n if verbose >= 2:\\n print(\\\" bl, br:\\\", bl, br)\\n\\n # Enumerate all elements of Z_F with T_2 <= br\\n T2s = []\\n trace_elts_found = False\\n for i in range(len(self.trace_elts)):\\n tre = self.trace_elts[i]\\n if tre[0] <= bl and tre[1] >= br:\\n trace_elts_found = True\\n if verbose >= 2:\\n print(\\\" found copy!\\\")\\n for theta in tre[2]:\\n if theta.trace() >= bl and theta.trace() <= br:\\n T2s.append(theta)\\n break\\n if not trace_elts_found:\\n T2s = self.F._positive_integral_elements_with_trace([bl,br])\\n self.trace_elts.append([bl,br,T2s])\\n\\n # Now ensure that T2 satisfies the correct parity condition\\n am2s = []\\n for t2 in T2s:\\n am2 = (self.a[m-1]**2-t2)/2\\n if am2.is_integral():\\n ispositive = True\\n for v in self.Foo:\\n ispositive = ispositive and v((m-1)*self.a[m-1]**2-2*m*am2) > 0\\n if ispositive:\\n am2s.append(am2)\\n\\n if verbose >= 2:\\n print(\\\" am2s:\\\", am2s)\\n\\n # If none survive, break!\\n if len(am2s) == 0:\\n if verbose:\\n print(\\\" finished\\\")\\n maxoutflag = 1\\n break\\n\\n self.amaxvals[m-2] = am2s\\n self.a[m-2] = self.amaxvals[m-2].pop()\\n\\n # Initialize the second derivative.\\n self.b_lower = [-1./m*(v(self.a[m-1]) +\\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\\n self.b_upper = [-1./m*(v(self.a[m-1]) -\\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\\n self.beta[k] = [[self.b_lower[i], -self.Foo[i](self.a[m-1])/m, self.b_upper[i]] for i in range(d)]\\n self.gnk[k] = [0, (m-1)*self.a[m-1], m*(m-1)/2]\\n\\n if verbose >= 2:\\n print(\\\" betak:\\\", self.beta[k])\\n else:\\n # Compute the roots of the derivative.\\n self.gnk[k+1][0] = self.a[k+1]\\n gnk = self.gnk[k+1]\\n self.beta[k] = [numpy.roots([v(gnk[len(gnk)-1-i]) for i in range(len(gnk))]).tolist() for v in self.Foo]\\n\\n try:\\n for i in range(d):\\n self.beta[k][i].sort()\\n except TypeError:\\n if verbose:\\n print(\\\" betak:\\\", self.beta[k])\\n maxoutflag = True\\n break\\n\\n # Check for double roots\\n for i in range(len(self.beta[k][0])-1):\\n if abs(self.beta[k][0][i] - self.beta[k][0][i+1]) < 2*eps_global:\\n # This happens reasonably infrequently, so calling\\n # the Python routine should be sufficiently fast...\\n f = self.Fx(self.gnk[k+1])\\n df = self.Fx(self.gnk[k+2])\\n if gcd(f,df) != 1:\\n if verbose:\\n print(\\\" gnk has multiple factor!\\\")\\n maxoutflag = True\\n break\\n if maxoutflag:\\n break\\n\\n if k == m-3:\\n self.b_lower = [-1./m*(v(self.a[m-1]) +\\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\\n self.b_upper = [-1./m*(v(self.a[m-1]) -\\n (m-1.)*math.sqrt(v(self.a[m-1])**2 - 2.*(1+1./(m-1))*v(self.a[m-2]))) for v in self.Foo]\\n elif k == m-4:\\n # New bounds from Lagrange multiplier in degree 3.\\n bminmax = [lagrange_degree_3(m,v(self.a[m-1]),v(self.a[m-2]),v(self.a[m-3])) for v in self.Foo]\\n self.b_lower = [bminmax[i][0] for i in range(len(bminmax))]\\n self.b_upper = [bminmax[i][1] for i in range(len(bminmax))]\\n\\n self.beta[k] = [[self.b_lower[i]] + self.beta[k][i] + [self.b_upper[i]] for i in range(len(self.beta[k]))]\\n\\n if verbose >= 2:\\n print(\\\" betak:\\\", self.beta[k])\\n\\n # Compute next g_(m-(k+1)), k times the formal integral of g_(m-k).\\n self.gnk[k] = [self.F.primitive_element()*0] + [self.gnk[k+1][i-1]*(k+1)/i for i in range(1,m-k+1)]\\n gnk = self.gnk[k]\\n gnks = [ [v(gnk[len(gnk)-1-i]) for i in range(len(gnk))] for v in self.Foo ]\\n gnkm1 = self.gnk[k+1]\\n gnkm1s = [ [v(gnkm1[len(gnkm1)-1-i]) for i in range(len(gnkm1))] for v in self.Foo ]\\n mk = m-(k+1)\\n\\n if verbose >= 2:\\n print(\\\" gnk:\\\", self.gnk[k])\\n print(\\\" gnks:\\\", gnks)\\n\\n # Compute upper and lower bounds which guarantee one retains\\n # a polynomial with all real roots.\\n betak = self.beta[k]\\n akmin = [-numpy.polyval(gnks[j], betak[j][mk+1]) - \\\\\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk+1]))*eps_global for j in range(self.d)]\\n for i in range(1,(mk+1)//2+1):\\n # Use the fact that f(z) <= f(x)+|f'(x)|eps if |x-z| < eps\\n # for sufficiently small eps, f(z) = 0, and f''(z) < 0.\\n akmin = [max(akmin[j],\\n -numpy.polyval(gnks[j], betak[j][mk+1-2*i]) - \\\\\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk+1-2*i])*eps_global)) for j in range(self.d)]\\n\\n akmax = [-numpy.polyval(gnks[j], betak[j][mk]) + \\\\\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk]))*eps_global for j in range(self.d)]\\n for i in range(1,mk//2+1):\\n akmax = [min(akmax[j],\\n -numpy.polyval(gnks[j], betak[j][mk-2*i]) + \\\\\\n abs(numpy.polyval(gnkm1s[j], betak[j][mk-2*i])*eps_global)) for j in range(self.d)]\\n\\n if verbose >= 2:\\n print(\\\" akmin:\\\", akmin)\\n print(\\\" akmax:\\\", akmax)\\n\\n for i in range(self.d):\\n if akmin[i] > akmax[i]:\\n if verbose:\\n print(\\\" \\\", akmin[i], \\\">\\\", akmax[i])\\n maxoutflag = 1\\n break\\n if maxoutflag:\\n break\\n\\n self.amaxvals[k] = integral_elements_in_box(self.F, [[akmin[i],akmax[i]] for i in range(d)])\\n if k == 0:\\n a0s = [0, -sum([self.a[i] for i in range(1,m+1)]),\\n -sum([self.a[i]*(-1)**i for i in range(1,m+1)]),\\n -sum([self.a[i]*2**i for i in range(1,m+1)]),\\n -sum([self.a[i]*(-2)**i for i in range(1,m+1)])]\\n for a0 in a0s:\\n try:\\n self.amaxvals[0].remove(a0)\\n except Exception:\\n pass\\n\\n if verbose:\\n print(\\\" amaxvals[k]:\\\", self.amaxvals[k])\\n if len(self.amaxvals[k]) == 0:\\n if verbose:\\n print(\\\" finished\\\")\\n maxoutflag = True\\n break\\n self.a[k] = self.amaxvals[k].pop()\\n\\n self.k -= 1\\n k -= 1\\n\\n if not maxoutflag:\\n self.k = k\\n for i in range(m):\\n f_out[i] = self.a[i]\\n return\\n else:\\n k += 1\\n while k < m and len(self.amaxvals[k]) == 0:\\n k += 1\\n if k < m:\\n self.a[k] = self.amaxvals[k].pop()\\n k -= 1\\n\\n # k == n-1, so iteration is complete; return the zero polynomial (of degree n+1).\\n self.k = k\\n f_out[m] = 0\\n return\",\n \"def testAggregateCorrectly(self):\\n\\n\\tscaler = pf.LinearScaler()\\n\\tQBp = pf.ProductQuoteBasis(base_price = 1.53, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(1, '1/gal'))\\n\\tesc = pf.NoEscalationEscalator()\\n\\tpr1 = pf.Product(name = 'gasoline', description = 'People', quote_basis = QBp, escalator = esc)\\n\\n\\tpro1 = pf.Production(name = 'stream1', product = pr1, rate = uv.UnitVal(15000, 'gal/hr'), startup_discounter = None, init_date = dt.datetime(2012,01,01))\\n\\n\\tQB = pf.VariableExpenseQuoteBasis(base_price = 0.062, date = dt.datetime(2012,01,01), source = \\\"P&T\\\", scaler = scaler, size_basis = uv.UnitVal(1, '1/(kW*hr)'))\\n\\tvex1 = pf.VariableExpense(name = 'Electricity', description = 'Power consumption by plant', quote_basis = QB, production = pro1, rate = uv.UnitVal(1, 'kW*hr/gal'), escalator = esc)\\n\\n\\tQB2 = pf.VariableExpenseQuoteBasis(base_price = 75, date = dt.datetime(2012,01,01), source= 'Tom Miles', scaler = scaler, size_basis = uv.UnitVal(1, '1/ton'))\\n\\tvex2 = pf.VariableExpense(name = 'Biomass', description = 'Biomass used by plant', quote_basis = QB2, production = pro1, rate = uv.UnitVal(1.0/150.0, 'ton/gal'), escalator = esc)\\n\\n\\tdates = [dt.datetime(2012,01,31), dt.datetime(2013,01,31), dt.datetime(2020, 03, 31), dt.datetime(2021, 12,31)]\\n vals = [202320,202320,202320,202320]\\n\\tend_date = dt.datetime(2034,12,31)\\n\\tcosts = pf.VariableCosts()\\n costs.add_variable_expense(vex1)\\n costs.add_variable_expense(vex2)\\n costs.build_vex_schedule(end_date)\\n\\t\\n for d, v in zip(dates, vals):\\n self.assertAlmostEqual(v, costs.schedule.loc[d, 'variable_costs'],4)\",\n \"def LangmuirCurve(x, B,a,N,K):\\n return B+np.square(a*(((x+N+(55.5/K))-np.sqrt(np.square(x+N+(55.5/K))-(4*x*N)))/(2*N)));\",\n \"def compute_increase_rate(input_data):\\n rates = {}\\n for comp in input_data:\\n stock_prices = input_data[comp][1]\\n rates[comp] = []\\n for i in range(len(stock_prices)-1):\\n # Add a new increase rate to the dictionary\\n rates[comp].append((stock_prices[i] - stock_prices[i+1])/stock_prices[i+1])\\n return rates\",\n \"def _K(s):\\n p = 0\\n for k in range(-10, 10, 1):\\n p += (-1)**k * np.exp(-2 * k**2 * s**2)\\n return p\",\n \"def get_func(k_center,enk,I,gamma,gamma_k):\\n\\n def lorentzian_k(k):\\n return 1./np.pi * gamma_k / ( (k-k_center)**2 + gamma_k**2)\\n\\n def lorentzian(k,omega):\\n return I * gamma / ( (omega-enk)**2 + gamma**2) * lorentzian_k(k)\\n\\n return lorentzian\",\n \"def curve_no_hillcoef(ph, pka):\\n# return ph - pka\\n return 1/(10**(pka-ph)+1)\",\n \"def stock_market(no_profiles: int) -> tuple:\\n all_companies = []\\n Stocks = namedtuple(\\\"Stocks\\\", 'name symbol open high close company_weight')\\n MkValue_ = random.uniform(1000, 50000, 100)\\n wts_ = random.uniform(0, 1, 100)\\n wts_ = wts_/sum(wts_)\\n\\n for _ in range(100):\\n name = fake.company()\\n open_ = round(MkValue_[_]*wts_[_],2)\\n close = round(open_ * random.uniform(0.7, 1.15), 2)\\n high = round(open_ * random.uniform(0.85, 1.15), 2)\\n if high < open_:\\n high = open_\\n if high < close:\\n high = close\\n\\n all_companies.append(\\n Stocks(name=name, symbol=symbol(name), open=open_, high=round(high, 2), close=round(close, 2), company_weight=round(wts_[_], 4)))\\n\\n stock_index = round(\\n sum(x.open * x.company_weight for x in all_companies), 4)\\n highest_for_day = round(\\n sum(x.high * x.company_weight for x in all_companies), 2)\\n lowest_close_for_day = round(\\n sum(x.close * x.company_weight for x in all_companies), 2)\\n\\n # print(f\\\"\\\\n------------------------------------Top 100 listed companies on Fake Stock Exchange------------------------------------\\\")\\n # [print(x) for x in sorted(all_companies, key=lambda x:x.symbol)]\\n # print(f\\\"\\\\n--------------Main details on {date.today()}--------------\\\")\\n # print(f\\\"\\\\nStart of the day: {stock_index}\\\")\\n # print(f\\\"Highest for the day: {highest_for_day}\\\")\\n # print(f\\\"Lowest close for the day: {lowest_close_for_day}\\\")\\n return sorted(all_companies, key=lambda x: x.symbol), stock_index, highest_for_day, lowest_close_for_day\",\n \"def getIdealSec(context, data): #This replaced before_trading_start(context, data)\\n record(Leverage = \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t context.account.leverage,pos=len(context.portfolio.positions))\\n context.output = pipeline_output('my_pipeline')\\n #print('Pipeout: ')\\n #print(context.output)\\n \\n # These are the securities that we are interested in trading each day.\\n # Note: As it stands, the securities in this list are from two different industries (defense and\\n # consumer electronics). Although more computationally expensive then dividing them out into their \\n # two respective industries prior to cross correlating, leaving them in the same matrix/data set and \\n # cross correlating them gives us a way to 'check' that the crosscorrelation is valid, since securities within the same industry should typically cross correlate to a higher degree than across industries. ***\\n context.security_list = context.output.index \\n context.defenseList = context.output[context.output['defenseFilt']].index.tolist()\\n #print(context.defenseList)\\n context.autoList = context.output[context.output['autoFilt']].index.tolist()\\n #print(context.autoList)\\n context.chemList = context.output[context.output['chemFilt']].index.tolist()\\n #print(context.chemList)\\n context.techList = context.output[context.output['techFilt']].index.tolist()\\n #print(context.techList)\\n context.depList = context.output[context.output['depFilt']].index.tolist()\\n # Within each sector, calculate the mean (and max, since we may choose only to trade the maximally correlated securities regardless of industry) crosscorrelation between all combinations of stocks. \\n #This will only run every trading day to prevent computational expense. In that \\n #respect, performs identically to a pipeline add-on (but allows the use of \\\"history\\\") \\n #Try block here incase pipe returns no valid securities. \\n try:\\n \\tprice_history = np.transpose(data.history(context.security_list, fields=\\\"price\\\", bar_count=context.lookback,frequency=\\\"1m\\\"))\\n \\tprice_history=price_history.as_matrix()\\n except:\\n price_history=[[0],[0],[0]]\\n #This returns three arrays, containing a filtered set of maximally cross correlated securities within the last time range (given by context.lookback), their associated (and filtered) time delays corresponding to their maximum correlation, and the degree of their correlation in the given time frame. Essentially, since tau has already been filtered for, the degree of their correlation should be used as a confidence feature to make predictions off of, and tau should be used to determine when to make purchases/sales. \\n #hCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context)\\n #The best securities to trade using this algorithm (each day) are listed in the below lists ***\\n try:\\n \\thCorrVals,maxSecs,timeDelays,short_timeDelays=crossCorr(context.security_list,price_history,context) \\n except: \\n print('Crosscorr Failed')\\n maxSecs,hCorrVals,timeDelays,short_timeDelays=[],[],[],[]\\n #\\\"Globalize\\\" the returned information so that we can handle these commodities every minute. \\n context.Securities=maxSecs\\n context.CorrVals=hCorrVals\\n context.timeDelays=short_timeDelays #************Used to be timeDelays, now however, we calculate a more recent tau\\n context.actionList,context.timerList,context.tradeList,context.tradingNow=[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities),[0]*len(context.Securities) #list of zeros indicating that no stocks should currently be trading\\n #(Note that all stocks should be sold at end of every tradinng day.) \",\n \"def find_coeff(depth, period = 2*pi):\\n\\tfund_feq = 2 * pi / period\\n\\tAK = []\\n\\talphaK = []\\n\\n\\tfor n in range(1, depth+1):\\n\\t\\tdef a_function(x, i):\\n\\t\\t\\treturn input_function(x) * cos(i * fund_feq * x)\\n\\t\\tdef b_function(x, i):\\n\\t\\t\\treturn input_function(x) * sin(i * fund_feq * x)\\n\\t\\t(a, err) = quad(a_function, 0, period, n)\\n\\t\\tan = 2 * a / period\\n\\t\\t(b, err) = quad(b_function, 0, period, n)\\n\\t\\tbn = 2 * b / period\\n\\t\\tAk = math.sqrt(an**2 + bn**2)\\n\\t\\tAK.append(Ak)\\n\\t\\talphak = math.asin(an/Ak)\\n\\t\\talphaK.append(alphak)\\n\\treturn (AK, alphaK)\",\n \"def coef_val():\\n\\n basepath = path.join(path.dirname(path.realpath('__file__')), 'data')\\n fdata = basepath + path.sep + 'VAWTPolySurfaceCoef_pub.csv' # published coefficients from paper\\n # fdata = basepath + path.sep + 'VAWTPolySurfaceCoef.csv' # polynomial surface fitting coefficients\\n\\n loc1 = np.zeros(10)\\n loc2 = np.zeros(10)\\n loc3 = np.zeros(10)\\n spr1 = np.zeros(10)\\n spr2 = np.zeros(10)\\n skw1 = np.zeros(10)\\n skw2 = np.zeros(10)\\n scl1 = np.zeros(10)\\n scl2 = np.zeros(10)\\n scl3 = np.zeros(10)\\n\\n f = open(fdata)\\n csv_f = csv.reader(f)\\n\\n i = 0\\n for row in csv_f:\\n if i != 0:\\n loc1[i-1] = float(row[0])\\n loc2[i-1] = float(row[1])\\n loc3[i-1] = float(row[2])\\n spr1[i-1] = float(row[3])\\n spr2[i-1] = float(row[4])\\n skw1[i-1] = float(row[5])\\n skw2[i-1] = float(row[6])\\n scl1[i-1] = float(row[7])\\n scl2[i-1] = float(row[8])\\n scl3[i-1] = float(row[9])\\n i += 1\\n\\n f.close()\\n\\n return loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3\",\n \"def backtest(self, strategy): \\n \\n # load data\\n data = self.import_data(currency_ids = np.unique(self.signals.currency_id),\\n start_date = self.start_date,\\n end_date = self.end_date)\\n \\n # add cash and columns for currencies\\n data[\\\"capital\\\"] = 0\\n data[\\\"actions\\\"] = \\\"\\\" # should become a dictW \\n data[\\\"description\\\"] = \\\"\\\"\\n data[\\\"capital\\\"].iloc[0] = self.initial_capital\\n data[\\\"worth_usd\\\"] = 0\\n \\n for currency_id in np.unique(self.signals.currency_id):\\n data[currency_id + '_position'] = 0\\n \\n # a sell or buy can influence subsequent positions, so calculate iteratively\\n for observation in range(1, len(data.index)):\\n \\n date = data.index[observation]\\n \\n # investment this period is zero\\n investment_capital_period = 0\\n \\n # amount of currency_ids initially same as last period\\n for currency_id in np.unique(self.signals.currency_id):\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] \\n \\n # at each point, compute size of each position (cash and currencies), and record actions\\n if(data.index[observation] in self.signals.index):\\n \\n action_df = pd.DataFrame(columns=list([\\\"Currency\\\",\\\"NominalAmount\\\", \\\"CapitalAmount\\\"]))\\n \\n # could be multiple actions\\n for index, action in self.signals.loc[date].iterrows(): \\n currency_id = action['currency_id']\\n signal = action['signal']\\n \\n # Buy\\n if signal == 1:\\n \\n # buy for 10% currency_id\\n investment_capital = data[\\\"capital\\\"].iloc[observation-1] * 0.10 \\n\\n # estimate how many coins\\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\\n \\n # calculate exact capital needed\\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\\n investment_capital_period = investment_capital_period + investment_capital_exact \\n \\n # change the amount of currency hold\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] + investment_nominal\\n \\n # report action by appending a Series to the (empty) dataframe\\n action_df = action_df.append(pd.Series({\\\"Currency\\\": currency_id, \\n \\\"NominalAmount\\\": investment_nominal, \\n \\\"CapitalAmount\\\": investment_capital_exact}),ignore_index=True)\\n \\n # report description\\n data[\\\"description\\\"].iloc[observation] = (data[\\\"actions\\\"].iloc[observation] + \\\"\\\\n Buy \\\" + \\n str(investment_nominal) + \\\" \\\" + str(currency_id) + \\n \\\" for \\\" + str(investment_capital_exact))\\n \\n # Sell\\n if signal == -1:\\n \\n # sell currency_id for 10% of total capital\\n investment_capital = data[\\\"capital\\\"].iloc[observation-1] * 0.10 \\n \\n # estimate how many coins\\n investment_nominal = round(investment_capital / data[currency_id].iloc[observation])\\n \\n # calculate exact capital needed\\n investment_capital_exact = investment_nominal * data[currency_id].iloc[observation]\\n investment_capital_period = investment_capital_period - investment_capital_exact\\n \\n # change the amount of currency hold\\n data[currency_id + '_position'].iloc[observation] = data[currency_id + '_position'].iloc[observation-1] - investment_nominal\\n \\n # report action\\n action_df = action_df.append(pd.Series({\\\"Currency\\\": currency_id, \\n \\\"NominalAmount\\\": investment_nominal, \\n \\\"CapitalAmount\\\": investment_capital_exact}),ignore_index=True)\\n \\n # report description\\n data[\\\"description\\\"].iloc[observation] = data[\\\"actions\\\"].iloc[observation] + \\\"Sell \\\" + str(investment_nominal) + \\\" \\\" + str(currency_id) + \\\" for \\\" + str(investment_capital_exact)\\n \\n # report actions\\n data[\\\"actions\\\"].iloc[observation] = action_df.to_json()\\n \\n # calculate resulting cash capital\\n data[\\\"capital\\\"].iloc[observation] = data[\\\"capital\\\"].iloc[observation-1] - investment_capital_period\\n \\n # calculate worth by capital (usd) and each currency * price\\n data[\\\"worth_usd\\\"].iloc[observation] = data[\\\"capital\\\"].iloc[observation] \\n return data\",\n \"def powBeta( n ):\\n return (1-alphaval)*Fib(n) + Fib(n-1)\\n #return Fib(n+1) - Fib(n) * alphaval\",\n \"def phosfracs(h,ks):\\n k1p,k2p,k3p = ks\\n h3po4 = h*h*h\\n h2po4 = k1p*h*h\\n hpo4 = k1p*k2p*h\\n po4 = k1p*k2p*k3p\\n denom = h3po4 + h2po4 + hpo4 + po4\\n h3po4 /= denom\\n h2po4 /= denom\\n hpo4 /= denom\\n po4 /= denom\\n return h3po4,h2po4,hpo4,po4\",\n \"def _compute_empirical_ffreq(self):\\n empirical_ffreq = dict().fromkeys(self.features)\\n for feature in self.features:\\n empirical_ffreq[feature] = sum(\\n [self.indicator_func((_feature, feature))\\n for _x, _y in self.train_set\\n for _feature in _x]\\n )\\n return empirical_ffreq\",\n \"def HFCALC(N, R, Zeta1, Zeta2, Za, Zb, G):\\n # Calculate one and two electron integrals\\n Intgrl(N, R, Zeta1, Zeta2, Za, Zb)\\n # Put all integals into array\\n Colect(N, R, Zeta1, Zeta2, Za, Zb)\\n # Perform the SCF calculation\\n SCF(N, R, Zeta1, Zeta2, Za, Zb, G)\\n return\",\n \"def roccurve(signals, bkgs, cut_function, cut_values):\\n eff_sig, n_pass_sig, n_total_sig = get_eff(svjflatanalysis.iterate(signals), cut_function, cut_values)\\n eff_bkg, n_pass_bkg, n_total_bkg = get_eff(svjflatanalysis.iterate(bkgs), cut_function, cut_values)\\n return eff_sig, eff_bkg, n_pass_sig, n_pass_bkg, n_total_sig, n_total_bkg\",\n \"def _m_to_F_on_basis(self, la):\\n Sym = self._kBoundedRing.ambient()\\n kB = Sym.kBoundedSubspace(self.k, t=1)\\n h = kB.khomogeneous()\\n ks = kB.kschur()\\n return sum( h(ks(x)).coefficient(la) * self(x) for x in PartitionsGreatestLE(sum(la), self.k))\",\n \"def bfgs_method(x0, eps=1e-6, H0=np.eye(18),c1=1e-4):\\n k = 0 # initialize num of outer iterations.\\n inner_k = 0 # initialize inner k iteration.\\n old_xk = None\\n alpha_original = 1\\n alpha = np.copy(alpha_original)\\n xk = x0 # intitialize x.\\n Hk = H0 # initialize H, positive definite matrix.\\n I = np.eye(len(x0)) # idenitity matrix of 2 by 2.\\n\\n alpha_vec = []\\n f_vec = []\\n grad_vec = []\\n inner_k = []\\n conv_c = []\\n\\n while np.linalg.norm(rosen_der(xk)) > eps:\\n pk = -Hk @ rosen_der(xk)\\n\\n xk_next = xk + alpha * pk\\n ink = 0\\n print(xk)\\n while rosen(xk_next) > rosen(xk) + c1 * alpha * (pk.T @ rosen_der(xk)):\\n \\\"\\\"\\\" find a step size that will satisfy Armijo-Goldstein inequality. Modify alpha. \\\"\\\"\\\"\\n alpha = 0.1* alpha\\n xk_next = xk + alpha * pk\\n ink += 1\\n\\n inner_k.append(abs(int(ink)))\\n\\n xk_next = xk + alpha * pk\\n\\n sk = xk_next - xk\\n\\n yk = rosen_der(xk_next) - rosen_der(xk)\\n\\n rho = 1 / (yk.T @ sk)\\n\\n Hk = np.copy((I - rho * sk @ yk.T) @ Hk @ (I - rho * yk @ sk.T) + rho * sk @ sk.T)\\n\\n old_xk = np.copy(xk)\\n xk = np.copy(xk_next)\\n\\n alpha_vec.append(alpha)\\n f_vec.append(rosen(xk))\\n grad_vec.append(np.linalg.norm(rosen_der(xk)))\\n alpha = np.copy(alpha_original)\\n print(f_vec[-1])\\n\\n k += 1\\n\\n return xk, k, inner_k, alpha_vec, f_vec, grad_vec\",\n \"def calcAdl(self):\\n adl = []\\n for i,j in enumerate(self.stock_data['Close']):\\n #Calculating money flow measure\\n mfm_nom = ((j-self.stock_data['Low'][i])-(self.stock_data['High'][i]))\\n mfm_deno = self.stock_data['High'][i]-self.stock_data['Low'][i]\\n mfm = mfm_nom/mfm_deno\\n #Calculating money flow volume\\n mfv = mfm*self.stock_data['Volume'][i]\\n #Calculating accumulated distributin line\\n if not adl:\\n print(mfm)\\n adl.append(mfv)\\n else:\\n print(adl)\\n adl.append(mfv+adl)\\n def_dates, def_points, k = self.angle(self.dates, adl, self.type) \\n return k\",\n \"def test_gamma_basis_hon(self):\\n def row_generator():\\n return [random.betavariate(0.5, 0.5) for i in range(self.d)]\\n\\n self._test_sample_basis_hon(row_generator)\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def gamma(self):\\r\\n raise NotImplementedError('not implemented yet, will use spouge approximation')\",\n \"def _ucb_halluc_acq(x):\\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\\n return mu + beta_th * sigma\",\n \"def _ucb_halluc_acq(x):\\n mu, sigma = gp.eval_with_hallucinated_observations(x, halluc_pts, uncert_form='std')\\n return mu + beta_th * sigma\",\n \"def func_hollomon(eps,k,n):\\n return k * eps**n\",\n \"def RKC2(m,epsilon=0):\\n import sympy\\n one = sympy.Rational(1)\\n\\n x=sympy.Symbol('x')\\n Tm=sympy.polys.orthopolys.chebyshevt_poly(m,x)\\n\\n w0=one+sympy.Rational(epsilon,m**2)\\n w1=sympy.Rational(Tm.diff().subs(x,w0),Tm.diff(x,2).subs(x,w0))\\n\\n alpha=snp.zeros([m+1,m])\\n beta=snp.zeros([m+1,m])\\n\\n b=snp.zeros(m+1)\\n a=snp.zeros(m+1)\\n mu=snp.zeros(m+1)\\n nu=snp.zeros(m+1)\\n mut=snp.zeros(m+1)\\n gamt=snp.zeros(m+1)\\n\\n T2 = sympy.polys.orthopolys.chebyshevt_poly(2,x)\\n b[0]=sympy.Rational(T2.diff(x,2).subs(x,w0),(T2.diff().subs(x,w0))**2)\\n\\n b[1]=one/w0\\n mut[1] = b[1]*w1\\n alpha[1,0]=one\\n beta[1,0]=mut[1]\\n\\n for j in range(2,m+1):\\n Tj=sympy.polys.orthopolys.chebyshevt_poly(j,x)\\n b[j] = sympy.Rational(Tj.diff(x,2).subs(x,w0),(Tj.diff().subs(x,w0))**2)\\n\\n a[j] = one-b[j]*Tj.subs(x,w0)\\n mu[j]= 2*b[j]*w0/b[j-1]\\n nu[j]= -b[j]/b[j-2]\\n mut[j] = mu[j]*w1/w0\\n gamt[j] = -a[j-1]*mut[j]\\n\\n alpha[j,0]=one-mu[j]-nu[j]\\n alpha[j,j-1]=mu[j]\\n alpha[j,j-2]=nu[j]\\n beta[j,j-1]=mut[j]\\n beta[j,0]=gamt[j]\\n\\n shortname='RKC'+str(m)+'2'\\n name = 'Runge-Kutta-Chebyshev ('+str(m)+',2)'\\n return ExplicitRungeKuttaMethod(alpha=alpha,beta=beta,name=name,shortname=shortname)\",\n \"def findAShin(self):\\n #return reduce(lambda x, y: x*y, [self.DoS[key].get_price() for key in self.DoS] )\\n a = array([self.DoS[key].get_Price() for key in self.DoS])\\n return a.prod()**(1.0/len(a))\",\n \"def alpha_rf(port_returns, risk_free_rate, market_returns, b):\\n\\n # the portfolio Alpha is given by the below equation, as stated by the Capital Asset Pricing Model\\n alpha = np.mean(port_returns) - risk_free_rate + b*(np.mean(market_returns) - risk_free_rate)\\n\\n return alpha\",\n \"def alpha_rf(port_returns, risk_free_rate, market_returns, b):\\n\\n # the portfolio Alpha is given by the below equation, as stated by the Capital Asset Pricing Model\\n alpha = np.mean(port_returns) - risk_free_rate + b*(np.mean(market_returns) - risk_free_rate)\\n\\n return alpha\",\n \"def trading_alg(self,table_name = None, buy_now = False, strategy_name = \\\"sma9\\\"):\\n \\n self.bs.buyed_stocks = 0\\n self.bs.money = self.bs.startCredit\\n spy_stocks = self.load_data(table_name = table_name, symbols = [\\\"SPY\\\"])\\n spy_stocks = FinI.add_indicators(spy_stocks)\\n \\n if self.symbols:\\n symbols = self.symbols\\n else:\\n symbols = self.db.get_symbols()\\n\\n # symbols = [\\\"INTC\\\",\\\"BYND\\\",\\\"ZM\\\",\\\"NKE\\\",\\\"HIMX\\\",\\\"JKS\\\",\\\"ENPH\\\",\\\"DUK\\\",\\\"GE\\\",\\\"DIS\\\",\\\"LEVI\\\",\\\"NVAX\\\",\\\"SLCA\\\",\\\"GPS\\\"]\\n \\n for symbol in symbols:\\n print(\\\"symbol: \\\" + str(symbol))\\n \\n sub_data = self.load_data(table_name = table_name, symbols = symbol)\\n if len(sub_data) < 1:\\n break\\n\\n self.bt_stocks = FinI.add_indicators(sub_data)\\n self.bt_stocks = FinI.add_fib(self.bt_stocks)\\n # print(self.bt_stocks)\\n print(self.bt_stocks[\\\"sma30\\\"])\\n print(\\\"calculating percent change:\\\" + str(symbol))\\n # sub_data = self.stocks.loc[self.stocks.sym ==symbol[0]].sort_values(by='index')\\n \\n self.symbols = symbol[0]\\n \\n # self.prev_stock = sub_data.iloc[0]\\n # self.bt_stocks.iloc[0] = sub_data.iloc[0]\\n\\n # self.sell_marks = self.sell_marks.iloc[0:0]\\n # self.buy_marks = self.buy_marks.iloc[0:0]\\n self.bs.transactions = 0\\n self.bs.profit_perc = 0\\n \\n # trend_indicator = \\n # TODO mechanism for select strategies\\n # self.ts_boll(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks)\\n self.ts_eval(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks, strategy_logic = strategy_name)\\n\\n # call the method with passed and assembled name\\n # method = getattr(self, 'ts_' + strategy_name)\\n # method(buy_now = buy_now, at_settings = None, symbol = symbol, spy_stocks = spy_stocks, strategy_name = strategy_name)\",\n \"def _ei_acq(x):\\n mu, sigma = gp.eval(x, uncert_form='std')\\n Z = (mu - curr_best) / sigma\\n return (mu - curr_best)*normal_distro.cdf(Z) + sigma*normal_distro.pdf(Z)\",\n \"def calculate_alphabeta(self, p, prec):\\n var('x')\\n sqrtdelta = None\\n try:\\n M = Qp(p, prec).extension(x ** 2 - self.constants.delta, names=\\\"padicroot\\\")\\n sqrtdelta = M.gen(0)\\n except NotImplementedError:\\n try:\\n M = Qp(p, prec)\\n sqrtdelta = M(self.constants.delta).sqrt()\\n except NotImplementedError:\\n # Exceptional case.\\n M = Qp(p, prec).extension(x ** 2 - self.constants.A * x - self.constants.B, names=\\\"padicroot\\\")\\n alpha = M.gen(0)\\n beta = self.constants.A - alpha\\n return (alpha, beta)\\n\\n alpha = (self.constants.A + sqrtdelta) / 2\\n beta = self.constants.A - alpha\\n return (alpha, beta)\",\n \"def rosenbrockfcn(x: np.ndarray) -> np.ndarray:\\n scores = np.zeros((x.shape[0], 1))\\n n = x.shape[1]\\n assert n >= 1, \\\"Given input X cannot be empty\\\"\\n a = 1\\n b = 100\\n for i in range(n - 1):\\n scores += b * ((x[:, i + 1] - (x[:, i] ** 2)) ** 2) + (\\n (a - x[:, i]) ** 2\\n )\\n return scores\",\n \"def OLSV2_HA(code):\\n if len(code)==6:\\n if (code[0]=='6')|(code[0]=='9'):\\n code='SS_'+code\\n _get_index_data('000001')\\n index1='SS_000001'\\n else:\\n code='SZ_'+code\\n _get_index_data('399001')\\n index1='SZ_399001'\\n elif len(code)==4:\\n code='HK_'+code\\n index1='HK_HSI'\\n else:\\n print('Input Wrong code.')\\n\\n pre_code='YAHOO/'\\n ticker=pre_code+code\\n index1=pre_code+index1\\n\\n fn='./Quandl/'+ticker+'.csv'\\n ind='./Quandl/'+index1+'.csv'\\n\\n df=pd.read_csv(fn,parse_dates=True,index_col=0)\\n dff1=df[['Open','High','Low','Close','Volume','Adjusted Close']].copy()\\n print ('Caculating the analysing 1/4 statistics:')\\n print (dff1.describe(),'\\\\n')\\n dfi=pd.read_csv(ind,parse_dates=True,index_col=0)\\n df['cpct']=df['Close'].pct_change()\\n df['vpct']=df['Volume'].pct_change()\\n dfi['indpct']=dfi['Close'].pct_change()\\n\\n rets=pd.concat([df['cpct'],dfi['indpct'],df['vpct']],axis=1)\\n rets=rets.dropna(how='any')\\n #print (rets)\\n\\n X=np.array(rets.iloc[:,1:3])\\n X=sm.add_constant(X)\\n #print(X)\\n\\n Y=np.array(rets.iloc[:,0])\\n\\n\\n #y=np.dot(X,beta)+e\\n model=sm.OLS(Y,X)\\n results=model.fit()\\n print (results.summary())\\n \\n print (\\\"The params for the model:\\\",results.params)\\n print (\\\"The std for the model:\\\",results.bse)\\n return results\",\n \"def calc_k(self):\\n\\t\\n\\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\\n\\n\\treturn\",\n \"def solve_stationary_equilibrium(self) :\\n \\n \\n \\n \\n #a. find the equilibrium wage given the tax rate and subsidy\\n w_ss = self.find_equilibrium_wage(self.w0_guess, self.w1_guess)\\n \\n #b. obtain firm policy functions and discount present value factors\\n W_e , pol_k, pol_n, pi, W, pol_enter = self.entry_condition(w_ss)\\n \\n \\n #c. obtain the invariant distribution \\n \\n #i. normalized invariant distribution over firms\\n mu_hat = pol_enter/self.lambdaa * self.joint_pdf\\n \\n #ii. labor market clearing (section 3.5), agg demand for labor\\n N_ss = np.sum(np.sum(pol_n*mu_hat, axis=0))\\n \\n #iii. ss equilibrium level of entry (mass of entrants)\\n E_star = 1/N_ss \\n \\n #iv. rescale invariant distribution over firms, mu(s,tau)\\n mu = E_star*mu_hat\\n \\n #d. marginal distributions\\n \\n #i. sum over subsidies, except, taxes of stationary distribution\\n distrib_stationary = np.sum(mu, axis=1)\\n total_mass = np.sum(distrib_stationary)\\n \\n #ii. marginal stationary distribution over productivity\\n pdf_stationary = distrib_stationary / total_mass\\n cdf_stationary = np.cumsum(pdf_stationary)\\n \\n #iii. stationary distribution over number of employed \\n distrib_emp = (pol_n[:,2] * pdf_stationary)/ np.sum(pol_n[:,2] * pdf_stationary)\\n pdf_emp = distrib_emp / np.sum(distrib_emp)\\n cdf_emp = np.cumsum(pdf_emp)\\n \\n #e. Aggregate statistics\\n \\n Y_ss = np.sum(np.sum( self.grid_s_matrix * pol_k**self.alpha * pol_n**self.gamma*mu, axis=0)) #ss output\\n K_ss = np.sum(np.sum(pol_k*mu, axis=0)) #ss capital\\n TFP_ss = Y_ss/(N_ss*E_star)/(K_ss/(N_ss*E_star))**self.alpha\\n total_employment = np.dot(self.labor_demand_rel, distrib_stationary)\\n average_firm_size = total_employment / total_mass\\n \\n #output share of subsidy, excemption, taxed\\n Y_set = np.sum(self.grid_s_matrix * pol_k**self.alpha*pol_n**self.gamma*mu, axis=0) / Y_ss\\n \\n Y_sub_percent = Y_set[0] #output share of establishments that are receiving a subsidy, Y_s/Y\\n Y_exempt_percent = Y_set[1]\\n Y_taxed__Percent = Y_set[2]\\n \\n #the total subsidies paid out to establishments receiving subsidies as a fraction of output. numerator takes first column which is subsidy (S/Y)\\n subsidy_size = np.sum(-self.tau_output[:,0]*self.grid_s_matrix[:,0]*pol_k[:,0]**self.alpha \\\\\\n *pol_n[:,0]**self.gamma*mu[:,0]-self.tau_capital[:,0]*self.ret \\\\\\n *pol_k[:,0]*mu[:,0]-self.tau_labor[:,0]*w_ss* \\\\\\n pol_n[:,0]*mu[:,0]) / Y_ss\\n \\n \\n return Y_ss, K_ss, TFP_ss, average_firm_size, E_star, Y_set, subsidy_size, N_ss, w_ss, cdf_stationary, cdf_emp\",\n \"def BacktestStrategy1(start_cond_dict, df, stock_exchange, invt_dict):\\n total_days=df.shape[0]\\n today_invt_dict=invt_dict\\n invt_daily_list=[] # invt after today's transaction\\n net_wealth_list=[]\\n\\n for i in range(total_days):\\n if i==0:\\n today_invt_dict=stock_exchange.FullBuyStocks(today_invt_dict, i)\\n elif i==total_days-1: # last day\\n today_invt_dict=stock_exchange.FullSellStocks(today_invt_dict, i)\\n invt_daily_list.append(today_invt_dict)\\n net_wealth_list.append(stock_exchange.EstimateNetWealth(today_invt_dict, i))\\n \\n PrintResult(\\\"Baseline Strategy\\\", net_wealth_list)\\n plt.plot(net_wealth_list)\\n plt.title(\\\"Baseline (1st day buy->hold->last day sell) Strategy\\\")\\n plt.ylabel('Net Worth in USD') # Cash + Stock worth\\n plt.show()\\n return\",\n \"def compute_returns(rewards, gamma=1.0):\\n n = 0\\n G = []\\n while n < len(rewards):\\n G.append(0) \\n for i in range(n,len(rewards)):\\n G[n] += (gamma**(i-n))*rewards[i]\\n n+=1\\n\\n return G\",\n \"def eval_costh_phi_fold_HX(data):\\n return data.costh_HX_fold, data.phi_HX_fold\",\n \"def get_alphas(portfolio_returns,risk_free,market_returns,betas):\\r\\n \\r\\n R = portfolio_returns\\r\\n Rf = risk_free\\r\\n Beta = betas\\r\\n Rm = market_returns\\r\\n alpha = R - Rf - (Beta*(Rm-Rf))\\r\\n \\r\\n return alpha\",\n \"def cheb_poly(x, n):\\n if n == 0:\\n return anp.array([1 for i in x])\\n elif n == 1:\\n return x\\n else:\\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\\n\\n raise NotImplementedError(\\\"Problem 6 Incomplete\\\")\",\n \"def eval_abs_costh_phi_fold_HX(data):\\n return data.costh_HX_fold.abs(), data.phi_HX_fold\",\n \"def hr_egn(A, B, R, x0):\\n # A - Adjacency matrix, np.ndarray (N,N)\\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\\n # R - Relationship or preference matrix, np.ndarray (N,N)\\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\\n\\n # Number of players\\n N = A[:, 0].size\\n # Number of strategies\\n S = x0[0, :].size\\n # Degree and degree of preferences\\n d = np.zeros([N, 2])\\n d[:, 0] = np.dot(A, np.ones(N))\\n\\n for v in range(N):\\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\\n\\n # Player v neighborhood\\n k = np.zeros([N, S], dtype='double')\\n for v in range(N):\\n for u in range(N):\\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\\n # Weights the neighborhood\\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\\n\\n # This variable is the increments that x0 receives, the derivative\\n x = np.zeros([N, S], dtype='double')\\n # This is the unit vector with 1 in some entry\\n es = np.zeros(S, dtype='int')\\n\\n # Phi and gamma\\n p = 0\\n g = 0\\n\\n # Auxiliary variables for better clarity\\n aux1 = 0\\n aux2 = 0\\n\\n # Here is the derivative calculation\\n # We first test if all payoffs are the same so we do less comparisons\\n if B.ndim == 2:\\n for v in range(N):\\n for s in range(S):\\n # Set es value\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Same payoff personal equation\\n # First we will do the dot products\\n # e_s*B*k_v\\n aux1 = np.dot(es, np.dot(B, k[v, :]))\\n # x_v*B*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\\n # Finally we subtract them to multiply by r_vv\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Same payoff social equation\\n # x_u*B*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B, es))\\n # x_u*B*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n else:\\n for v in range(N):\\n for s in range(S):\\n # Same thing as before, but now with individual payoffs\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Individual payoffs personal equation\\n # e_s*B_v*k_v\\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\\n # x_u*B_v*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Individual payoffs social equation\\n # x_u*B_u*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\\n # x_u*B_u*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n return x\",\n \"def _ucb_acq(x):\\n mu, sigma = gp.eval(x, uncert_form='std')\\n return mu + beta_th * sigma\",\n \"def _ucb_acq(x):\\n mu, sigma = gp.eval(x, uncert_form='std')\\n return mu + beta_th * sigma\",\n \"def calc_annual_heating_savings (self):\\n price = (self.diesel_prices + self.cd['heating fuel premium'])\\n\\n #~ self.base_heating_cost =\\n\\n #~ self.proposed_heating_cost =\\n\\n\\n\\n\\n self.annual_heating_savings = self.reduction_diesel_used * price\\n #~ print 'self.annual_heating_savings',self.annual_heating_savings\",\n \"def ackley(x):\\n a = 20.0\\n b = 0.2\\n c = 2.0 * np.pi\\n\\n n = np.size(x)\\n s1 = np.sum(x**2)\\n s2 = np.sum(np.cos(c * x))\\n f = (-a * np.exp(-b * np.sqrt(1.0 / n * s1)) - np.exp(1.0 / n * s2) + a +\\n np.exp(1.0))\\n\\n return f\",\n \"def dblcal(self, lowstrike, highstrike, expiry1, expiry2):\\n assert lowstrike < highstrike\\n assert pd.Timestamp(expiry1) < pd.Timestamp(expiry2)\\n _rows1 = {}\\n _rows2 = {}\\n _prices1 = {}\\n _prices2 = {}\\n _index = ['Near Call', 'Far Call', 'Call Ratio', 'Near Put', 'Far Put', \\n 'Put Ratio', 'Near to Far Ratio', 'Debit', 'Underlying_Price', 'Quote_Time']\\n _metrics = pd.DataFrame(index=_index, columns=['Value'])\\n _errmsg = \\\"No key for {} strike {} {}\\\"\\n _opttype = 'call'\\n _rows1[_opttype] = _relevant_rows(self.data, (highstrike, expiry1, _opttype),\\n _errmsg.format(expiry1, highstrike, _opttype))\\n _prices1[_opttype] = _getprice(_rows1[_opttype])\\n _rows2[_opttype] = _relevant_rows(self.data, (highstrike, expiry2, _opttype),\\n _errmsg.format(expiry2, highstrike, _opttype))\\n _prices2[_opttype] = _getprice(_rows2[_opttype])\\n _metrics.loc['Near Call', 'Value'] = _prices1[_opttype]\\n _metrics.loc['Far Call', 'Value'] = _prices2[_opttype]\\n _metrics.loc['Call Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\\n _metrics.loc['Underlying_Price', 'Value'], _metrics.loc['Quote_Time', 'Value'] =\\\\\\n _getkeys(_rows1[_opttype], ['Underlying_Price', 'Quote_Time'])\\n _opttype = 'put'\\n _rows1[_opttype] = _relevant_rows(self.data, (lowstrike, expiry1, _opttype),\\n _errmsg.format(expiry1, lowstrike, _opttype))\\n _prices1[_opttype] = _getprice(_rows1[_opttype])\\n _rows2[_opttype] = _relevant_rows(self.data, (lowstrike, expiry2, _opttype),\\n _errmsg.format(expiry2, lowstrike, _opttype))\\n _prices2[_opttype] = _getprice(_rows2[_opttype])\\n _metrics.loc['Near Put', 'Value'] = _prices1[_opttype]\\n _metrics.loc['Far Put', 'Value'] = _prices2[_opttype]\\n _metrics.loc['Put Ratio', 'Value'] = _prices1[_opttype] / _prices2[_opttype]\\n _neartot = sum(_prices1.values())\\n _fartot = sum(_prices2.values())\\n _metrics.loc['Near to Far Ratio', 'Value'] = float(_neartot) / _fartot\\n _metrics.loc['Debit', 'Value'] = _fartot - _neartot\\n return _metrics\",\n \"def parab(C,gamma):\\r\\n return 5.678 - ((1.234 - C)**2 + (3.456 - gamma)**2)\",\n \"def chebcoef(self,f,n,m,Kmin,Kmax):\\n z = -cos((linspace(1,m,m)*2-1)*pi/(2*m*1.0))\\n x = (z+1)*(Kmax-Kmin)/2.0 + Kmin\\n y = f(x)\\n # print 'x, f(x):', x, y\\n T0 = ones(m)\\n T1 = z\\n a = zeros(n+1)\\n a[0] = sum(y)/(m*1.0)\\n a[1] = dot(y,T1)/dot(T1,T1)\\n for i in range(2,n+1):\\n T = 2*z*T1 - T0\\n a[i] = dot(y,T)/(dot(T,T)*1.0)\\n T0 = T1\\n T1 = T\\n return a\",\n \"def pareto_frontier(cmrf,featlist) :\\n\\tQ = []\\n\\ttaboodict = {}\\n\\tnStates = len(featlist)\\n\\tfeat1,feat2 = featlist\\n\\tEaxa,Xa = cmrf.decode(feat1)\\n\\tEbxb,Xb = cmrf.decode(feat2)\\n\\tif Xa == Xb : \\n\\t\\treturn [Xa],[(Eaxa,Ebxb)]\\n\\tEaxb = cmrf.score(Xb,feat1)\\n\\tEbxa = cmrf.score(Xa,feat2)\\n\\tQ.append((Xa,Xb))\\n\\tfrontier,frontier_energy = [],[]\\n\\tfrontier.extend([Xa,Xb])\\n\\tfrontier_energy.extend([(Eaxa,Ebxa),(Eaxb,Ebxb)])\\n\\ttaboodict[(Eaxa,Ebxa)] = 1;\\n\\ttaboodict[(Eaxb,Ebxb)] = 1;\\n\\twhile len(Q) > 0 :\\n\\t\\t### Optimize \\n\\t\\tXa,Xb = Q[0]\\n\\t\\tQ = Q[1:] # Dequeue\\n\\t\\tEaxb = cmrf.score(Xb,feat1)\\n\\t\\tEbxa = cmrf.score(Xa,feat2)\\t\\n\\t\\tEaxa = cmrf.score(Xa,feat1)\\n\\t\\tEbxb = cmrf.score(Xb,feat2)\\t\\n\\t\\tm = (Ebxa - Ebxb)/(Eaxa-Eaxb)\\n\\t\\tif m > 0 : \\n\\t\\t\\t#stop()\\n\\t\\t\\tsys.stderr.write(\\\"### WARNING : Slope > 0. Cvxhull failed\\\")\\n\\t\\t\\treturn frontier,frontier_energy\\n\\t\\tthetaa = -m/(1-m)\\n\\t\\tthetab = 1/(1-m)\\n\\t\\ttmrf = TMRF(cmrf,[thetaa,thetab],[feat1,feat2])\\n\\t\\tXab = tmrf.decode()[1]\\n\\t\\tEaxab = cmrf.score(Xab,feat1)\\n\\t\\tEbxab = cmrf.score(Xab,feat2)\\n\\t\\tif Xab != Xa and Xab != Xb and \\\\\\n\\t\\t\\tnot taboodict.has_key((Eaxab,Ebxab)) :\\n\\t\\t\\t# Check almost equal condition\\n\\t\\t\\tif any(map(lambda(x):almost_eq(Eaxab,x[0] or \\\\\\n\\t\\t\\t\\talmost_eq(Ebxab,x[1])),taboodict.keys())) : \\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tfrontier.append(Xab)\\n\\t\\t\\tfrontier_energy.append((Eaxab,Ebxab))\\n\\t\\t\\ttaboodict[(Eaxab,Ebxab)]=1\\n\\t\\t\\tQ.extend([(Xa,Xab),(Xab,Xb)])\\n\\t# Calculate energy of frontier elements\\t\\n\\treturn frontier,frontier_energy\",\n \"def calc_capital_costs (self):\\n powerhouse_control_cost = 0\\n if not self.cd['switchgear suitable for renewables']:\\n powerhouse_control_cost = self.cd['switchgear cost']\\n\\n #~ road_needed = self.comp_specs['road needed for transmission line']\\n\\n\\n if str(self.comp_specs['transmission capital cost'])\\\\\\n != 'UNKNOWN':\\n transmission_line_cost = \\\\\\n int(self.comp_specs['transmission capital cost'])\\n else:\\n if str(self.comp_specs['distance to resource']) \\\\\\n != 'UNKNOWN':\\n distance = \\\\\\n float(self.comp_specs\\\\\\n ['distance to resource'])\\n transmission_line_cost = \\\\\\n distance*self.comp_specs['est. transmission line cost']\\n\\n secondary_load_cost = 0\\n if self.comp_specs['secondary load']:\\n secondary_load_cost = self.comp_specs['secondary load cost']\\n\\n if str(self.comp_specs['generation capital cost']) \\\\\\n != 'UNKNOWN':\\n wind_cost = \\\\\\n int(self.comp_specs['generation capital cost'])\\n self.cost_per_kw = np.nan\\n else:\\n for i in range(len(self.comp_specs['estimated costs'])):\\n if int(self.comp_specs['estimated costs'].iloc[i].name) < \\\\\\n self.load_offset_proposed:\\n if i == len(self.comp_specs['estimated costs']) - 1:\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n continue\\n\\n cost = float(self.comp_specs['estimated costs'].iloc[i])\\n break\\n\\n wind_cost = self.load_offset_proposed * cost\\n self.cost_per_kw = cost\\n\\n #~ print powerhouse_control_cost\\n #~ print transmission_line_cost\\n #~ print secondary_load_cost\\n #~ print wind_cost\\n self.capital_costs = powerhouse_control_cost + transmission_line_cost +\\\\\\n secondary_load_cost + wind_cost\\n\\n #~ print 'self.capital_costs',self.capital_costs\",\n \"def compute_effective_quantities(r, cosmo, p=None, P0=3e4, ell=0):\\n assert 'Z' in r.columns\\n assert 'NZ' in r.columns\\n\\n # weights\\n w_fkp = 1. / (1 + r['NZ']*P0)\\n if p is not None:\\n w1 = fnl_weight(r['Z'], p=p)\\n w2 = bias_weight(r['Z'], cosmo, ell=ell)\\n else:\\n w1 = w2 = 1.0\\n\\n # effective redshift\\n A = (r['Z'] * r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\\n norm = (r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\\n z_eff = A/norm\\n\\n # effective nbar\\n A = (r['NZ'] * r['NZ'] * w_fkp**2 * w1 * w2).sum().compute()\\n nbar_eff = A/norm\\n\\n return z_eff, nbar_eff\",\n \"def holland(p_values, control):\\n\\n # Initial Checking\\n if type(p_values) == pd.DataFrame:\\n algorithms = p_values.columns\\n p_values = p_values.values\\n elif type(p_values) == np.ndarray:\\n algorithms = np.array([\\\"Alg%d\\\" % alg for alg in range(p_values.shape[1])])\\n\\n if type(control) == str:\\n control = int(np.where(algorithms == control)[0])\\n if control is None:\\n raise ValueError(\\\"Initialization ERROR. Incorrect value for control.\\\")\\n\\n # --------------------------------------------------------------------------\\n # ------------------------------- Procedure --------------------------------\\n # --------------------------------------------------------------------------\\n k = p_values.shape[1]\\n\\n # sort p-values p(0) <= p(1) <= ... <= p(k-1)\\n argsorted_pvals = np.argsort(p_values[0, :])\\n\\n APVs = np.zeros((k - 1, 1))\\n comparison = []\\n for i in range(k - 1):\\n comparison.append(algorithms[control] + \\\" vs \\\" + algorithms[argsorted_pvals[i]])\\n aux = k - 1 - np.arange(i + 1)\\n v = np.max(1 - (1 - p_values[0, argsorted_pvals[: (i + 1)]]) ** aux)\\n APVs[i, 0] = np.min([v, 1])\\n return pd.DataFrame(data=APVs, index=comparison, columns=[\\\"Holland\\\"])\",\n \"def prob3(x0 = 0, K = 9):\\n #Code from prob1start\\n x = sy.symbols('x')\\n exp = (sy.sin(x) + 1)**(sy.sin(sy.cos(x)))\\n der = sy.simplify(sy.diff(exp, x))\\n \\n f = sy.lambdify(x, exp)\\n f1 = sy.lambdify(x, der)\\n #Code from prob 1 end\\n \\n #just for ease of coding...\\n difD = np.array(x0)\\n \\n #Initialize what I want\\n FDQ1 = []\\n FDQ2 = []\\n BDQ1 = []\\n BDQ2 = []\\n CDQ2 = []\\n CDQ4 = []\\n N = []\\n correct = f1(x0)\\n \\n #Get errors\\n for i in range(0, K):\\n n = 10**(-i)\\n \\n N.append(n)\\n \\n FDQ1.append(np.abs(correct - fdq1(f, difD, h = n)))\\n \\n FDQ2.append(np.abs(correct - fdq2(f, difD, h = n)))\\n \\n BDQ1.append(np.abs(correct - bdq1(f, difD, h = n)))\\n \\n BDQ2.append(np.abs(correct - bdq2(f, difD, h = n)))\\n \\n CDQ2.append(np.abs(correct - cdq2(f, difD, h = n)))\\n \\n CDQ4.append(np.abs(correct - cdq4(f, difD, h = n)))\\n \\n #Plot results\\n plt.loglog(N, FDQ1, label = \\\"Order 1 Forward\\\")\\n plt.loglog(N, FDQ2, label = \\\"Order 2 Forward\\\")\\n plt.loglog(N, BDQ1, label = \\\"Order 1 Backward\\\")\\n plt.loglog(N, BDQ2, label = \\\"Order 2 Backward\\\")\\n plt.loglog(N, CDQ2, label = \\\"Order 2 Centered\\\")\\n plt.loglog(N, CDQ4, label = \\\"Order 4 Centered\\\")\\n \\n #Tidy results\\n plt.xlabel(\\\"h\\\")\\n plt.ylabel(\\\"Absolute Error\\\")\\n plt.title(\\\"title for approximate derivative errors graphs that isn\\\\'t in book\\\")\\n plt.legend(loc = 2)\\n plt.show()\\n return\\n raise NotImplementedError(\\\"Problem 3 Incomplete\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5805574","0.568245","0.5679868","0.5634262","0.55871993","0.54936045","0.5484346","0.54805106","0.5462374","0.5451627","0.54347575","0.54347575","0.54025716","0.53955644","0.5385762","0.5380132","0.53783524","0.53712624","0.5367456","0.5344546","0.53184885","0.53136396","0.53129596","0.53116596","0.5274351","0.52661026","0.52560955","0.52494544","0.5248396","0.52479804","0.523862","0.5234577","0.523053","0.52239645","0.5220691","0.5207377","0.52053726","0.52037615","0.5194783","0.5188641","0.5184852","0.5182339","0.51763755","0.517497","0.51690793","0.516057","0.5157357","0.51549447","0.51538277","0.51513976","0.5138098","0.513571","0.51273847","0.51266694","0.5123667","0.5116139","0.511146","0.51112807","0.50982463","0.5098024","0.5093998","0.5093944","0.5093724","0.5092128","0.5091324","0.5089925","0.5089925","0.5081451","0.5075981","0.5075981","0.507486","0.5073405","0.5071183","0.50694066","0.50694066","0.50651133","0.5063233","0.5059312","0.50577366","0.50563174","0.5048258","0.50460184","0.5045749","0.50409585","0.5038202","0.5037213","0.50352913","0.50331783","0.502363","0.5022978","0.5022978","0.5016584","0.50122","0.50098515","0.50052315","0.50040466","0.50019515","0.49999174","0.4995773","0.49925995","0.49918908"],"string":"[\n \"0.5805574\",\n \"0.568245\",\n \"0.5679868\",\n \"0.5634262\",\n \"0.55871993\",\n \"0.54936045\",\n \"0.5484346\",\n \"0.54805106\",\n \"0.5462374\",\n \"0.5451627\",\n \"0.54347575\",\n \"0.54347575\",\n \"0.54025716\",\n \"0.53955644\",\n \"0.5385762\",\n \"0.5380132\",\n \"0.53783524\",\n \"0.53712624\",\n \"0.5367456\",\n \"0.5344546\",\n \"0.53184885\",\n \"0.53136396\",\n \"0.53129596\",\n \"0.53116596\",\n \"0.5274351\",\n \"0.52661026\",\n \"0.52560955\",\n \"0.52494544\",\n \"0.5248396\",\n \"0.52479804\",\n \"0.523862\",\n \"0.5234577\",\n \"0.523053\",\n \"0.52239645\",\n \"0.5220691\",\n \"0.5207377\",\n \"0.52053726\",\n \"0.52037615\",\n \"0.5194783\",\n \"0.5188641\",\n \"0.5184852\",\n \"0.5182339\",\n \"0.51763755\",\n \"0.517497\",\n \"0.51690793\",\n \"0.516057\",\n \"0.5157357\",\n \"0.51549447\",\n \"0.51538277\",\n \"0.51513976\",\n \"0.5138098\",\n \"0.513571\",\n \"0.51273847\",\n \"0.51266694\",\n \"0.5123667\",\n \"0.5116139\",\n \"0.511146\",\n \"0.51112807\",\n \"0.50982463\",\n \"0.5098024\",\n \"0.5093998\",\n \"0.5093944\",\n \"0.5093724\",\n \"0.5092128\",\n \"0.5091324\",\n \"0.5089925\",\n \"0.5089925\",\n \"0.5081451\",\n \"0.5075981\",\n \"0.5075981\",\n \"0.507486\",\n \"0.5073405\",\n \"0.5071183\",\n \"0.50694066\",\n \"0.50694066\",\n \"0.50651133\",\n \"0.5063233\",\n \"0.5059312\",\n \"0.50577366\",\n \"0.50563174\",\n \"0.5048258\",\n \"0.50460184\",\n \"0.5045749\",\n \"0.50409585\",\n \"0.5038202\",\n \"0.5037213\",\n \"0.50352913\",\n \"0.50331783\",\n \"0.502363\",\n \"0.5022978\",\n \"0.5022978\",\n \"0.5016584\",\n \"0.50122\",\n \"0.50098515\",\n \"0.50052315\",\n \"0.50040466\",\n \"0.50019515\",\n \"0.49999174\",\n \"0.4995773\",\n \"0.49925995\",\n \"0.49918908\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84681,"cells":{"query":{"kind":"string","value":"returns coefficients of Chebyshev Regression of f with m sample points on the interval [min,max], and n is the order of chebyshev polynomials"},"document":{"kind":"string","value":"def chebcoef(self,f,n,m,Kmin,Kmax):\n z = -cos((linspace(1,m,m)*2-1)*pi/(2*m*1.0))\n x = (z+1)*(Kmax-Kmin)/2.0 + Kmin\n y = f(x)\n # print 'x, f(x):', x, y\n T0 = ones(m)\n T1 = z\n a = zeros(n+1)\n a[0] = sum(y)/(m*1.0)\n a[1] = dot(y,T1)/dot(T1,T1)\n for i in range(2,n+1):\n T = 2*z*T1 - T0\n a[i] = dot(y,T)/(dot(T,T)*1.0)\n T0 = T1\n T1 = T\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 chebyshev_coeffs(f, n):\n extrema = np.cos((np.pi * np.arange(2*n))/n)\n samples = f(extrema)\n coeffs = np.real(np.fft.fft(samples))[:n+1]\n coeffs /= n \n coeffs[0] /= 2\n coeffs[n] /= 2\n\n return coeffs","def random_coefficients(self, n=3, max_range = 10):\n return np.random.uniform(-1*max_range, max_range, n)","def cheb_poly(x, n):\n if n == 0:\n return anp.array([1 for i in x])\n elif n == 1:\n return x\n else:\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\n\n raise NotImplementedError(\"Problem 6 Incomplete\")","def coefficients_from_Weierstrass_polynomial(f):\n R = f.parent()\n cubic_variables = [x for x in R.gens() if f.degree(x) == 3]\n quadratic_variables = [y for y in R.gens() if f.degree(y) == 2]\n try:\n x = cubic_variables[0]\n y = quadratic_variables[0]\n except IndexError:\n raise ValueError('polynomial is not in long Weierstrass form')\n\n a1 = a2 = a3 = a4 = a6 = 0\n x3 = y2 = None\n for coeff, mon in f:\n if mon == x**3:\n x3 = coeff\n elif mon == x**2:\n a2 = coeff\n elif mon == x:\n a4 = coeff\n elif mon == 1:\n a6 = coeff\n elif mon == y**2:\n y2 = -coeff\n elif mon == x*y:\n a1 = -coeff\n elif mon == y:\n a3 = -coeff\n else:\n raise ValueError('polynomial is not in long Weierstrass form')\n\n if x3 != y2:\n raise ValueError('the coefficient of x^3 and -y^2 must be the same')\n elif x3 != 1:\n a1, a2, a3, a4, a6 = a1/x3, a2/x3, a3/x3, a4/x3, a6/x3\n return [a1, a2, a3, a4, a6]","def h(n, x, orthonormal=True):\n h = polynomial.polyval(x, h_coefs[n])\n return h","def polyfit_with_fixed_points(n, x, y, xf, yf):\n import numpy as np\n x = np.asarray(x)\n y = np.asarray(y)\n xf = np.asarray(xf,dtype=float)\n yf = np.asarray(yf,dtype=float)\n mat = np.empty((n + 1 + len(xf),) * 2)\n vec = np.empty((n + 1 + len(xf),))\n x_n = x**np.arange(2 * n + 1)[:, None]\n yx_n = np.sum(x_n[:n + 1] * y, axis=1)\n x_n = np.sum(x_n, axis=1)\n idx = np.arange(n + 1) + np.arange(n + 1)[:, None]\n mat[:n + 1, :n + 1] = np.take(x_n, idx)\n xf_n = xf**np.arange(n + 1)[:, None]\n mat[:n + 1, n + 1:] = old_div(xf_n, 2)\n mat[n + 1:, :n + 1] = xf_n.T\n mat[n + 1:, n + 1:] = 0\n vec[:n + 1] = yx_n\n vec[n + 1:] = yf\n params = np.linalg.solve(mat, vec)\n return params[:n + 1]","def chebyshev_polynomial(X, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n T_k = list()\n T_k.append(sp.eye(X.shape[0]).tocsr())\n T_k.append(X)\n\n def chebyshev_recurrence(T_k_minus_one, T_k_minus_two, X):\n X_ = sp.csr_matrix(X, copy=True)\n return 2 * X_.dot(T_k_minus_one) - T_k_minus_two\n\n for i in range(2, k+1):\n T_k.append(chebyshev_recurrence(T_k[-1], T_k[-2], X))\n\n return T_k","def modified_chebyshev(nterms, moments, input_coefs=None):\n moments = np.asarray(moments)\n assert moments.ndim == 1\n nmoments = moments.shape[0]\n if nterms > nmoments/2:\n msg = 'nterms and nmoments are inconsistent. '\n msg += 'Not enough moments specified'\n raise Exception(msg)\n\n if input_coefs is None:\n # the unmodified polynomials are monomials\n input_coefs = np.zeros((nmoments, 2))\n\n assert nmoments == input_coefs.shape[0]\n\n ab = np.zeros((nterms, 2))\n ab[0, 0] = input_coefs[0, 0]+moments[1]/moments[0]\n ab[0, 1] = moments[0]\n\n sigma = np.zeros(2*nterms)\n sigma_m2 = np.zeros_like(sigma)\n sigma_m1 = moments[0:2*nterms].copy()\n for kk in range(1, nterms):\n sigma[:] = 0\n idx = 2*nterms-kk\n for ll in range(kk, 2*nterms-kk):\n sigma[kk:idx] = sigma_m1[kk+1:idx+1] -\\\n (ab[kk-1, 0]-input_coefs[kk:idx, 0])*sigma_m1[kk:idx] -\\\n ab[kk-1, 1]*sigma_m2[kk:idx]+input_coefs[kk:idx, 1] *\\\n sigma_m1[kk-1:idx-1]\n # sigma[ll]=sigma_m1[ll+1]-\\\n # (ab[kk-1,0]-input_coefs[ll,0])*sigma_m1[ll] - \\\n # ab[kk-1,1]*sigma_m2[ll]+input_coefs[ll,1]*sigma_m1[ll-1]\n ab[kk, 0] = input_coefs[kk, 0]+sigma[kk+1]/sigma[kk] -\\\n sigma_m1[kk]/sigma_m1[kk-1]\n ab[kk, 1] = sigma[kk]/sigma_m1[kk-1]\n sigma_m2 = sigma_m1.copy()\n sigma_m1 = sigma.copy()\n\n return ab","def cheby_coeff(g, m, N=None, arange=(-1,1)):\r\n if N is None:\r\n N = m+1\r\n\r\n a1 = (arange[1] - arange[0]) / 2.0\r\n a2 = (arange[1] + arange[0]) / 2.0\r\n n = np.pi * (np.r_[1:N+1] - 0.5) / N\r\n s = g(a1 * np.cos(n) + a2)\r\n c = np.zeros(m+1)\r\n for j in range(m+1):\r\n c[j] = np.sum(s * np.cos(j * n)) * 2 / N\r\n\r\n return c","def hyperbolic_decay(mul, pow, n, min=0.1):\n return np.vstack([mul * np.power(1 / np.arange(1, n + 1), pow), [min] * n]).max(0).tolist()","def basis_fns(n=0):\n return lambda x: np.sum(x ** (n+1), axis=1)","def cheby_coeff2(m,s):\r\n c = np.zeros(m+1)\r\n for j in range(m+1):\r\n c[j] = 2*np.exp(-s)*j1(-s)\r\n \r\n return c","def conway_polynomial(n=100):\n \n xs = []\n ys = []\n for i in range(n):\n x = (i - n/2) / 50\n xs.append(x)\n\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\n\n ys.append(y)\n\n return xs, ys","def bspline_basis(c, n, degree):\n # Create knot vector and a range of samples on the curve\n kv = np.array([0] * degree + [i for i in range(c - degree + 1)] +\n [c - degree] * degree, dtype='int') # knot vector\n u = np.linspace(0, c - degree, n) # samples range\n\n # Cox - DeBoor recursive function to calculate basis\n @memo\n def coxDeBoor(k, d):\n # Test for end conditions\n if (d == 0):\n return ((u - kv[k] >= 0) & (u - kv[k + 1] < 0)).astype(int)\n\n denom1 = kv[k + d] - kv[k]\n term1 = 0\n if denom1 > 0:\n term1 = ((u - kv[k]) / denom1) * coxDeBoor(k, d - 1)\n\n denom2 = kv[k + d + 1] - kv[k + 1]\n term2 = 0\n if denom2 > 0:\n term2 = ((-(u - kv[k + d + 1]) / denom2) * coxDeBoor(k + 1, d - 1))\n\n return term1 + term2\n\n # Compute basis for each point\n b = np.column_stack([coxDeBoor(k, degree) for k in range(c)])\n b[n - 1][-1] = 1\n\n return b","def poly(df, n):\n poly = pd.Series(df.x**n, name=\"poly_\" + str(n))\n df = df.join(poly)\n return df","def get_polyfit_function(self):\n N = len(self.coefficients)\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )","def Bpoly(n, x):\n n = int(n)\n out = 0\n for k in xrange(0, n+1):\n out += comb(n,k)*Bnum(n-k)*x**float(k)\n return out","def formHn(n,min,max,N):\n pas = abs((max-min)/N)\n x = min\n result = np.array([])\n \n for i in range(0,N):\n result = np.append(result,H(n,x))\n x += pas \n return result","def poly_nth(f, n):\n if n < 0 or n > len(f)-1:\n raise IndexError\n else:\n return f[zzx_degree(f)-n]","def get_poly(self, n, xf = 14, y0=[1, 0], first_step = 1e-10, max_step = .1):\n self.n = n\n y0s = [1- first_step**2/2, - first_step]\n sol = integ.solve_ivp(lambda t, y: self.f(t, y, n), (first_step, xf), y0s, max_step=max_step, \\\n vectorized=True, events=self.find_zero)\n data_sol = np.array([sol.t, sol.y[0], sol.y[1]])\n data_sol[1, -1] = 1e-18\n data0 = np.array([0, y0[0], y0[1]]).reshape(3, 1)\n self.poly = np.concatenate((data0, data_sol), axis=1)","def zzX_pow(f, n):\n if poly_univariate_p(f):\n return zzx_pow(f, n)\n if not n:\n return zzX_const_of(f, 1)\n if n == 1 or zzX_zero_p(f) or zzX_one_p(f):\n return f\n\n g = zzX_const_of(f, 1)\n\n while True:\n n, m = n//2, n\n\n if m & 1:\n g = zzX_mul(g, f)\n\n if n == 0:\n break\n\n f = zzX_sqr(f)\n\n return g","def get_cheb_extrema(a, b, n):\n\n # nodes (Chebyshev extrema)\n x = np.array(list(reversed(np.cos((np.pi * np.arange(n)) / n))))\n # scale to (a, b)\n return (x * (b - a) + b + a) / 2","def get_params(H, n_qubits, p):\n# function to optimimize\n def fun(x):\n# we minimize f to find max for F \n return cost_function(H, n_qubits, p, params=x)[0]\n# starting point\n params_0=[0.25*np.pi for i in range(2*p)]\n params_min=[0 for i in range(2*p)]\n params_max=[2*np.pi if i%2==0 else np.pi for i in range(2*p)]\n # the bounds required by L-BFGS-B\n bounds = [(low, high) for low, high in zip(params_min, params_max)]\n# use method L-BFGS-B because the problem is smooth and bounded\n result = scipy.optimize.minimize(fun, params_0, method=\"TNC\",bounds=bounds)\n return [result.x[i] for i in range(2*p)]","def LinkwitzRileyCrossOver(f_c_m, fs, f):\n # transform the frequency bins into normalized radian frequency\n # Lowpass\n # lowpass coefficients\n b_xo_low, a_xo_low = sig.butter(2, f_c_m/(fs/2), btype='lowpass')\n # Complex frequency response of the second order Butterworth filter\n f_xo_low, D_xo_low = sig.freqz(b_xo_low, a_xo_low, worN=f, fs=fs)\n D_xo_low = D_xo_low * D_xo_low\n \n # Highpass\n # highpass coefficients\n b_xo_high, a_xo_high = sig.butter(2, f_c_m/(fs/2), btype='highpass')\n # Complex frequency response of the second order Butterworth filter\n f_xo_low, D_xo_high = sig.freqz(b_xo_high, a_xo_high, worN=f, fs=fs)\n D_xo_high = D_xo_high * D_xo_high\n \n return D_xo_low, D_xo_high","def prob6(n = 5):\n domain = np.linspace(-1,1, 100)\n X = anp.array(list(domain), dtype = anp.float)\n dTn = auto.elementwise_grad(cheb_poly)\n primes = []\n \n for i in range(0, n):\n primes.append(dTn(X, i))\n \n #Plot graphs\n fig, graph = plt.subplots(3, 2)\n \n graph[0, 0].plot(X, primes[0], label = \"T0\")\n graph[0, 0].set_title(\"Chebyshev - T0\")\n \n graph[0, 1].plot(X, primes[1], label = \"T1\")\n graph[0, 1].set_title(\"Chebyshev - T1\")\n \n graph[1, 0].plot(X, primes[2], label = \"T2\")\n graph[1, 0].set_title(\"Chebyshev - T2\")\n \n graph[1, 1].plot(X, primes[3], label = \"T3\")\n graph[1, 1].set_title(\"Chebyshev - T3\")\n \n graph[2, 0].plot(X, primes[4], label = \"T4\")\n graph[2, 0].set_title(\"Chebyshev - T4\")\n \n plt.tight_layout()\n \n return","def fht(x, N):\n if N == 2:\n return np.array([x[0] + x[1], x[0] - x[1]])\n else:\n m = int(N/2)\n y_t = fht(x[0:N:2],m) \n y_b = fht(x[1:N:2],m)\n H_N_C = np.cos((2*PI*np.arange(m))/N)\n H_N_S = np.sin((2*PI*np.arange((m)))/N)\n idx_map = np.concatenate(([0], np.arange(m - 1, 0, -1)))\n y_1 = y_t + np.multiply(H_N_C,y_b) + np.multiply(H_N_S, y_b[idx_map])\n idx_map = np.concatenate(([0], np.arange(m - 1, 0, -1)))#Modulo N/2\n y_2 = y_t - np.multiply(H_N_C,y_b) - np.multiply(H_N_S, y_b[idx_map])\n y = np.concatenate((y_1, y_2))\n return y","def get_poly_cc(n, k, t):\n assert (n > 0 and k >= 0), \"order and derivative must be positive.\"\n\n cc = np.ones(n)\n D = np.linspace(0, n-1, n)\n\n for i in range(n):\n for j in range(k):\n cc[i] = cc[i] * D[i]\n D[i] = D[i] - 1\n if D[i] == -1:\n D[i] = 0\n\n for i, c in enumerate(cc):\n cc[i] = c * np.power(t, D[i])\n\n return cc","def Generate_Custom(f, n, m):\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))","def getEG(n,int_method,func) :\n m = np.asarray([0.5,0.6,0.7,0.8,0.9,1,1.1,1.2,1.3,1.4,1.5,2,2.5,3,3.5,4,\n 4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10])\n bes = np.asarray([0.5,0.47768,0.44879,0.39831,0.25858,0,0.15502,0.25699,\n 0.30896,0.35245,0.39119,0.51822,0.53678,0.54984,0.55847,\n 0.56395,0.57054,0.57950,0.58402,0.58765,0.59512,0.60214,\n 0.60469,0.61143,0.61789,0.62443,0.63097,0.63694])\n p = np.asarray([1,0.85417,0.94685,1.04467,2.55052,0,1.59086,\n 1.00670,0.88866,0.83763,0.81030,0.76108,0.83093,0.86863,\n 0.89233,0.90909,0.92097,0.93007,0.93735,0.94332,0.94813,\n 0.95193,0.95557,0.95864,0.96107,0.96360,0.96570,\n 0.96788])\n h0 = np.asarray([0,-0.03567,-0.04808,-0.04315,-0.01879,0,0.00041,0.00069,\n 0.00639,0.01405,0.02294,0.07814,0.13994,0.19278,0.23793,\n 0.27678,0.31039,0.33974,0.36585,0.38917,0.41003,0.42891,\n 0.44621,0.46195,0.47644,0.48982,0.50223,0.51379])\n h1 = np.asarray([0,0.26899, 0.10571,0.01763,-0.39382,0,0.15211,0.05665,\n 0.00933,-0.02791,-0.05876,-0.16720,-0.13033,-0.10455 ,\n -0.08618,-0.07208,-0.06179,-0.05369,-0.04715,-0.04176,\n -0.03742,-0.03408,-0.03081,-0.02808,-0.02599,-0.02375,\n -0.02194,-0.02004])\n h2 = np.asarray([0,-0.09016,-0.06893,-0.04971,-0.08828,0,-0.03341,\n -0.03964,-0.04456,-0.04775,-0.04984,-0.05381,-0.03570,\n -0.02476,-0.01789,-0.01333,-0.01028,-0.00812,-0.00653,\n -0.00534,-0.00444,-0.00376,-0.00319,-0.00274,-0.00238,\n -0.00207,-0.00182,-0.00160])\n h3 = np.asarray([0,0.03993,0.03363,0.02216,-0.00797,0,0.00899,0.01172,\n 0.01150,0.01026,0.00860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n 0])\n \n if (func == True) :\n int_bes = splev(n,splrep(m, bes))\n int_p = splev(n,splrep(m, p))\n int_h0 = splev(n,splrep(m, h0))\n int_h1 = splev(n,splrep(m, h1))\n int_h2 = splev(n,splrep(m, h2))\n int_h3 = splev(n,splrep(m, h3))\n else :\n int_bes = griddata(m, bes, n, method=int_method)\n int_p = griddata(m, p, n, method=int_method)\n int_h0 = griddata(m, h0, n, method=int_method)\n int_h1 = griddata(m, h1, n, method=int_method)\n int_h2 = griddata(m, h2, n, method=int_method)\n int_h3 = griddata(m, h3, n, method=int_method)\n \n return np.asarray([int_bes,int_p,int_h0,int_h1,int_h2,int_h3])","def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\r\n\r\n # replace these lines with your solution\r\n initial_T = time.time()\r\n\r\n def get_points(f, a, b, n):\r\n x = np.linspace(a, b, n)\r\n y_lst = f(x)\r\n y = np.array(y_lst)\r\n\r\n return x, y\r\n\r\n def build_vector(x, y, size, deg):\r\n if deg == size:\r\n y_n = y.sum()\r\n else:\r\n y_n = np.dot(y, (x ** (size - deg)))\r\n pol1 = np.zeros(size + 1)\r\n for i in range(size + 1):\r\n pol1[i] = (x ** (2 * size - deg - i)).sum()\r\n return pol1, y_n\r\n\r\n def build_coeff_matrix(f, a, b, n, d):\r\n x, y = get_points(f, a, b, n)\r\n deg = d\r\n b = np.array([])\r\n coeff_matrix = np.array([])\r\n for i in range(d + 1):\r\n x_n, y_n = build_vector(x, y, d, i)\r\n deg -= 1\r\n coeff_matrix = np.append(coeff_matrix, x_n)\r\n b = np.append(b, y_n)\r\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\r\n return coeff_matrix, b\r\n\r\n def solve_coeff_matrix(coeff_matrix, b):\r\n A_inverse = np.linalg.inv(coeff_matrix)\r\n coeffs = A_inverse.dot(b)\r\n return coeffs\r\n\r\n def build_function_from_coeffs(coeffs):\r\n f = np.poly1d(coeffs)\r\n return f\r\n\r\n n = 100 # fisrt sample size\r\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\r\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\r\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\r\n break\r\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\r\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\r\n break\r\n result = build_function_from_coeffs(coeffs)\r\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\r\n break\r\n n += 200 # increasing sample size\r\n\r\n return result","def decimatef(f,m):\r\n \r\n n=len(f)\r\n nout=np.ceil(n/m)\r\n nfilt=8\r\n rip=.05\r\n \r\n #make a cheybeshev1 zero-phase filter with cuttoff frequency of .8/m\r\n b,a=sps.iirfilter(nfilt,.8/m,rp=rip,btype='low',ftype='cheby1',output='ba')\r\n ffilt=sps.filtfilt(b,a,f)\r\n nbeg=n-m*nout\r\n fdec=np.array([ffilt[ii] for ii in np.arange(start=nbeg,stop=int(n),step=m)])\r\n \r\n return fdec","def bezier_curve_range(n, points):\n for i in xrange(n):\n t = i / float(n - 1)\n yield bezier(t, points)","def recf_chebyshev_poly(basetensor, ind, x):\n\n return 2. * x[:, ind.current_dim] * basetensor[ind.all+ind.getPreceding(1)] \\\n - basetensor[ind.all+ind.getPreceding(2)]","def fourier_series(x, f, n=0):\n # Make the parameter objects for all the terms\n a0, *cos_a = parameters(','.join(['a{}'.format(i) for i in range(0, n + 1)]))\n sin_b = parameters(','.join(['b{}'.format(i) for i in range(1, n + 1)]))\n\n # Construct the series\n series = a0 + sum(ai * cos(i * f * x) + bi * sin(i * f * x)\n for i, (ai, bi) in enumerate(zip(cos_a, sin_b), start=1))\n return series","def generate_basis(n, dim):\n planes = [np.random.randn(dim) for i in range(n)]\n return [p / np.linalg.norm(p) for p in planes]","def _f(X, g, n):\n if n == 3:\n n = 3.001 # for numerical stability\n hyp2f1_term = hyp2f1((n-1)/2, g/2, n/2, 1/(1+X**2))\n beta_term = beta((n-1)/2, 0.5)\n return 0.5 * beta_term * hyp2f1_term * (1+X**2) ** ((1-n)/2)","def evaluate_polynomial(f,x):\n degree = len(f)-1\n ans = 0\n for i in f:\n ans += i*x**degree\n degree -= 1\n return(ans)","def eval_chebyt(n,\n x,\n low = -1.,\n high = 1.,\n normalization = \"classical\"):\n if not isinstance(n, int):\n raise NotImplementedError(\n \"This function is currently implemented only for \" +\n \"integer values of n\")\n # TODO(pedregosa): what happens if n is negative?\n coefs = recurrence_chebyt(low, high, normalization)\n return utils.eval_three_term(n, coefs, x)","def cheby16(f,a,b,n):\n if n == 1:\n ts = np.array([a])\n h = (b-a)\n else:\n ts, h = np.linspace(a,b,num=n, endpoint=False, retstep=True)\n\n xs = (c16+1)*h/2\n xs = xs.reshape((1,-1))\n ts = ts.reshape((-1,1))\n all_ts = ts + xs\n all_fts = f(all_ts)\n return np.sum(np.dot(all_fts,w16))*h/2","def generate_random_tropical_poly(max_degree, min_coefficient, max_coefficient):\n coefficients = []\n for d in range(0, random.randint(1, max_degree) + 1):\n coefficients.append(random.randint(min_coefficient, max_coefficient))\n return coefficients","def Coef(expr, n,i):\n return int(expr.coeff_monomial(x**(i+n)*y**n))","def required_nb_data_func(list_nb_coeff):\n return max(list_nb_coeff / (1+np.arange(1, N+1)//2))","def minimize(self, n=1000):\n # TODO: review this whole funciton\n ranges = self.bounds[:, 1] - self.bounds[:, 0]\n ndim = ranges.size\n theta = self.sample(np.random.rand(n, self.ndim))\n opts, sses = [], []\n for p0 in tqdm(theta):\n results = minimize(fun=self.chi, x0=p0, method='L-BFGS-B', jac=self.grad_chi, bounds=self.bounds)\n opts.append(results.x)\n sses.append(self.chi(results.x))\n mask = np.isfinite(sses)\n sses = np.array(sses)[mask]\n opts = np.array(opts)[mask]\n sorted_ids = np.argsort(sses)\n sses = sses[sorted_ids]\n opts = opts[sorted_ids]\n return opts, sses","def H(n,x):\r\n H_values = [] #a list of sequential H values for different n's up to n=n.\r\n H_values.append(1) #appends H_0.\r\n H_values.append(2*x) #appends H_1.\r\n if n>1:\r\n for i in range(1,n):\r\n H_values.append((2*x*H_values[-1])-(2*i*H_values[-2]))\r\n return H_values[-1]\r\n elif n == 0:\r\n return H_values[0]\r\n else:\r\n return H_values[1]","def poly(n, force_zero=None, **kwargs):\n if force_zero is None and len(kwargs) == 0:\n # noinspection PyUnusedLocal\n def pf(x, params, const_list, const_dict):\n return np.polyval(params, x)\n return FitFunction(\n func=pf, num_fit_params=n + 1, force_zero=force_zero,\n name='poly{}'.format(n), code='p{}'.format(n), **kwargs\n )\n else:\n # noinspection PyUnusedLocal\n def pf(x, params, const_list, const_dict):\n return np.polyval(np.concatenate((params, np.zeros(1))), x)\n return FitFunction(\n func=pf, num_fit_params=n, force_zero=force_zero,\n name='poly{}'.format(n), code='p{}'.format(n), **kwargs\n )","def zernike_num_coeff(n):\n \n\tif not (n>=0):\n\t\tprint('Input parameter must be >= 0')\n\t\traise AssertionError() \n \n\treturn sum(xrange(n+1)) + n+1","def Mn_plus_distribution(n, x):\n b_bounds = Mn_plus_bounds(n, x)\n return 1.0 - crossprob.ecdf1_new_b(b_bounds)\n #return 1.0 - crossprob.ecdf2(b_bounds, [1]*len(b_bounds), True)","def cdfFunction(f, x, N):\r\n return ssstats.binom.cdf(x, N, f)","def linear_score_function(n: int) -> ndarray:\n return np.array([(n - p) / (n * (n - 1) / 2) for p in range(1, n + 1)])","def zernike_radial_coeffs(l, m, exact=True):\n l = np.atleast_1d(l).astype(int)\n m = np.atleast_1d(np.abs(m)).astype(int)\n lm = np.vstack([l, m]).T\n # for modest to large arrays, faster to find unique values and\n # only evaluate those\n lms, idx = np.unique(lm, return_inverse=True, axis=0)\n\n npoly = len(lms)\n lmax = np.max(lms[:, 0])\n coeffs = np.zeros((npoly, lmax + 1), dtype=object)\n lm_even = ((lms[:, 0] - lms[:, 1]) % 2 == 0)[:, np.newaxis]\n for ii in range(npoly):\n ll = lms[ii, 0]\n mm = lms[ii, 1]\n for s in range(mm, ll + 1, 2):\n coeffs[ii, s] = (\n (-1) ** ((ll - s) // 2)\n * factorial((ll + s) // 2)\n // (\n factorial((ll - s) // 2)\n * factorial((s + mm) // 2)\n * factorial((s - mm) // 2)\n )\n )\n c = np.fliplr(np.where(lm_even, coeffs, 0))\n if not exact:\n try:\n c = c.astype(int)\n except OverflowError:\n c = c.astype(float)\n c = c[idx]\n return c","def fit_linear(self, h, m):\n susceptibility, coercivity, r, p, se = scipy.stats.linregress(h, m)\n return coercivity/susceptibility, susceptibility","def coefficients(k, xi, x):\n\n import pyweno.cnonuniform\n\n x = np.asarray(x, np.float64)\n xi = np.asarray(xi, np.float64)\n\n nc = len(x) - 1\n n = len(xi)\n c = np.zeros((nc, n, k, k), np.float64)\n beta = np.zeros((nc, k, k, k), np.float64)\n varpi = np.zeros((nc, n, k), np.float64)\n\n pyweno.cnonuniform.nonuniform_coeffs(k, xi, x, c, beta, varpi)\n\n return c, beta, varpi","def coeffs(f):\n return dmp_coeffs(f.rep, f.lev, f.dom)","def zzx_sqr(f):\n df, h = zzx_degree(f), []\n\n for i in xrange(0, 2*df+1):\n coeff = INT_ZERO\n\n jmin = max(0, i-df)\n jmax = min(i, df)\n\n n = jmax - jmin + 1\n\n jmax = jmin + n // 2 - 1\n\n for j in xrange(jmin, jmax+1):\n coeff += f[j]*f[i-j]\n\n coeff += coeff\n\n if n & 1:\n elem = f[jmax+1]\n coeff += elem**2\n\n h.append(coeff)\n\n return h","def c_coefficients(x1,x2,x3,y1,y2,y3,initial_slope,final_slope):\n\tC = c_matrix(x1,x2,x3)\n\ty = y_vector(x1,x2,x3,y1,y2,y3,initial_slope,final_slope)\n\tCCoefficients = np.dot(inv(C),y)\n\treturn(CCoefficients)","def get_polyfit_hess_function(self):\n return lambda x : self.get_polyfit_hess(x)","def zzX_sqr(f):\n if poly_univariate_p(f):\n return zzx_sqr(f)\n\n if zzX_zero_p(f):\n return f\n\n df = zzX_degree(f)\n l = poly_level(f)-1\n\n h = []\n\n for i in xrange(0, 2*df+1):\n coeff = zzX_zero(l)\n\n jmin = max(0, i-df)\n jmax = min(i, df)\n\n n = jmax - jmin + 1\n\n jmax = jmin + n // 2 - 1\n\n for j in xrange(jmin, jmax+1):\n coeff = zzX_add(coeff, zzX_mul(f[j], f[i-j]))\n\n coeff = zzX_mul_const(coeff, 2)\n\n if n & 1:\n elem = zzX_sqr(f[jmax+1])\n coeff = zzX_add(coeff, elem)\n\n h.append(coeff)\n\n return h","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 cubic_spline_interpolation(q_, m = 100):\n n = q_.shape[0]\n dof = q_.shape[1]\n\n q_ = np.transpose(q_)\n\n m = m + (m % (n-1))\n k = int(m / (n-1))\n timesteps = [np.linspace(0, 1, num = k, endpoint = False) for _ in range(n-2)]\n timesteps.append(np.linspace(0, 1, num = k))\n\n # Generate A matrix\n A = np.zeros((dof, n, n))\n # A[:, 0, 0] = 2\n # A[:, 0, 1] = 1\n # A[:, n-1, n-2] = 1\n # A[:, n-1, n-1] = 2\n A[:, 0, 0] = 1\n A[:, n-1, n-1] = 1\n for i in range(1, n-1):\n A[:, i, i - 1] = 1\n A[:, i, i] = 4\n A[:, i, i + 1] = 1\n\n # Generate b matrix\n y = np.zeros((dof, n))\n # y[:, 0] = 3 * (q_[:, 1] - q_[:, 0])\n # y[:, n-1] = 3 * (q_[:, n - 1] - q_[:, n - 2])\n y[:, 0] = 0\n y[:, n-1] = 0\n for i in range(1, n-1):\n y[:, i] = 3 * (q_[:, i + 1] - q_[:, i - 1])\n\n # Solve D\n D = np.linalg.solve(A, y)\n\n # Calculate coefficients\n a = np.copy(q_[:, :n-1])\n b = np.copy(D[:, :n-1])\n c = np.zeros((dof, n-1))\n d = np.zeros((dof, n-1))\n for i in range(0, n-1):\n c[:, i] = 3 * (q_[:, i + 1] - q_[:, i]) - 2 * D[:, i] - D[:, i + 1]\n d[:, i] = 2 * (q_[:, i] - q_[:, i + 1]) + D[:, i] + D[:, i + 1]\n\n \n # Calculate Trajectories\n q = np.zeros((dof, m))\n qd = np.zeros((dof, m))\n qdd = np.zeros((dof, m))\n\n for j in range(n - 1):\n for i in range(len(timesteps[j])):\n t = timesteps[j][i]\n t_2 = t * t\n t_3 = t * t * t\n\n q[:, i + j * k] = a[:, j] + b[:, j] * t + c[:, j] * t_2 + d[:, j] * t_3\n qd[:, i + j * k] = b[:, j] + 2 * c[:, j] * t + 3 * d[:, j] * t_2\n qdd[:, i + j * k] = 2 * c[:, j] + 6 * d[:, j] * t\n\n return q, qd, qdd","def chebyshev_polynomials(adj, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (\n 2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0]))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k + 1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return sparse_to_tensor(t_k)","def generateHashFunctions(n):\n hashFunction = []\n for i in range(n):\n # Chooses random value to use as xor during a single hash function\n random_XORvalue = random.getrandbits(INT_SIZE)\n hashFunction.append((random_XORvalue))\n return hashFunction","def cost_function(x, N, w, dt):\n yh = np.abs(fftkernel(x, w / dt)) # density\n # formula for density\n C = np.sum(yh ** 2) * dt - 2 * np.sum(yh * x) * \\\n dt + 2 / np.sqrt(2 * np.pi) / w / N\n C = C * N * N\n # formula for rate\n # C = dt*sum( yh.^2 - 2*yh.*y_hist + 2/sqrt(2*pi)/w*y_hist )\n return C, yh","def trapezium_rule(f, m, x, a, b, n):\n h = (b-a)/float(n)\n s = 0.5*(f(m, x, a) + f(m, x, b))\n for i in range(n):\n s = s + f(m, x, a + i*h)\n return h*s","def biphasic_fit_function(x, a, b, c, d, e, f):\n term1 = 1 + (a + (1 - a)/(1 + (x * (10 ** b)) ** c))\n term2 = 1 + (d + (1 - d)/(1 + (x * (10 ** e)) ** f))\n\n biphasic_function = 2 ** (0.5 * (np.log2(term1) + np.log2(term2))) - 1\n return biphasic_function","def _energy_test_statistic_coefficient(\n n: int,\n m: int,\n) -> float:\n return n * m / (n + m)","def linear_combination(n):\n weighs = (1, 3, 9, 27)\n\n for factors in factors_set():\n sum = 0\n for i in range(len(factors)):\n sum += factors[i] * weighs[i]\n if sum == n:\n return factors","def local_basis_regression(functions, M=10):\r\n assert M>1\r\n N = M-1\r\n L=len(functions)\r\n def aux(X,Y):\r\n (D,S) = X.shape\r\n assert D==1\r\n # at the moment only works with dim 1\r\n order = np.argsort(X).flatten()\r\n X_ = X[...,order]\r\n Y_ = Y[order]\r\n K=S/M\r\n limits = [ X[0,i*K] \r\n for i in range(1,M) ]\r\n local_weights = np.zeros((M,L))\r\n for i in range(0,M):\r\n seg = slice(i*K, (i+1)*K)\r\n local_weights[i] = get_regression_coefficients(functions, X_[...,seg], Y_[seg]) \r\n return local_basis_function(limits, local_weights, functions)\r\n return aux","def compute_coefficients(self, nrange, irange=None, prec=10, ef=True, Qadd=0):\n # we first need an initial set of coefficients\n C = self._coeffs\n P = self._principal_part\n M = self._space\n WR = M.multiplier()\n weight = M.weight()\n if(self.prec >= prec or len(C) > 0):\n # presumable we already have good coefficients\n pass\n else:\n # Need initial set first\n print(\"Computing initial set of coefficients!\")\n self.prec = prec\n [Y, M0] = self._space.get_Y_and_M(P, weight, prec)\n Q = M0 + 10\n W = vv_harmonic_wmwf_setupV(WR, P, Y, M0, Q, weight, self._space._sym_type, verbose=self._space._verbose)\n if (0, 0) in P:\n N = self._space.set_norm()\n # N=set_norm_vv_harmonic_weak_maass_forms(WR,cusp_form=True,holomorphic=self._holomorphic)\n else:\n N = self._space.set_norm()\n # N=set_norm_vv_harmonic_weak_maass_forms(WR,cusp_form=False,holomorphic=self._holomorphic)\n C = solve_system_for_vv_harmonic_weak_Maass_waveforms(W, N, verbose=self._verbose)\n\n # endif\n # check if we have all coefficients we wanted\n maxc = max(C[list(C.keys())[0]].keys())\n if maxc >= max(nrange):\n print(\"Have all we need!\")\n pass\n else:\n # we do not have all coefficients we need\n print(\"Need to compute more!!\")\n Ns = nrange # [maxc,max(nrange)]\n if irange is not None:\n Is = irange\n else:\n Is = [min(M.D()), max(M.D())]\n\n # Try to find good Y\n # Recall that the error in the negative part is usually smaller than in the positive part\n M_minus = abs(min(self._coeffs[list(self._coeffs.keys())[0]]))\n M_plus = abs(max(self._coeffs[list(self._coeffs.keys())[0]]))\n # Assume we computed these coefficients at (almost) the highest horocycle\n Y0 = mpmath.sqrt(3) / mpmath.mpf(2) * mpmath.mpf(0.995)\n [err_minus, err_plus] = self.get_error_estimates(Y0, M_minus, M_plus)\n kint = mpmath.mp.mpf(1 - self._space.weight())\n print(\"original:\")\n print(\"err-={0}\".format(err_minus))\n print(\"err+={0}\".format(err_plus))\n Y0 = mpmath.mpf(0.5)\n Yin = Y0\n for j in range(5000):\n Y = Y0 * mpmath.power(mpmath.mpf(0.99), j)\n t = mpmath.pi() * 2 * Y * abs(Ns[0])\n tmp1 = mpmath.exp(t)\n err1 = err_plus * tmp1\n # print \"err+=\",err1\n tmp2 = mpmath.gammainc(kint, 2 * t)\n err2 = err_plus * mpmath.exp(-t) / tmp2\n # print \"err-=\",err2\n if(max(err1, err2) < mpmath.power(10, -prec)):\n Yin = Y\n break\n # t=max(1.0,abs(mpmath.log10(prec)-mpmath.log10(self.prec)))\n # Yin=t/mpmath.mpf(Ns[0]+Ns[1])*mpmath.mpf(2.0) ## This should be good on average\n # Yin=Yin*mpmath.mpf(0.2)\n print(\"err={0}\".format(max(err1, err2)))\n print(\"Yin={0}\".format(Yin))\n sys.stdout.flush()\n # Qadd=40\n try:\n if(ef):\n CC = vv_harmonic_wmwf_phase2_2_ef(self, Ns, Is, prec, Yin, Qadd_in=Qadd)\n else:\n CC = vv_harmonic_wmwf_phase2_2(M, P, C, Ns, Is, prec, Yin)\n for x in CC.keys():\n C[x] = CC[x]\n except KeyboardInterrupt:\n print(\"Manually stopping...\")","def hessian(f, x, s=_DEFAULT_STEP):\n x = np.asarray(x)\n n = len(x)\n e = s * np.eye(n)\n\n forw1 = np.zeros(n)\n forw2 = np.zeros((n, n))\n for i in range(n):\n forw1[i] = f(x + e[i])\n for j in range(i, n):\n forw2[i, j] = forw2[j, i] = f(x + e[i] + e[j])\n\n H = (forw2 - _colvec(forw1) - _rowvec(forw1) + f(x)) / s**2\n return H","def generate_polynomial():\n degree = numpy.random.choice(range(3, 7))\n x = numpy.linspace(-10, 10, 1000)\n coefficients = numpy.random.chisquare(3, size=degree) + 1\n coefficients *= numpy.random.choice([-1, 1], size=coefficients.shape)\n coefficients *= 0.5\n y = numpy.polyval(coefficients, x)\n add_noise(y, 0.1)\n return x, y","def perform_fit(xdata,ydata,initial,n):\n try:\n p, pcov = curve_fit(f,xdata,ydata,p0=initial)\n delta = p[2]-p[1]\n error = sum([ abs(ydata[i] - f(xdata[i],p[0],p[1],p[2])) for i in range(len(xdata)) ])\n except:\n print \"ERROR: RuntimeError: Optimal parameters not found: Number of calls to function has reached maxfev\"\n return 0, 0, [0,0,0,0], [0]\n return abs(delta), error, p, pcov","def monte_carlo_sample(f, bounds, n_samples):\r\n samples = []\r\n pmax = f(bounds[0])\r\n tries_per_run = int(n_samples*1/pmax)\r\n while len(samples) < n_samples:\r\n x = np.random.rand(tries_per_run)*(bounds[1]-bounds[0])+bounds[0]\r\n y = np.random.rand(tries_per_run)*pmax\r\n good = x[y <= f(x)]\r\n samples = samples + [i for i in x[y <= f(x)]]\r\n return np.array(np.array(samples))[:n_samples]","def _getZc(n):\n # An extra trial is required for low counts, due to the fact\n # that there is higher variance in the calculated deviation.\n extra = 1\n\n vFree = n - 1\n zc = 1.96\n if vFree > 15:\n # Normal distribution, and enough that we do not need to\n # have an extra trial.\n extra = 0\n elif vFree >= 10:\n # Here and below is a t-distribution; note that this comes\n # from the 97.5% column in Table 3 of Driels et al., since\n # those coefficients don't include the tail\n zc = 2.23\n elif vFree >= 5:\n zc = 2.57\n elif vFree >= 4:\n zc = 2.78\n elif vFree >= 3:\n zc = 3.18\n elif vFree >= 2:\n zc = 4.30\n elif vFree >= 1:\n zc = 12.71\n return zc, extra","def fourier_coefficient(t, freq, n=1, axis=-1):\n t, freq, n = map(np.asanyarray, (t, freq, n))\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)","def coefficients(self) :\n raise NotImplementedError","def test_quadratic_features_max_n_features():\n transformer = QuadraticFeatures(max_n_features=5)\n transformer.fit(X_small)\n assert len(transformer.combinations_) == 5 - X_small_n_cols","def _get_legcoef(self, n0):\n n = sp.Symbol(\"n\")\n return self.legcoefs.xreplace({n: int(n0)}).evalf()","def prob3(N):\n x, y, n = sy.symbols('x, y, n')\n expr = sy.summation(x**n/sy.factorial(n), (n, 0, N))\n f = sy.lambdify(y, expr.subs(x, -y**2), \"numpy\")\n domain = np.linspace(-2, 2, 100)\n plt.ion()\n plt.plot(domain, np.exp(-1*domain**2), label=\"original function\")\n plt.plot(domain, f(domain), label=\"Maclaurin series\")\n plt.legend()\n plt.show()","def prob6(n):\n data = np.load('airdata.npy')\n fx = lambda a, b, n: .5*(a+b + (b-a) * np.cos(np.arange(n+1) * np.pi/n))\n a, b = 0, 366 - 1/24\n domain = np.linspace(0, b, 8784)\n pts = fx(a, b, n)\n temp = np.abs(pts - domain.reshape(8784, 1))\n temp2 = np.argmin(temp, axis=0)\n poly = Barycentric(domain[temp2], data[temp2])\n\n plt.ion()\n plt.subplot(121)\n plt.plot(domain, data)\n plt.title(\"Data\")\n plt.subplot(122)\n plt.plot(domain, poly(domain))\n plt.title(\"Interpolation\")\n plt.show()","def fit_poly(x, y, n=5, log=False):\n \n x_g = x\n x = np.ma.array(x, mask=y.mask).compressed()\n y = y.compressed()\n if log:\n yl = np.log10(y)\n else:\n yl = y\n fit = np.polyfit(x, yl, n)\n p = np.poly1d(fit)\n \n if log:\n return 10**(p(x_g))\n else:\n return p(x_g)","def EllipticCurve_from_Weierstrass_polynomial(f):\n return EllipticCurve(coefficients_from_Weierstrass_polynomial(f))","def _poly_func(x, a, b, c, d, e):\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2","def _f_lcs(llcs, m, n):\n r_lcs = llcs / m\n p_lcs = llcs / n\n beta = p_lcs / (r_lcs + 1e-12)\n num = (1 + (beta ** 2)) * r_lcs * p_lcs\n denom = r_lcs + ((beta ** 2) * p_lcs)\n f_lcs = num / (denom + 1e-12)\n return f_lcs","def zzX_eval(f, x):\n if hasattr(x, '__iter__'):\n return zzX_eval_list(f, x)\n\n if poly_univariate_p(f):\n return zzx_eval(f, x)\n\n if not x:\n return poly_TC(f)\n\n result = poly_LC(f)\n\n for coeff in f[1:]:\n result = zzX_mul_const(result, x)\n result = zzX_add(result, coeff)\n\n return result","def sample(self,f,N,p=100):\n return [f(x) for x in np.linspace(0,N,p)]","def coarse_fc(n):\n input_shape = (n,)\n input_vec = Input(shape=input_shape,name = \"Input1\", dtype = 'float32')\n dense = Dense(3,name = \"fc1\",trainable=True)(input_vec)\n res = Activation('softmax',name = 'coarse')(dense)\n model_c = Model(inputs=input_vec,outputs=[res,dense])\n return(model_c)","def coeffients(x, y):\n\n # ensure floating point datatypes\n x.astype(float)\n y.astype(float)\n\n # degree of interpolating polynomial\n n = len(x)\n\n # intitilize list of coeffients for interpolating polynomial to y values\n c = y.tolist()\n\n # compute coeffients\n for j in range(1, n):\n for i in range(n-1, j-1, -1):\n c[i] = float(c[i]-c[i-1])/float(x[i]-x[i-j])\n\n # return an array of polynomial coefficient, note: reverse order for np.polyval function\n return np.array(c[::-1])","def zzx_pow(f, n):\n if not n:\n return [INT_ONE]\n if n == 1 or f == [] or f == [1]:\n return f\n\n g = [INT_ONE]\n\n while True:\n n, m = n//2, n\n\n if m & 1:\n g = zzx_mul(g, f)\n\n if n == 0:\n break\n\n f = zzx_sqr(f)\n\n return g","def chebyshev_polynomials(adj, k):\n # print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n adj_normalized = normalize_adj(adj)\n laplacian = sp.eye(adj.shape[0], dtype=adj.dtype) - adj_normalized\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0], dtype=adj.dtype)\n\n t_k = list()\n t_k.append(sp.eye(adj.shape[0], dtype=adj.dtype))\n t_k.append(scaled_laplacian)\n\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\n s_lap = sp.csr_matrix(scaled_lap, copy=True, dtype=adj.dtype)\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\n\n for i in range(2, k+1):\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\n\n return t_k","def binom_coef(n, k):\n n = tf.cast(n, tf.float64)\n k = tf.cast(k, tf.float64)\n num = factorial(n)\n denom = tf.multiply(factorial(k), factorial(n-k))\n return tf.divide(num, denom)","def hn(x, n):\n\n data = x\n for _ in xrange(n):\n data = h(data)\n return data","def fg_day_compare_features_n(cls, n):\n\n def func(df):\n val = cls.day_compare_features(df)\n return [np_shift(item, n, 0) for item in val]\n\n return func","def gen_fhe_instance(n, q, alpha=None, h=None, m=None, seed=None):\n if seed is not None:\n set_random_seed(seed)\n\n q = next_prime(ceil(q)-1, proof=False)\n if alpha is None:\n alpha = ZZ(8)/q\n\n n, alpha, q = preprocess_params(n, alpha, q)\n\n stddev = stddevf(alpha*q)\n\n if m is None:\n m = n\n K = GF(q, proof=False)\n A = random_matrix(K, m, n)\n\n if h is None:\n s = random_vector(ZZ, n, x=-1, y=1)\n else:\n S = [-1, 1]\n s = [S[randint(0, 1)] for i in range(h)]\n s += [0 for _ in range(n-h)]\n shuffle(s)\n s = vector(ZZ, s)\n c = A*s\n\n D = DiscreteGaussian(stddev)\n\n for i in range(m):\n c[i] += D()\n\n return A, c","def upper_bound_of_coefficient(f):\n weight = 0\n for c in f.itercoefficients():\n weight += abs(c)**2\n weight = arith1.floorsqrt(weight) + 1\n degree = f.degree()\n lc = f[degree]\n m = (degree >> 1) + 1\n bound = 1\n for i in range(1, m):\n b = combinatorial.binomial(m - 1, i) * weight + \\\n combinatorial.binomial(m - 1, i - 1) * lc\n if bound < b:\n bound = b\n return bound","def zzX_diff(f, m=1):\n if poly_univariate_p(f):\n return zzx_diff(f, m)\n\n n = zzX_degree(f)\n\n if n < m:\n return zzX_zero_of(f)\n\n deriv, c = [], INT_ONE\n\n for i in xrange(0, m):\n c, n = c*n, n-1\n\n for coeff in f[:-m]:\n h = zzX_mul_const(coeff, c)\n c, n = n*(c//(n+m)), n-1\n deriv.append(h)\n\n return deriv","def bernstein_poly(i, n, t):\n\n return comb(n, i) * ( t**(n-i) ) * (1 - t)**i","def bernstein_poly(i, n, t):\n\n return comb(n, i) * ( t**(n-i) ) * (1 - t)**i","def sexp(p,n,res_field=RR):\n assert n>=2, \"Carleman matrix must at least be of size 2 to retrieve the coefficients. But given was \" + repr(n)\n CM = p.carleman_matrix(n)\n ev = [ r[0] for r in CM.charpoly().roots(QQbar) ]\n assert len(ev) == n, \"Carleman matrix must have exactly \" + repr(n) + \"eigenvalues, but has \" + repr(len(ev))\n\n #We want to compute:\n #sum over k: evk^t*(CM-ev1*I)*(CM-ev2*I)*. omit k * (CM-evn*I)/(evk-ev1)*.. omit k *(evk-evn)\n Char = [0]*n\n for k in range(n):\n #here is possibility for improvement of precision\n #to separate the fractional from the root parts\n #expanding the product\n Char[k] = CM - ev[k]*identity_matrix(n)\n\n #we want to have the first row of the product of the matrices\n #thatswhy we mulitply in front with:\n prod = vector(QQbar,[0,1]+[0]*(n-2))\n prodwo = [0]*n\n for k in range(n):\n prodwo[k]=prod #these are the first terms until k-1\n\n #no need to continue\n if k == n-1:\n break\n\n #and we add the terms starting with k+1\n for i in range(k+1,n):\n prodwo[k] = prodwo[k] * Char[i]\n\n prod = prod * Char[k]\n\n sprodwo = [0]*n\n for k in range(n):\n if k==0:\n sprodwo[k] = ev[k] - ev[1]\n start = 2\n else:\n sprodwo[k] = ev[k] - ev[0]\n start = 1\n\n for i in range(start,n):\n if i != k:\n sprodwo[k] = sprodwo[k] * (ev[k] - ev[i])\n\n for k in range(n):\n print ev[k]\n print prodwo[k][0]/sprodwo[k]\n print res_field\n #return lambda t: sum(res_field(ev[k])**t*res_field(prodwo[k][0]/sprodwo[k]) for k in range(n))\n return [ev,[prodwo[k][0]/sprodwo[k] for k in range(n)]]","def PBpoly(n, x):\n n = int(n)\n return Bpoly(n, x-math.floor(x))","def schaffern3fcn(x: np.ndarray) -> np.ndarray:\n n = x.shape[1]\n assert n == 2, \"Schaffer function N. 3 is only defined on a 2D space.\"\n\n X = x[:, 0]\n Y = x[:, 1]\n\n numeratorcomp = (np.sin(np.cos(np.abs(X**2 - Y**2))) ** 2) - 0.5\n denominatorcomp = (1 + 0.001 * (X**2 + Y**2)) ** 2\n scores = 0.5 + numeratorcomp / denominatorcomp\n\n return scores"],"string":"[\n \"def chebyshev_coeffs(f, n):\\n extrema = np.cos((np.pi * np.arange(2*n))/n)\\n samples = f(extrema)\\n coeffs = np.real(np.fft.fft(samples))[:n+1]\\n coeffs /= n \\n coeffs[0] /= 2\\n coeffs[n] /= 2\\n\\n return coeffs\",\n \"def random_coefficients(self, n=3, max_range = 10):\\n return np.random.uniform(-1*max_range, max_range, n)\",\n \"def cheb_poly(x, n):\\n if n == 0:\\n return anp.array([1 for i in x])\\n elif n == 1:\\n return x\\n else:\\n return 2*x*cheb_poly(x, n-1)-cheb_poly(x, n-2)\\n\\n raise NotImplementedError(\\\"Problem 6 Incomplete\\\")\",\n \"def coefficients_from_Weierstrass_polynomial(f):\\n R = f.parent()\\n cubic_variables = [x for x in R.gens() if f.degree(x) == 3]\\n quadratic_variables = [y for y in R.gens() if f.degree(y) == 2]\\n try:\\n x = cubic_variables[0]\\n y = quadratic_variables[0]\\n except IndexError:\\n raise ValueError('polynomial is not in long Weierstrass form')\\n\\n a1 = a2 = a3 = a4 = a6 = 0\\n x3 = y2 = None\\n for coeff, mon in f:\\n if mon == x**3:\\n x3 = coeff\\n elif mon == x**2:\\n a2 = coeff\\n elif mon == x:\\n a4 = coeff\\n elif mon == 1:\\n a6 = coeff\\n elif mon == y**2:\\n y2 = -coeff\\n elif mon == x*y:\\n a1 = -coeff\\n elif mon == y:\\n a3 = -coeff\\n else:\\n raise ValueError('polynomial is not in long Weierstrass form')\\n\\n if x3 != y2:\\n raise ValueError('the coefficient of x^3 and -y^2 must be the same')\\n elif x3 != 1:\\n a1, a2, a3, a4, a6 = a1/x3, a2/x3, a3/x3, a4/x3, a6/x3\\n return [a1, a2, a3, a4, a6]\",\n \"def h(n, x, orthonormal=True):\\n h = polynomial.polyval(x, h_coefs[n])\\n return h\",\n \"def polyfit_with_fixed_points(n, x, y, xf, yf):\\n import numpy as np\\n x = np.asarray(x)\\n y = np.asarray(y)\\n xf = np.asarray(xf,dtype=float)\\n yf = np.asarray(yf,dtype=float)\\n mat = np.empty((n + 1 + len(xf),) * 2)\\n vec = np.empty((n + 1 + len(xf),))\\n x_n = x**np.arange(2 * n + 1)[:, None]\\n yx_n = np.sum(x_n[:n + 1] * y, axis=1)\\n x_n = np.sum(x_n, axis=1)\\n idx = np.arange(n + 1) + np.arange(n + 1)[:, None]\\n mat[:n + 1, :n + 1] = np.take(x_n, idx)\\n xf_n = xf**np.arange(n + 1)[:, None]\\n mat[:n + 1, n + 1:] = old_div(xf_n, 2)\\n mat[n + 1:, :n + 1] = xf_n.T\\n mat[n + 1:, n + 1:] = 0\\n vec[:n + 1] = yx_n\\n vec[n + 1:] = yf\\n params = np.linalg.solve(mat, vec)\\n return params[:n + 1]\",\n \"def chebyshev_polynomial(X, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n T_k = list()\\n T_k.append(sp.eye(X.shape[0]).tocsr())\\n T_k.append(X)\\n\\n def chebyshev_recurrence(T_k_minus_one, T_k_minus_two, X):\\n X_ = sp.csr_matrix(X, copy=True)\\n return 2 * X_.dot(T_k_minus_one) - T_k_minus_two\\n\\n for i in range(2, k+1):\\n T_k.append(chebyshev_recurrence(T_k[-1], T_k[-2], X))\\n\\n return T_k\",\n \"def modified_chebyshev(nterms, moments, input_coefs=None):\\n moments = np.asarray(moments)\\n assert moments.ndim == 1\\n nmoments = moments.shape[0]\\n if nterms > nmoments/2:\\n msg = 'nterms and nmoments are inconsistent. '\\n msg += 'Not enough moments specified'\\n raise Exception(msg)\\n\\n if input_coefs is None:\\n # the unmodified polynomials are monomials\\n input_coefs = np.zeros((nmoments, 2))\\n\\n assert nmoments == input_coefs.shape[0]\\n\\n ab = np.zeros((nterms, 2))\\n ab[0, 0] = input_coefs[0, 0]+moments[1]/moments[0]\\n ab[0, 1] = moments[0]\\n\\n sigma = np.zeros(2*nterms)\\n sigma_m2 = np.zeros_like(sigma)\\n sigma_m1 = moments[0:2*nterms].copy()\\n for kk in range(1, nterms):\\n sigma[:] = 0\\n idx = 2*nterms-kk\\n for ll in range(kk, 2*nterms-kk):\\n sigma[kk:idx] = sigma_m1[kk+1:idx+1] -\\\\\\n (ab[kk-1, 0]-input_coefs[kk:idx, 0])*sigma_m1[kk:idx] -\\\\\\n ab[kk-1, 1]*sigma_m2[kk:idx]+input_coefs[kk:idx, 1] *\\\\\\n sigma_m1[kk-1:idx-1]\\n # sigma[ll]=sigma_m1[ll+1]-\\\\\\n # (ab[kk-1,0]-input_coefs[ll,0])*sigma_m1[ll] - \\\\\\n # ab[kk-1,1]*sigma_m2[ll]+input_coefs[ll,1]*sigma_m1[ll-1]\\n ab[kk, 0] = input_coefs[kk, 0]+sigma[kk+1]/sigma[kk] -\\\\\\n sigma_m1[kk]/sigma_m1[kk-1]\\n ab[kk, 1] = sigma[kk]/sigma_m1[kk-1]\\n sigma_m2 = sigma_m1.copy()\\n sigma_m1 = sigma.copy()\\n\\n return ab\",\n \"def cheby_coeff(g, m, N=None, arange=(-1,1)):\\r\\n if N is None:\\r\\n N = m+1\\r\\n\\r\\n a1 = (arange[1] - arange[0]) / 2.0\\r\\n a2 = (arange[1] + arange[0]) / 2.0\\r\\n n = np.pi * (np.r_[1:N+1] - 0.5) / N\\r\\n s = g(a1 * np.cos(n) + a2)\\r\\n c = np.zeros(m+1)\\r\\n for j in range(m+1):\\r\\n c[j] = np.sum(s * np.cos(j * n)) * 2 / N\\r\\n\\r\\n return c\",\n \"def hyperbolic_decay(mul, pow, n, min=0.1):\\n return np.vstack([mul * np.power(1 / np.arange(1, n + 1), pow), [min] * n]).max(0).tolist()\",\n \"def basis_fns(n=0):\\n return lambda x: np.sum(x ** (n+1), axis=1)\",\n \"def cheby_coeff2(m,s):\\r\\n c = np.zeros(m+1)\\r\\n for j in range(m+1):\\r\\n c[j] = 2*np.exp(-s)*j1(-s)\\r\\n \\r\\n return c\",\n \"def conway_polynomial(n=100):\\n \\n xs = []\\n ys = []\\n for i in range(n):\\n x = (i - n/2) / 50\\n xs.append(x)\\n\\n y = x**71 - x**69 - 2*x**68 - x**67 + 2*x**66 + 2*x**65 + x**64 - x**63 - x**62 - x**61 - x**60 - x**59 + 2*x**58 + 5*x**57 + 3*x**56 +\\\\\\n - 2*x**55 - 10*x**54 - 3*x**53 - 2*x**52 + 6*x**51 + 6*x**50 + x**49 + 9*x**48 - 3*x**47 - 7*x**46 - 8*x**45 - 8*x**44 + 10*x**43 +\\\\\\n + 6*x**42 + 8*x**41 - 5*x**40 - 12*x**39 + 7*x**38 - 7*x**37 + 7*x**36 + x**35 - 3*x**34 + 10*x**33 + x**32 - 6*x**31 - 2*x**30 +\\\\\\n - 10*x**29 - 3*x**28 + 2*x**27 + 9*x**26 - 3*x**25 + 14*x**24 - 8*x**23 - 7*x**21 + 9*x**20 + 3*x**19 - 4*x**18 - 10*x**17 - 7*x**16 +\\\\\\n + 12*x**15 + 7*x**14 + 2*x**13 - 12*x**12 - 4*x**11 - 2*x**10 + 5*x**9 + x**7 - 7*x**6 + 7*x**5 - 4*x**4 + 12*x**3 - 6*x**2 + 3*x - 6\\n\\n ys.append(y)\\n\\n return xs, ys\",\n \"def bspline_basis(c, n, degree):\\n # Create knot vector and a range of samples on the curve\\n kv = np.array([0] * degree + [i for i in range(c - degree + 1)] +\\n [c - degree] * degree, dtype='int') # knot vector\\n u = np.linspace(0, c - degree, n) # samples range\\n\\n # Cox - DeBoor recursive function to calculate basis\\n @memo\\n def coxDeBoor(k, d):\\n # Test for end conditions\\n if (d == 0):\\n return ((u - kv[k] >= 0) & (u - kv[k + 1] < 0)).astype(int)\\n\\n denom1 = kv[k + d] - kv[k]\\n term1 = 0\\n if denom1 > 0:\\n term1 = ((u - kv[k]) / denom1) * coxDeBoor(k, d - 1)\\n\\n denom2 = kv[k + d + 1] - kv[k + 1]\\n term2 = 0\\n if denom2 > 0:\\n term2 = ((-(u - kv[k + d + 1]) / denom2) * coxDeBoor(k + 1, d - 1))\\n\\n return term1 + term2\\n\\n # Compute basis for each point\\n b = np.column_stack([coxDeBoor(k, degree) for k in range(c)])\\n b[n - 1][-1] = 1\\n\\n return b\",\n \"def poly(df, n):\\n poly = pd.Series(df.x**n, name=\\\"poly_\\\" + str(n))\\n df = df.join(poly)\\n return df\",\n \"def get_polyfit_function(self):\\n N = len(self.coefficients)\\n return lambda x: np.dot( self.get_poly(x).T , self.coefficients.reshape(N, 1) )\",\n \"def Bpoly(n, x):\\n n = int(n)\\n out = 0\\n for k in xrange(0, n+1):\\n out += comb(n,k)*Bnum(n-k)*x**float(k)\\n return out\",\n \"def formHn(n,min,max,N):\\n pas = abs((max-min)/N)\\n x = min\\n result = np.array([])\\n \\n for i in range(0,N):\\n result = np.append(result,H(n,x))\\n x += pas \\n return result\",\n \"def poly_nth(f, n):\\n if n < 0 or n > len(f)-1:\\n raise IndexError\\n else:\\n return f[zzx_degree(f)-n]\",\n \"def get_poly(self, n, xf = 14, y0=[1, 0], first_step = 1e-10, max_step = .1):\\n self.n = n\\n y0s = [1- first_step**2/2, - first_step]\\n sol = integ.solve_ivp(lambda t, y: self.f(t, y, n), (first_step, xf), y0s, max_step=max_step, \\\\\\n vectorized=True, events=self.find_zero)\\n data_sol = np.array([sol.t, sol.y[0], sol.y[1]])\\n data_sol[1, -1] = 1e-18\\n data0 = np.array([0, y0[0], y0[1]]).reshape(3, 1)\\n self.poly = np.concatenate((data0, data_sol), axis=1)\",\n \"def zzX_pow(f, n):\\n if poly_univariate_p(f):\\n return zzx_pow(f, n)\\n if not n:\\n return zzX_const_of(f, 1)\\n if n == 1 or zzX_zero_p(f) or zzX_one_p(f):\\n return f\\n\\n g = zzX_const_of(f, 1)\\n\\n while True:\\n n, m = n//2, n\\n\\n if m & 1:\\n g = zzX_mul(g, f)\\n\\n if n == 0:\\n break\\n\\n f = zzX_sqr(f)\\n\\n return g\",\n \"def get_cheb_extrema(a, b, n):\\n\\n # nodes (Chebyshev extrema)\\n x = np.array(list(reversed(np.cos((np.pi * np.arange(n)) / n))))\\n # scale to (a, b)\\n return (x * (b - a) + b + a) / 2\",\n \"def get_params(H, n_qubits, p):\\n# function to optimimize\\n def fun(x):\\n# we minimize f to find max for F \\n return cost_function(H, n_qubits, p, params=x)[0]\\n# starting point\\n params_0=[0.25*np.pi for i in range(2*p)]\\n params_min=[0 for i in range(2*p)]\\n params_max=[2*np.pi if i%2==0 else np.pi for i in range(2*p)]\\n # the bounds required by L-BFGS-B\\n bounds = [(low, high) for low, high in zip(params_min, params_max)]\\n# use method L-BFGS-B because the problem is smooth and bounded\\n result = scipy.optimize.minimize(fun, params_0, method=\\\"TNC\\\",bounds=bounds)\\n return [result.x[i] for i in range(2*p)]\",\n \"def LinkwitzRileyCrossOver(f_c_m, fs, f):\\n # transform the frequency bins into normalized radian frequency\\n # Lowpass\\n # lowpass coefficients\\n b_xo_low, a_xo_low = sig.butter(2, f_c_m/(fs/2), btype='lowpass')\\n # Complex frequency response of the second order Butterworth filter\\n f_xo_low, D_xo_low = sig.freqz(b_xo_low, a_xo_low, worN=f, fs=fs)\\n D_xo_low = D_xo_low * D_xo_low\\n \\n # Highpass\\n # highpass coefficients\\n b_xo_high, a_xo_high = sig.butter(2, f_c_m/(fs/2), btype='highpass')\\n # Complex frequency response of the second order Butterworth filter\\n f_xo_low, D_xo_high = sig.freqz(b_xo_high, a_xo_high, worN=f, fs=fs)\\n D_xo_high = D_xo_high * D_xo_high\\n \\n return D_xo_low, D_xo_high\",\n \"def prob6(n = 5):\\n domain = np.linspace(-1,1, 100)\\n X = anp.array(list(domain), dtype = anp.float)\\n dTn = auto.elementwise_grad(cheb_poly)\\n primes = []\\n \\n for i in range(0, n):\\n primes.append(dTn(X, i))\\n \\n #Plot graphs\\n fig, graph = plt.subplots(3, 2)\\n \\n graph[0, 0].plot(X, primes[0], label = \\\"T0\\\")\\n graph[0, 0].set_title(\\\"Chebyshev - T0\\\")\\n \\n graph[0, 1].plot(X, primes[1], label = \\\"T1\\\")\\n graph[0, 1].set_title(\\\"Chebyshev - T1\\\")\\n \\n graph[1, 0].plot(X, primes[2], label = \\\"T2\\\")\\n graph[1, 0].set_title(\\\"Chebyshev - T2\\\")\\n \\n graph[1, 1].plot(X, primes[3], label = \\\"T3\\\")\\n graph[1, 1].set_title(\\\"Chebyshev - T3\\\")\\n \\n graph[2, 0].plot(X, primes[4], label = \\\"T4\\\")\\n graph[2, 0].set_title(\\\"Chebyshev - T4\\\")\\n \\n plt.tight_layout()\\n \\n return\",\n \"def fht(x, N):\\n if N == 2:\\n return np.array([x[0] + x[1], x[0] - x[1]])\\n else:\\n m = int(N/2)\\n y_t = fht(x[0:N:2],m) \\n y_b = fht(x[1:N:2],m)\\n H_N_C = np.cos((2*PI*np.arange(m))/N)\\n H_N_S = np.sin((2*PI*np.arange((m)))/N)\\n idx_map = np.concatenate(([0], np.arange(m - 1, 0, -1)))\\n y_1 = y_t + np.multiply(H_N_C,y_b) + np.multiply(H_N_S, y_b[idx_map])\\n idx_map = np.concatenate(([0], np.arange(m - 1, 0, -1)))#Modulo N/2\\n y_2 = y_t - np.multiply(H_N_C,y_b) - np.multiply(H_N_S, y_b[idx_map])\\n y = np.concatenate((y_1, y_2))\\n return y\",\n \"def get_poly_cc(n, k, t):\\n assert (n > 0 and k >= 0), \\\"order and derivative must be positive.\\\"\\n\\n cc = np.ones(n)\\n D = np.linspace(0, n-1, n)\\n\\n for i in range(n):\\n for j in range(k):\\n cc[i] = cc[i] * D[i]\\n D[i] = D[i] - 1\\n if D[i] == -1:\\n D[i] = 0\\n\\n for i, c in enumerate(cc):\\n cc[i] = c * np.power(t, D[i])\\n\\n return cc\",\n \"def Generate_Custom(f, n, m):\\n return np.fromfunction(np.vectorize(f, otypes=[float]), (n,m))\",\n \"def getEG(n,int_method,func) :\\n m = np.asarray([0.5,0.6,0.7,0.8,0.9,1,1.1,1.2,1.3,1.4,1.5,2,2.5,3,3.5,4,\\n 4.5,5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10])\\n bes = np.asarray([0.5,0.47768,0.44879,0.39831,0.25858,0,0.15502,0.25699,\\n 0.30896,0.35245,0.39119,0.51822,0.53678,0.54984,0.55847,\\n 0.56395,0.57054,0.57950,0.58402,0.58765,0.59512,0.60214,\\n 0.60469,0.61143,0.61789,0.62443,0.63097,0.63694])\\n p = np.asarray([1,0.85417,0.94685,1.04467,2.55052,0,1.59086,\\n 1.00670,0.88866,0.83763,0.81030,0.76108,0.83093,0.86863,\\n 0.89233,0.90909,0.92097,0.93007,0.93735,0.94332,0.94813,\\n 0.95193,0.95557,0.95864,0.96107,0.96360,0.96570,\\n 0.96788])\\n h0 = np.asarray([0,-0.03567,-0.04808,-0.04315,-0.01879,0,0.00041,0.00069,\\n 0.00639,0.01405,0.02294,0.07814,0.13994,0.19278,0.23793,\\n 0.27678,0.31039,0.33974,0.36585,0.38917,0.41003,0.42891,\\n 0.44621,0.46195,0.47644,0.48982,0.50223,0.51379])\\n h1 = np.asarray([0,0.26899, 0.10571,0.01763,-0.39382,0,0.15211,0.05665,\\n 0.00933,-0.02791,-0.05876,-0.16720,-0.13033,-0.10455 ,\\n -0.08618,-0.07208,-0.06179,-0.05369,-0.04715,-0.04176,\\n -0.03742,-0.03408,-0.03081,-0.02808,-0.02599,-0.02375,\\n -0.02194,-0.02004])\\n h2 = np.asarray([0,-0.09016,-0.06893,-0.04971,-0.08828,0,-0.03341,\\n -0.03964,-0.04456,-0.04775,-0.04984,-0.05381,-0.03570,\\n -0.02476,-0.01789,-0.01333,-0.01028,-0.00812,-0.00653,\\n -0.00534,-0.00444,-0.00376,-0.00319,-0.00274,-0.00238,\\n -0.00207,-0.00182,-0.00160])\\n h3 = np.asarray([0,0.03993,0.03363,0.02216,-0.00797,0,0.00899,0.01172,\\n 0.01150,0.01026,0.00860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\\n 0])\\n \\n if (func == True) :\\n int_bes = splev(n,splrep(m, bes))\\n int_p = splev(n,splrep(m, p))\\n int_h0 = splev(n,splrep(m, h0))\\n int_h1 = splev(n,splrep(m, h1))\\n int_h2 = splev(n,splrep(m, h2))\\n int_h3 = splev(n,splrep(m, h3))\\n else :\\n int_bes = griddata(m, bes, n, method=int_method)\\n int_p = griddata(m, p, n, method=int_method)\\n int_h0 = griddata(m, h0, n, method=int_method)\\n int_h1 = griddata(m, h1, n, method=int_method)\\n int_h2 = griddata(m, h2, n, method=int_method)\\n int_h3 = griddata(m, h3, n, method=int_method)\\n \\n return np.asarray([int_bes,int_p,int_h0,int_h1,int_h2,int_h3])\",\n \"def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\\r\\n\\r\\n # replace these lines with your solution\\r\\n initial_T = time.time()\\r\\n\\r\\n def get_points(f, a, b, n):\\r\\n x = np.linspace(a, b, n)\\r\\n y_lst = f(x)\\r\\n y = np.array(y_lst)\\r\\n\\r\\n return x, y\\r\\n\\r\\n def build_vector(x, y, size, deg):\\r\\n if deg == size:\\r\\n y_n = y.sum()\\r\\n else:\\r\\n y_n = np.dot(y, (x ** (size - deg)))\\r\\n pol1 = np.zeros(size + 1)\\r\\n for i in range(size + 1):\\r\\n pol1[i] = (x ** (2 * size - deg - i)).sum()\\r\\n return pol1, y_n\\r\\n\\r\\n def build_coeff_matrix(f, a, b, n, d):\\r\\n x, y = get_points(f, a, b, n)\\r\\n deg = d\\r\\n b = np.array([])\\r\\n coeff_matrix = np.array([])\\r\\n for i in range(d + 1):\\r\\n x_n, y_n = build_vector(x, y, d, i)\\r\\n deg -= 1\\r\\n coeff_matrix = np.append(coeff_matrix, x_n)\\r\\n b = np.append(b, y_n)\\r\\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\\r\\n return coeff_matrix, b\\r\\n\\r\\n def solve_coeff_matrix(coeff_matrix, b):\\r\\n A_inverse = np.linalg.inv(coeff_matrix)\\r\\n coeffs = A_inverse.dot(b)\\r\\n return coeffs\\r\\n\\r\\n def build_function_from_coeffs(coeffs):\\r\\n f = np.poly1d(coeffs)\\r\\n return f\\r\\n\\r\\n n = 100 # fisrt sample size\\r\\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\\r\\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\\r\\n break\\r\\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\\r\\n break\\r\\n result = build_function_from_coeffs(coeffs)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\\r\\n break\\r\\n n += 200 # increasing sample size\\r\\n\\r\\n return result\",\n \"def decimatef(f,m):\\r\\n \\r\\n n=len(f)\\r\\n nout=np.ceil(n/m)\\r\\n nfilt=8\\r\\n rip=.05\\r\\n \\r\\n #make a cheybeshev1 zero-phase filter with cuttoff frequency of .8/m\\r\\n b,a=sps.iirfilter(nfilt,.8/m,rp=rip,btype='low',ftype='cheby1',output='ba')\\r\\n ffilt=sps.filtfilt(b,a,f)\\r\\n nbeg=n-m*nout\\r\\n fdec=np.array([ffilt[ii] for ii in np.arange(start=nbeg,stop=int(n),step=m)])\\r\\n \\r\\n return fdec\",\n \"def bezier_curve_range(n, points):\\n for i in xrange(n):\\n t = i / float(n - 1)\\n yield bezier(t, points)\",\n \"def recf_chebyshev_poly(basetensor, ind, x):\\n\\n return 2. * x[:, ind.current_dim] * basetensor[ind.all+ind.getPreceding(1)] \\\\\\n - basetensor[ind.all+ind.getPreceding(2)]\",\n \"def fourier_series(x, f, n=0):\\n # Make the parameter objects for all the terms\\n a0, *cos_a = parameters(','.join(['a{}'.format(i) for i in range(0, n + 1)]))\\n sin_b = parameters(','.join(['b{}'.format(i) for i in range(1, n + 1)]))\\n\\n # Construct the series\\n series = a0 + sum(ai * cos(i * f * x) + bi * sin(i * f * x)\\n for i, (ai, bi) in enumerate(zip(cos_a, sin_b), start=1))\\n return series\",\n \"def generate_basis(n, dim):\\n planes = [np.random.randn(dim) for i in range(n)]\\n return [p / np.linalg.norm(p) for p in planes]\",\n \"def _f(X, g, n):\\n if n == 3:\\n n = 3.001 # for numerical stability\\n hyp2f1_term = hyp2f1((n-1)/2, g/2, n/2, 1/(1+X**2))\\n beta_term = beta((n-1)/2, 0.5)\\n return 0.5 * beta_term * hyp2f1_term * (1+X**2) ** ((1-n)/2)\",\n \"def evaluate_polynomial(f,x):\\n degree = len(f)-1\\n ans = 0\\n for i in f:\\n ans += i*x**degree\\n degree -= 1\\n return(ans)\",\n \"def eval_chebyt(n,\\n x,\\n low = -1.,\\n high = 1.,\\n normalization = \\\"classical\\\"):\\n if not isinstance(n, int):\\n raise NotImplementedError(\\n \\\"This function is currently implemented only for \\\" +\\n \\\"integer values of n\\\")\\n # TODO(pedregosa): what happens if n is negative?\\n coefs = recurrence_chebyt(low, high, normalization)\\n return utils.eval_three_term(n, coefs, x)\",\n \"def cheby16(f,a,b,n):\\n if n == 1:\\n ts = np.array([a])\\n h = (b-a)\\n else:\\n ts, h = np.linspace(a,b,num=n, endpoint=False, retstep=True)\\n\\n xs = (c16+1)*h/2\\n xs = xs.reshape((1,-1))\\n ts = ts.reshape((-1,1))\\n all_ts = ts + xs\\n all_fts = f(all_ts)\\n return np.sum(np.dot(all_fts,w16))*h/2\",\n \"def generate_random_tropical_poly(max_degree, min_coefficient, max_coefficient):\\n coefficients = []\\n for d in range(0, random.randint(1, max_degree) + 1):\\n coefficients.append(random.randint(min_coefficient, max_coefficient))\\n return coefficients\",\n \"def Coef(expr, n,i):\\n return int(expr.coeff_monomial(x**(i+n)*y**n))\",\n \"def required_nb_data_func(list_nb_coeff):\\n return max(list_nb_coeff / (1+np.arange(1, N+1)//2))\",\n \"def minimize(self, n=1000):\\n # TODO: review this whole funciton\\n ranges = self.bounds[:, 1] - self.bounds[:, 0]\\n ndim = ranges.size\\n theta = self.sample(np.random.rand(n, self.ndim))\\n opts, sses = [], []\\n for p0 in tqdm(theta):\\n results = minimize(fun=self.chi, x0=p0, method='L-BFGS-B', jac=self.grad_chi, bounds=self.bounds)\\n opts.append(results.x)\\n sses.append(self.chi(results.x))\\n mask = np.isfinite(sses)\\n sses = np.array(sses)[mask]\\n opts = np.array(opts)[mask]\\n sorted_ids = np.argsort(sses)\\n sses = sses[sorted_ids]\\n opts = opts[sorted_ids]\\n return opts, sses\",\n \"def H(n,x):\\r\\n H_values = [] #a list of sequential H values for different n's up to n=n.\\r\\n H_values.append(1) #appends H_0.\\r\\n H_values.append(2*x) #appends H_1.\\r\\n if n>1:\\r\\n for i in range(1,n):\\r\\n H_values.append((2*x*H_values[-1])-(2*i*H_values[-2]))\\r\\n return H_values[-1]\\r\\n elif n == 0:\\r\\n return H_values[0]\\r\\n else:\\r\\n return H_values[1]\",\n \"def poly(n, force_zero=None, **kwargs):\\n if force_zero is None and len(kwargs) == 0:\\n # noinspection PyUnusedLocal\\n def pf(x, params, const_list, const_dict):\\n return np.polyval(params, x)\\n return FitFunction(\\n func=pf, num_fit_params=n + 1, force_zero=force_zero,\\n name='poly{}'.format(n), code='p{}'.format(n), **kwargs\\n )\\n else:\\n # noinspection PyUnusedLocal\\n def pf(x, params, const_list, const_dict):\\n return np.polyval(np.concatenate((params, np.zeros(1))), x)\\n return FitFunction(\\n func=pf, num_fit_params=n, force_zero=force_zero,\\n name='poly{}'.format(n), code='p{}'.format(n), **kwargs\\n )\",\n \"def zernike_num_coeff(n):\\n \\n\\tif not (n>=0):\\n\\t\\tprint('Input parameter must be >= 0')\\n\\t\\traise AssertionError() \\n \\n\\treturn sum(xrange(n+1)) + n+1\",\n \"def Mn_plus_distribution(n, x):\\n b_bounds = Mn_plus_bounds(n, x)\\n return 1.0 - crossprob.ecdf1_new_b(b_bounds)\\n #return 1.0 - crossprob.ecdf2(b_bounds, [1]*len(b_bounds), True)\",\n \"def cdfFunction(f, x, N):\\r\\n return ssstats.binom.cdf(x, N, f)\",\n \"def linear_score_function(n: int) -> ndarray:\\n return np.array([(n - p) / (n * (n - 1) / 2) for p in range(1, n + 1)])\",\n \"def zernike_radial_coeffs(l, m, exact=True):\\n l = np.atleast_1d(l).astype(int)\\n m = np.atleast_1d(np.abs(m)).astype(int)\\n lm = np.vstack([l, m]).T\\n # for modest to large arrays, faster to find unique values and\\n # only evaluate those\\n lms, idx = np.unique(lm, return_inverse=True, axis=0)\\n\\n npoly = len(lms)\\n lmax = np.max(lms[:, 0])\\n coeffs = np.zeros((npoly, lmax + 1), dtype=object)\\n lm_even = ((lms[:, 0] - lms[:, 1]) % 2 == 0)[:, np.newaxis]\\n for ii in range(npoly):\\n ll = lms[ii, 0]\\n mm = lms[ii, 1]\\n for s in range(mm, ll + 1, 2):\\n coeffs[ii, s] = (\\n (-1) ** ((ll - s) // 2)\\n * factorial((ll + s) // 2)\\n // (\\n factorial((ll - s) // 2)\\n * factorial((s + mm) // 2)\\n * factorial((s - mm) // 2)\\n )\\n )\\n c = np.fliplr(np.where(lm_even, coeffs, 0))\\n if not exact:\\n try:\\n c = c.astype(int)\\n except OverflowError:\\n c = c.astype(float)\\n c = c[idx]\\n return c\",\n \"def fit_linear(self, h, m):\\n susceptibility, coercivity, r, p, se = scipy.stats.linregress(h, m)\\n return coercivity/susceptibility, susceptibility\",\n \"def coefficients(k, xi, x):\\n\\n import pyweno.cnonuniform\\n\\n x = np.asarray(x, np.float64)\\n xi = np.asarray(xi, np.float64)\\n\\n nc = len(x) - 1\\n n = len(xi)\\n c = np.zeros((nc, n, k, k), np.float64)\\n beta = np.zeros((nc, k, k, k), np.float64)\\n varpi = np.zeros((nc, n, k), np.float64)\\n\\n pyweno.cnonuniform.nonuniform_coeffs(k, xi, x, c, beta, varpi)\\n\\n return c, beta, varpi\",\n \"def coeffs(f):\\n return dmp_coeffs(f.rep, f.lev, f.dom)\",\n \"def zzx_sqr(f):\\n df, h = zzx_degree(f), []\\n\\n for i in xrange(0, 2*df+1):\\n coeff = INT_ZERO\\n\\n jmin = max(0, i-df)\\n jmax = min(i, df)\\n\\n n = jmax - jmin + 1\\n\\n jmax = jmin + n // 2 - 1\\n\\n for j in xrange(jmin, jmax+1):\\n coeff += f[j]*f[i-j]\\n\\n coeff += coeff\\n\\n if n & 1:\\n elem = f[jmax+1]\\n coeff += elem**2\\n\\n h.append(coeff)\\n\\n return h\",\n \"def c_coefficients(x1,x2,x3,y1,y2,y3,initial_slope,final_slope):\\n\\tC = c_matrix(x1,x2,x3)\\n\\ty = y_vector(x1,x2,x3,y1,y2,y3,initial_slope,final_slope)\\n\\tCCoefficients = np.dot(inv(C),y)\\n\\treturn(CCoefficients)\",\n \"def get_polyfit_hess_function(self):\\n return lambda x : self.get_polyfit_hess(x)\",\n \"def zzX_sqr(f):\\n if poly_univariate_p(f):\\n return zzx_sqr(f)\\n\\n if zzX_zero_p(f):\\n return f\\n\\n df = zzX_degree(f)\\n l = poly_level(f)-1\\n\\n h = []\\n\\n for i in xrange(0, 2*df+1):\\n coeff = zzX_zero(l)\\n\\n jmin = max(0, i-df)\\n jmax = min(i, df)\\n\\n n = jmax - jmin + 1\\n\\n jmax = jmin + n // 2 - 1\\n\\n for j in xrange(jmin, jmax+1):\\n coeff = zzX_add(coeff, zzX_mul(f[j], f[i-j]))\\n\\n coeff = zzX_mul_const(coeff, 2)\\n\\n if n & 1:\\n elem = zzX_sqr(f[jmax+1])\\n coeff = zzX_add(coeff, elem)\\n\\n h.append(coeff)\\n\\n return h\",\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 cubic_spline_interpolation(q_, m = 100):\\n n = q_.shape[0]\\n dof = q_.shape[1]\\n\\n q_ = np.transpose(q_)\\n\\n m = m + (m % (n-1))\\n k = int(m / (n-1))\\n timesteps = [np.linspace(0, 1, num = k, endpoint = False) for _ in range(n-2)]\\n timesteps.append(np.linspace(0, 1, num = k))\\n\\n # Generate A matrix\\n A = np.zeros((dof, n, n))\\n # A[:, 0, 0] = 2\\n # A[:, 0, 1] = 1\\n # A[:, n-1, n-2] = 1\\n # A[:, n-1, n-1] = 2\\n A[:, 0, 0] = 1\\n A[:, n-1, n-1] = 1\\n for i in range(1, n-1):\\n A[:, i, i - 1] = 1\\n A[:, i, i] = 4\\n A[:, i, i + 1] = 1\\n\\n # Generate b matrix\\n y = np.zeros((dof, n))\\n # y[:, 0] = 3 * (q_[:, 1] - q_[:, 0])\\n # y[:, n-1] = 3 * (q_[:, n - 1] - q_[:, n - 2])\\n y[:, 0] = 0\\n y[:, n-1] = 0\\n for i in range(1, n-1):\\n y[:, i] = 3 * (q_[:, i + 1] - q_[:, i - 1])\\n\\n # Solve D\\n D = np.linalg.solve(A, y)\\n\\n # Calculate coefficients\\n a = np.copy(q_[:, :n-1])\\n b = np.copy(D[:, :n-1])\\n c = np.zeros((dof, n-1))\\n d = np.zeros((dof, n-1))\\n for i in range(0, n-1):\\n c[:, i] = 3 * (q_[:, i + 1] - q_[:, i]) - 2 * D[:, i] - D[:, i + 1]\\n d[:, i] = 2 * (q_[:, i] - q_[:, i + 1]) + D[:, i] + D[:, i + 1]\\n\\n \\n # Calculate Trajectories\\n q = np.zeros((dof, m))\\n qd = np.zeros((dof, m))\\n qdd = np.zeros((dof, m))\\n\\n for j in range(n - 1):\\n for i in range(len(timesteps[j])):\\n t = timesteps[j][i]\\n t_2 = t * t\\n t_3 = t * t * t\\n\\n q[:, i + j * k] = a[:, j] + b[:, j] * t + c[:, j] * t_2 + d[:, j] * t_3\\n qd[:, i + j * k] = b[:, j] + 2 * c[:, j] * t + 3 * d[:, j] * t_2\\n qdd[:, i + j * k] = 2 * c[:, j] + 6 * d[:, j] * t\\n\\n return q, qd, qdd\",\n \"def chebyshev_polynomials(adj, k):\\n print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0]) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (\\n 2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0])\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0]))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k + 1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return sparse_to_tensor(t_k)\",\n \"def generateHashFunctions(n):\\n hashFunction = []\\n for i in range(n):\\n # Chooses random value to use as xor during a single hash function\\n random_XORvalue = random.getrandbits(INT_SIZE)\\n hashFunction.append((random_XORvalue))\\n return hashFunction\",\n \"def cost_function(x, N, w, dt):\\n yh = np.abs(fftkernel(x, w / dt)) # density\\n # formula for density\\n C = np.sum(yh ** 2) * dt - 2 * np.sum(yh * x) * \\\\\\n dt + 2 / np.sqrt(2 * np.pi) / w / N\\n C = C * N * N\\n # formula for rate\\n # C = dt*sum( yh.^2 - 2*yh.*y_hist + 2/sqrt(2*pi)/w*y_hist )\\n return C, yh\",\n \"def trapezium_rule(f, m, x, a, b, n):\\n h = (b-a)/float(n)\\n s = 0.5*(f(m, x, a) + f(m, x, b))\\n for i in range(n):\\n s = s + f(m, x, a + i*h)\\n return h*s\",\n \"def biphasic_fit_function(x, a, b, c, d, e, f):\\n term1 = 1 + (a + (1 - a)/(1 + (x * (10 ** b)) ** c))\\n term2 = 1 + (d + (1 - d)/(1 + (x * (10 ** e)) ** f))\\n\\n biphasic_function = 2 ** (0.5 * (np.log2(term1) + np.log2(term2))) - 1\\n return biphasic_function\",\n \"def _energy_test_statistic_coefficient(\\n n: int,\\n m: int,\\n) -> float:\\n return n * m / (n + m)\",\n \"def linear_combination(n):\\n weighs = (1, 3, 9, 27)\\n\\n for factors in factors_set():\\n sum = 0\\n for i in range(len(factors)):\\n sum += factors[i] * weighs[i]\\n if sum == n:\\n return factors\",\n \"def local_basis_regression(functions, M=10):\\r\\n assert M>1\\r\\n N = M-1\\r\\n L=len(functions)\\r\\n def aux(X,Y):\\r\\n (D,S) = X.shape\\r\\n assert D==1\\r\\n # at the moment only works with dim 1\\r\\n order = np.argsort(X).flatten()\\r\\n X_ = X[...,order]\\r\\n Y_ = Y[order]\\r\\n K=S/M\\r\\n limits = [ X[0,i*K] \\r\\n for i in range(1,M) ]\\r\\n local_weights = np.zeros((M,L))\\r\\n for i in range(0,M):\\r\\n seg = slice(i*K, (i+1)*K)\\r\\n local_weights[i] = get_regression_coefficients(functions, X_[...,seg], Y_[seg]) \\r\\n return local_basis_function(limits, local_weights, functions)\\r\\n return aux\",\n \"def compute_coefficients(self, nrange, irange=None, prec=10, ef=True, Qadd=0):\\n # we first need an initial set of coefficients\\n C = self._coeffs\\n P = self._principal_part\\n M = self._space\\n WR = M.multiplier()\\n weight = M.weight()\\n if(self.prec >= prec or len(C) > 0):\\n # presumable we already have good coefficients\\n pass\\n else:\\n # Need initial set first\\n print(\\\"Computing initial set of coefficients!\\\")\\n self.prec = prec\\n [Y, M0] = self._space.get_Y_and_M(P, weight, prec)\\n Q = M0 + 10\\n W = vv_harmonic_wmwf_setupV(WR, P, Y, M0, Q, weight, self._space._sym_type, verbose=self._space._verbose)\\n if (0, 0) in P:\\n N = self._space.set_norm()\\n # N=set_norm_vv_harmonic_weak_maass_forms(WR,cusp_form=True,holomorphic=self._holomorphic)\\n else:\\n N = self._space.set_norm()\\n # N=set_norm_vv_harmonic_weak_maass_forms(WR,cusp_form=False,holomorphic=self._holomorphic)\\n C = solve_system_for_vv_harmonic_weak_Maass_waveforms(W, N, verbose=self._verbose)\\n\\n # endif\\n # check if we have all coefficients we wanted\\n maxc = max(C[list(C.keys())[0]].keys())\\n if maxc >= max(nrange):\\n print(\\\"Have all we need!\\\")\\n pass\\n else:\\n # we do not have all coefficients we need\\n print(\\\"Need to compute more!!\\\")\\n Ns = nrange # [maxc,max(nrange)]\\n if irange is not None:\\n Is = irange\\n else:\\n Is = [min(M.D()), max(M.D())]\\n\\n # Try to find good Y\\n # Recall that the error in the negative part is usually smaller than in the positive part\\n M_minus = abs(min(self._coeffs[list(self._coeffs.keys())[0]]))\\n M_plus = abs(max(self._coeffs[list(self._coeffs.keys())[0]]))\\n # Assume we computed these coefficients at (almost) the highest horocycle\\n Y0 = mpmath.sqrt(3) / mpmath.mpf(2) * mpmath.mpf(0.995)\\n [err_minus, err_plus] = self.get_error_estimates(Y0, M_minus, M_plus)\\n kint = mpmath.mp.mpf(1 - self._space.weight())\\n print(\\\"original:\\\")\\n print(\\\"err-={0}\\\".format(err_minus))\\n print(\\\"err+={0}\\\".format(err_plus))\\n Y0 = mpmath.mpf(0.5)\\n Yin = Y0\\n for j in range(5000):\\n Y = Y0 * mpmath.power(mpmath.mpf(0.99), j)\\n t = mpmath.pi() * 2 * Y * abs(Ns[0])\\n tmp1 = mpmath.exp(t)\\n err1 = err_plus * tmp1\\n # print \\\"err+=\\\",err1\\n tmp2 = mpmath.gammainc(kint, 2 * t)\\n err2 = err_plus * mpmath.exp(-t) / tmp2\\n # print \\\"err-=\\\",err2\\n if(max(err1, err2) < mpmath.power(10, -prec)):\\n Yin = Y\\n break\\n # t=max(1.0,abs(mpmath.log10(prec)-mpmath.log10(self.prec)))\\n # Yin=t/mpmath.mpf(Ns[0]+Ns[1])*mpmath.mpf(2.0) ## This should be good on average\\n # Yin=Yin*mpmath.mpf(0.2)\\n print(\\\"err={0}\\\".format(max(err1, err2)))\\n print(\\\"Yin={0}\\\".format(Yin))\\n sys.stdout.flush()\\n # Qadd=40\\n try:\\n if(ef):\\n CC = vv_harmonic_wmwf_phase2_2_ef(self, Ns, Is, prec, Yin, Qadd_in=Qadd)\\n else:\\n CC = vv_harmonic_wmwf_phase2_2(M, P, C, Ns, Is, prec, Yin)\\n for x in CC.keys():\\n C[x] = CC[x]\\n except KeyboardInterrupt:\\n print(\\\"Manually stopping...\\\")\",\n \"def hessian(f, x, s=_DEFAULT_STEP):\\n x = np.asarray(x)\\n n = len(x)\\n e = s * np.eye(n)\\n\\n forw1 = np.zeros(n)\\n forw2 = np.zeros((n, n))\\n for i in range(n):\\n forw1[i] = f(x + e[i])\\n for j in range(i, n):\\n forw2[i, j] = forw2[j, i] = f(x + e[i] + e[j])\\n\\n H = (forw2 - _colvec(forw1) - _rowvec(forw1) + f(x)) / s**2\\n return H\",\n \"def generate_polynomial():\\n degree = numpy.random.choice(range(3, 7))\\n x = numpy.linspace(-10, 10, 1000)\\n coefficients = numpy.random.chisquare(3, size=degree) + 1\\n coefficients *= numpy.random.choice([-1, 1], size=coefficients.shape)\\n coefficients *= 0.5\\n y = numpy.polyval(coefficients, x)\\n add_noise(y, 0.1)\\n return x, y\",\n \"def perform_fit(xdata,ydata,initial,n):\\n try:\\n p, pcov = curve_fit(f,xdata,ydata,p0=initial)\\n delta = p[2]-p[1]\\n error = sum([ abs(ydata[i] - f(xdata[i],p[0],p[1],p[2])) for i in range(len(xdata)) ])\\n except:\\n print \\\"ERROR: RuntimeError: Optimal parameters not found: Number of calls to function has reached maxfev\\\"\\n return 0, 0, [0,0,0,0], [0]\\n return abs(delta), error, p, pcov\",\n \"def monte_carlo_sample(f, bounds, n_samples):\\r\\n samples = []\\r\\n pmax = f(bounds[0])\\r\\n tries_per_run = int(n_samples*1/pmax)\\r\\n while len(samples) < n_samples:\\r\\n x = np.random.rand(tries_per_run)*(bounds[1]-bounds[0])+bounds[0]\\r\\n y = np.random.rand(tries_per_run)*pmax\\r\\n good = x[y <= f(x)]\\r\\n samples = samples + [i for i in x[y <= f(x)]]\\r\\n return np.array(np.array(samples))[:n_samples]\",\n \"def _getZc(n):\\n # An extra trial is required for low counts, due to the fact\\n # that there is higher variance in the calculated deviation.\\n extra = 1\\n\\n vFree = n - 1\\n zc = 1.96\\n if vFree > 15:\\n # Normal distribution, and enough that we do not need to\\n # have an extra trial.\\n extra = 0\\n elif vFree >= 10:\\n # Here and below is a t-distribution; note that this comes\\n # from the 97.5% column in Table 3 of Driels et al., since\\n # those coefficients don't include the tail\\n zc = 2.23\\n elif vFree >= 5:\\n zc = 2.57\\n elif vFree >= 4:\\n zc = 2.78\\n elif vFree >= 3:\\n zc = 3.18\\n elif vFree >= 2:\\n zc = 4.30\\n elif vFree >= 1:\\n zc = 12.71\\n return zc, extra\",\n \"def fourier_coefficient(t, freq, n=1, axis=-1):\\n t, freq, n = map(np.asanyarray, (t, freq, n))\\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)\",\n \"def coefficients(self) :\\n raise NotImplementedError\",\n \"def test_quadratic_features_max_n_features():\\n transformer = QuadraticFeatures(max_n_features=5)\\n transformer.fit(X_small)\\n assert len(transformer.combinations_) == 5 - X_small_n_cols\",\n \"def _get_legcoef(self, n0):\\n n = sp.Symbol(\\\"n\\\")\\n return self.legcoefs.xreplace({n: int(n0)}).evalf()\",\n \"def prob3(N):\\n x, y, n = sy.symbols('x, y, n')\\n expr = sy.summation(x**n/sy.factorial(n), (n, 0, N))\\n f = sy.lambdify(y, expr.subs(x, -y**2), \\\"numpy\\\")\\n domain = np.linspace(-2, 2, 100)\\n plt.ion()\\n plt.plot(domain, np.exp(-1*domain**2), label=\\\"original function\\\")\\n plt.plot(domain, f(domain), label=\\\"Maclaurin series\\\")\\n plt.legend()\\n plt.show()\",\n \"def prob6(n):\\n data = np.load('airdata.npy')\\n fx = lambda a, b, n: .5*(a+b + (b-a) * np.cos(np.arange(n+1) * np.pi/n))\\n a, b = 0, 366 - 1/24\\n domain = np.linspace(0, b, 8784)\\n pts = fx(a, b, n)\\n temp = np.abs(pts - domain.reshape(8784, 1))\\n temp2 = np.argmin(temp, axis=0)\\n poly = Barycentric(domain[temp2], data[temp2])\\n\\n plt.ion()\\n plt.subplot(121)\\n plt.plot(domain, data)\\n plt.title(\\\"Data\\\")\\n plt.subplot(122)\\n plt.plot(domain, poly(domain))\\n plt.title(\\\"Interpolation\\\")\\n plt.show()\",\n \"def fit_poly(x, y, n=5, log=False):\\n \\n x_g = x\\n x = np.ma.array(x, mask=y.mask).compressed()\\n y = y.compressed()\\n if log:\\n yl = np.log10(y)\\n else:\\n yl = y\\n fit = np.polyfit(x, yl, n)\\n p = np.poly1d(fit)\\n \\n if log:\\n return 10**(p(x_g))\\n else:\\n return p(x_g)\",\n \"def EllipticCurve_from_Weierstrass_polynomial(f):\\n return EllipticCurve(coefficients_from_Weierstrass_polynomial(f))\",\n \"def _poly_func(x, a, b, c, d, e):\\n return a * x ** 6 + b * x ** 5 + c * x ** 4 + d * x ** 3 + e * x ** 2\",\n \"def _f_lcs(llcs, m, n):\\n r_lcs = llcs / m\\n p_lcs = llcs / n\\n beta = p_lcs / (r_lcs + 1e-12)\\n num = (1 + (beta ** 2)) * r_lcs * p_lcs\\n denom = r_lcs + ((beta ** 2) * p_lcs)\\n f_lcs = num / (denom + 1e-12)\\n return f_lcs\",\n \"def zzX_eval(f, x):\\n if hasattr(x, '__iter__'):\\n return zzX_eval_list(f, x)\\n\\n if poly_univariate_p(f):\\n return zzx_eval(f, x)\\n\\n if not x:\\n return poly_TC(f)\\n\\n result = poly_LC(f)\\n\\n for coeff in f[1:]:\\n result = zzX_mul_const(result, x)\\n result = zzX_add(result, coeff)\\n\\n return result\",\n \"def sample(self,f,N,p=100):\\n return [f(x) for x in np.linspace(0,N,p)]\",\n \"def coarse_fc(n):\\n input_shape = (n,)\\n input_vec = Input(shape=input_shape,name = \\\"Input1\\\", dtype = 'float32')\\n dense = Dense(3,name = \\\"fc1\\\",trainable=True)(input_vec)\\n res = Activation('softmax',name = 'coarse')(dense)\\n model_c = Model(inputs=input_vec,outputs=[res,dense])\\n return(model_c)\",\n \"def coeffients(x, y):\\n\\n # ensure floating point datatypes\\n x.astype(float)\\n y.astype(float)\\n\\n # degree of interpolating polynomial\\n n = len(x)\\n\\n # intitilize list of coeffients for interpolating polynomial to y values\\n c = y.tolist()\\n\\n # compute coeffients\\n for j in range(1, n):\\n for i in range(n-1, j-1, -1):\\n c[i] = float(c[i]-c[i-1])/float(x[i]-x[i-j])\\n\\n # return an array of polynomial coefficient, note: reverse order for np.polyval function\\n return np.array(c[::-1])\",\n \"def zzx_pow(f, n):\\n if not n:\\n return [INT_ONE]\\n if n == 1 or f == [] or f == [1]:\\n return f\\n\\n g = [INT_ONE]\\n\\n while True:\\n n, m = n//2, n\\n\\n if m & 1:\\n g = zzx_mul(g, f)\\n\\n if n == 0:\\n break\\n\\n f = zzx_sqr(f)\\n\\n return g\",\n \"def chebyshev_polynomials(adj, k):\\n # print(\\\"Calculating Chebyshev polynomials up to order {}...\\\".format(k))\\n\\n adj_normalized = normalize_adj(adj)\\n laplacian = sp.eye(adj.shape[0], dtype=adj.dtype) - adj_normalized\\n largest_eigval, _ = eigsh(laplacian, 1, which='LM')\\n scaled_laplacian = (2. / largest_eigval[0]) * laplacian - sp.eye(adj.shape[0], dtype=adj.dtype)\\n\\n t_k = list()\\n t_k.append(sp.eye(adj.shape[0], dtype=adj.dtype))\\n t_k.append(scaled_laplacian)\\n\\n def chebyshev_recurrence(t_k_minus_one, t_k_minus_two, scaled_lap):\\n s_lap = sp.csr_matrix(scaled_lap, copy=True, dtype=adj.dtype)\\n return 2 * s_lap.dot(t_k_minus_one) - t_k_minus_two\\n\\n for i in range(2, k+1):\\n t_k.append(chebyshev_recurrence(t_k[-1], t_k[-2], scaled_laplacian))\\n\\n return t_k\",\n \"def binom_coef(n, k):\\n n = tf.cast(n, tf.float64)\\n k = tf.cast(k, tf.float64)\\n num = factorial(n)\\n denom = tf.multiply(factorial(k), factorial(n-k))\\n return tf.divide(num, denom)\",\n \"def hn(x, n):\\n\\n data = x\\n for _ in xrange(n):\\n data = h(data)\\n return data\",\n \"def fg_day_compare_features_n(cls, n):\\n\\n def func(df):\\n val = cls.day_compare_features(df)\\n return [np_shift(item, n, 0) for item in val]\\n\\n return func\",\n \"def gen_fhe_instance(n, q, alpha=None, h=None, m=None, seed=None):\\n if seed is not None:\\n set_random_seed(seed)\\n\\n q = next_prime(ceil(q)-1, proof=False)\\n if alpha is None:\\n alpha = ZZ(8)/q\\n\\n n, alpha, q = preprocess_params(n, alpha, q)\\n\\n stddev = stddevf(alpha*q)\\n\\n if m is None:\\n m = n\\n K = GF(q, proof=False)\\n A = random_matrix(K, m, n)\\n\\n if h is None:\\n s = random_vector(ZZ, n, x=-1, y=1)\\n else:\\n S = [-1, 1]\\n s = [S[randint(0, 1)] for i in range(h)]\\n s += [0 for _ in range(n-h)]\\n shuffle(s)\\n s = vector(ZZ, s)\\n c = A*s\\n\\n D = DiscreteGaussian(stddev)\\n\\n for i in range(m):\\n c[i] += D()\\n\\n return A, c\",\n \"def upper_bound_of_coefficient(f):\\n weight = 0\\n for c in f.itercoefficients():\\n weight += abs(c)**2\\n weight = arith1.floorsqrt(weight) + 1\\n degree = f.degree()\\n lc = f[degree]\\n m = (degree >> 1) + 1\\n bound = 1\\n for i in range(1, m):\\n b = combinatorial.binomial(m - 1, i) * weight + \\\\\\n combinatorial.binomial(m - 1, i - 1) * lc\\n if bound < b:\\n bound = b\\n return bound\",\n \"def zzX_diff(f, m=1):\\n if poly_univariate_p(f):\\n return zzx_diff(f, m)\\n\\n n = zzX_degree(f)\\n\\n if n < m:\\n return zzX_zero_of(f)\\n\\n deriv, c = [], INT_ONE\\n\\n for i in xrange(0, m):\\n c, n = c*n, n-1\\n\\n for coeff in f[:-m]:\\n h = zzX_mul_const(coeff, c)\\n c, n = n*(c//(n+m)), n-1\\n deriv.append(h)\\n\\n return deriv\",\n \"def bernstein_poly(i, n, t):\\n\\n return comb(n, i) * ( t**(n-i) ) * (1 - t)**i\",\n \"def bernstein_poly(i, n, t):\\n\\n return comb(n, i) * ( t**(n-i) ) * (1 - t)**i\",\n \"def sexp(p,n,res_field=RR):\\n assert n>=2, \\\"Carleman matrix must at least be of size 2 to retrieve the coefficients. But given was \\\" + repr(n)\\n CM = p.carleman_matrix(n)\\n ev = [ r[0] for r in CM.charpoly().roots(QQbar) ]\\n assert len(ev) == n, \\\"Carleman matrix must have exactly \\\" + repr(n) + \\\"eigenvalues, but has \\\" + repr(len(ev))\\n\\n #We want to compute:\\n #sum over k: evk^t*(CM-ev1*I)*(CM-ev2*I)*. omit k * (CM-evn*I)/(evk-ev1)*.. omit k *(evk-evn)\\n Char = [0]*n\\n for k in range(n):\\n #here is possibility for improvement of precision\\n #to separate the fractional from the root parts\\n #expanding the product\\n Char[k] = CM - ev[k]*identity_matrix(n)\\n\\n #we want to have the first row of the product of the matrices\\n #thatswhy we mulitply in front with:\\n prod = vector(QQbar,[0,1]+[0]*(n-2))\\n prodwo = [0]*n\\n for k in range(n):\\n prodwo[k]=prod #these are the first terms until k-1\\n\\n #no need to continue\\n if k == n-1:\\n break\\n\\n #and we add the terms starting with k+1\\n for i in range(k+1,n):\\n prodwo[k] = prodwo[k] * Char[i]\\n\\n prod = prod * Char[k]\\n\\n sprodwo = [0]*n\\n for k in range(n):\\n if k==0:\\n sprodwo[k] = ev[k] - ev[1]\\n start = 2\\n else:\\n sprodwo[k] = ev[k] - ev[0]\\n start = 1\\n\\n for i in range(start,n):\\n if i != k:\\n sprodwo[k] = sprodwo[k] * (ev[k] - ev[i])\\n\\n for k in range(n):\\n print ev[k]\\n print prodwo[k][0]/sprodwo[k]\\n print res_field\\n #return lambda t: sum(res_field(ev[k])**t*res_field(prodwo[k][0]/sprodwo[k]) for k in range(n))\\n return [ev,[prodwo[k][0]/sprodwo[k] for k in range(n)]]\",\n \"def PBpoly(n, x):\\n n = int(n)\\n return Bpoly(n, x-math.floor(x))\",\n \"def schaffern3fcn(x: np.ndarray) -> np.ndarray:\\n n = x.shape[1]\\n assert n == 2, \\\"Schaffer function N. 3 is only defined on a 2D space.\\\"\\n\\n X = x[:, 0]\\n Y = x[:, 1]\\n\\n numeratorcomp = (np.sin(np.cos(np.abs(X**2 - Y**2))) ** 2) - 0.5\\n denominatorcomp = (1 + 0.001 * (X**2 + Y**2)) ** 2\\n scores = 0.5 + numeratorcomp / denominatorcomp\\n\\n return scores\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7639109","0.6433395","0.6052176","0.60155755","0.59195346","0.57900774","0.57421833","0.5741759","0.5730309","0.56809217","0.5661867","0.55754876","0.5554896","0.5551868","0.5530003","0.5522098","0.55102664","0.5499079","0.54902244","0.54771787","0.5465253","0.5461324","0.5458557","0.54483867","0.54220635","0.5380017","0.53757435","0.536896","0.5367328","0.5360259","0.5354602","0.5346171","0.5337978","0.5328387","0.5327253","0.5307048","0.5299019","0.5297414","0.52889425","0.52878433","0.5281845","0.5277493","0.52733094","0.52671146","0.526666","0.5264799","0.52539885","0.5249545","0.5243774","0.52185553","0.52172303","0.52156","0.5195517","0.5191505","0.51770526","0.51758075","0.5175363","0.51748204","0.517131","0.5169501","0.51691115","0.51670486","0.515961","0.5156619","0.51511","0.5150401","0.51465285","0.5137735","0.51320624","0.5125507","0.51254535","0.51207906","0.5119986","0.5117778","0.51124406","0.5109476","0.5099468","0.5096261","0.5092393","0.5090865","0.50859827","0.50820285","0.5075988","0.5075017","0.5074929","0.50722706","0.5062864","0.505876","0.50552577","0.5047645","0.50470847","0.504048","0.5035415","0.5033395","0.5032983","0.503018","0.503018","0.50219315","0.5018369","0.5016144"],"string":"[\n \"0.7639109\",\n \"0.6433395\",\n \"0.6052176\",\n \"0.60155755\",\n \"0.59195346\",\n \"0.57900774\",\n \"0.57421833\",\n \"0.5741759\",\n \"0.5730309\",\n \"0.56809217\",\n \"0.5661867\",\n \"0.55754876\",\n \"0.5554896\",\n \"0.5551868\",\n \"0.5530003\",\n \"0.5522098\",\n \"0.55102664\",\n \"0.5499079\",\n \"0.54902244\",\n \"0.54771787\",\n \"0.5465253\",\n \"0.5461324\",\n \"0.5458557\",\n \"0.54483867\",\n \"0.54220635\",\n \"0.5380017\",\n \"0.53757435\",\n \"0.536896\",\n \"0.5367328\",\n \"0.5360259\",\n \"0.5354602\",\n \"0.5346171\",\n \"0.5337978\",\n \"0.5328387\",\n \"0.5327253\",\n \"0.5307048\",\n \"0.5299019\",\n \"0.5297414\",\n \"0.52889425\",\n \"0.52878433\",\n \"0.5281845\",\n \"0.5277493\",\n \"0.52733094\",\n \"0.52671146\",\n \"0.526666\",\n \"0.5264799\",\n \"0.52539885\",\n \"0.5249545\",\n \"0.5243774\",\n \"0.52185553\",\n \"0.52172303\",\n \"0.52156\",\n \"0.5195517\",\n \"0.5191505\",\n \"0.51770526\",\n \"0.51758075\",\n \"0.5175363\",\n \"0.51748204\",\n \"0.517131\",\n \"0.5169501\",\n \"0.51691115\",\n \"0.51670486\",\n \"0.515961\",\n \"0.5156619\",\n \"0.51511\",\n \"0.5150401\",\n \"0.51465285\",\n \"0.5137735\",\n \"0.51320624\",\n \"0.5125507\",\n \"0.51254535\",\n \"0.51207906\",\n \"0.5119986\",\n \"0.5117778\",\n \"0.51124406\",\n \"0.5109476\",\n \"0.5099468\",\n \"0.5096261\",\n \"0.5092393\",\n \"0.5090865\",\n \"0.50859827\",\n \"0.50820285\",\n \"0.5075988\",\n \"0.5075017\",\n \"0.5074929\",\n \"0.50722706\",\n \"0.5062864\",\n \"0.505876\",\n \"0.50552577\",\n \"0.5047645\",\n \"0.50470847\",\n \"0.504048\",\n \"0.5035415\",\n \"0.5033395\",\n \"0.5032983\",\n \"0.503018\",\n \"0.503018\",\n \"0.50219315\",\n \"0.5018369\",\n \"0.5016144\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7481705"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84682,"cells":{"query":{"kind":"string","value":"This method does NOT work!! except for some parameter values like eco = projectionmethod(N=2,tol=0.01,R=5,W=10,beta=0.98,delta=0.05,ncheb=2)"},"document":{"kind":"string","value":"def projection(e,N=30):\n start_time = datetime.now() # records the starting time\n for i in range(N):\n e.IterateCheby()\n e.CalculateChebyPaths()\n e.Aggregate()\n if e.Converged:\n print 'Converged! in',i+1,'iterations with tolerance level',e.tol\n break\n end_time = datetime.now()\n print('Duration: {}'.format(end_time - start_time))\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 Projection(W, TYPE_PROJ = proj_l11ball, ETA = 100, AXIS = 0, ETA_STAR = 100, device = \"cpu\" ): \n \n #global TYPE_PROJ, ETA, ETA_STAR, AXIS, device \n if TYPE_PROJ == 'No_proj':\n W_new = W\n if (TYPE_PROJ == proj_l1ball or TYPE_PROJ == proj_l11ball or TYPE_PROJ == proj_l11ball_line ):\n W_new = TYPE_PROJ(W, ETA, device)\n if TYPE_PROJ == proj_l21ball or TYPE_PROJ == proj_l12ball:\n W_new = TYPE_PROJ(W, ETA, AXIS, device = device)\n if TYPE_PROJ == proj_nuclear:\n W_new = TYPE_PROJ(W, ETA_STAR, device=device)\n return W_new","def doParametersOfInterest(self):\n \n self.modelBuilder.doVar('expr::cosW(\"0.87681811112\",)')\n self.modelBuilder.doVar('expr::sinW(\"0.48082221247\",)')\n self.modelBuilder.doVar('expr::mZ(\"91.2\",)')\n self.modelBuilder.doVar('expr::Lambda1(\"100.0\",)')\n self.modelBuilder.doVar('expr::e2(\"0.0917\",)')\n self.modelBuilder.doVar('expr::gs2(\"1.533\",)')\n\n # EFT Higgs basis couplings\n\n self.modelBuilder.doVar('cZ[0,-1,1]') \n self.modelBuilder.doVar(\"cZZ[0,-2,2]\") \n self.modelBuilder.doVar(\"cZZt[0,-2,2]\") \n self.modelBuilder.doVar(\"cZB[0,-6,6]\") \n\n poi='cZ,cZZ,cZZt,cZB'\n\n # Amplitude couplings from EFT couplings \n\n self.modelBuilder.doVar('expr::a1(\"@0+1\",cZ)') # (\"2*(@0+1)\",cZ) in AN/Paper but a1 = 1 for signal model and width calculation\n self.modelBuilder.doVar('expr::a2(\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\",cZZ,e2,sinW,cosW)')\n self.modelBuilder.doVar('expr::a3(\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\",cZZt,e2,sinW,cosW)')\n self.modelBuilder.doVar('expr::k1(\"@0*(@1*pow(@2,2)/(pow(@3,2)*pow(@4,2)))\",cZB,e2,Lambda1,sinW,mZ)')\n self.modelBuilder.doVar('expr::k1L1(\"@0/pow(@1,2)\",k1,Lambda1)')\n\n ###### gamma_H ########\n\n # SMEFT relationships for VV couplings (Expressed using amplitude couplings)\n\n self.modelBuilder.doVar('expr::kappa(\"1.0\",)')\n self.modelBuilder.doVar('expr::kappa_tilde(\"0.0\",)') \n\n self.modelBuilder.doVar('expr::a1_WW(\"@0\",a1)')\n self.modelBuilder.doVar('expr::a2_WW(\"@0*@0*@1\",cosW,a2)')\n self.modelBuilder.doVar('expr::a3_WW(\"@0*@0*@1\",cosW,a3)')\n self.modelBuilder.doVar('expr::k1_WW(\"(@2 / (@0*@0 - @1*@1) - 2*@1*@1*@3*@4*@4 /(@5*@5*(@0*@0 - @1*@1)))\",cosW,sinW,k1,a2,Lambda1,mZ)')\n self.modelBuilder.doVar('expr::k2_k1(\"2*@0*@1*@2/(@0*@0 - @1*@1)\",cosW,sinW,k1)')\n self.modelBuilder.doVar('expr::k2_a2(\"-2*@0*@1*@3*@4*@4/((@2*@2)*(@0*@0 - @1*@1))\",cosW,sinW,mZ,a2,Lambda1)')\n self.modelBuilder.doVar('expr::k2(\"@0 + @1\",k2_k1,k2_a2)')\n\n # Determine gamma_H from VV couplings\n\n zz_expr = '\"4*(@0*@0/4. + 0.1695*@3*@3 + 0.09076*@1*@1 + 0.03809*@2*@2 + 0.8095*@0*@3/2. + 0.5046*@0*@1/2. + 0.2092*@1*@3 + 0.1023*@4*@4 + 0.1901*@0*@4/2. + 0.07429*@3*@4 + 0.04710*@1*@4) \",a1,a2,a3,k1,k2'\n ww_expr = '\"4*(@0*@0/4. + 0.1320*@3*@3 + 0.1944*@1*@1 + 0.08075*@2*@2 + 0.7204*@0*@3/2. + 0.7437*@0*@1/2. + 0.2774*@3*@1) \",a1_WW,a2_WW,a3_WW,k1_WW'\n zgamma_expr = '\"4*(1.118600*@0*@0/4. +0.0035*@1*@1 - 0.125010*@0*@1/2. + 0.000003*@1*@1 - 0.00018*@1*@1 + 0.003100*@0*@1/2. +0.00126*@2*@2 + 0.000005*@2*@2 -0.00047*@2*@2)\",a1_WW,kappa,kappa_tilde'\n gg_expr = '\"(1.1068*@0*@0 + 0.0082*@0*@0 - 0.1150*@0*@0 + 2.5717*@1*@1 + 0.0091*@1*@1 - 0.1982*@1*@1)\",kappa,kappa_tilde'\n bb_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n cc_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n tautau_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n mumu_expr = '\"(@0*@0 + @1*@1)\",kappa,kappa_tilde'\n gmgm_expr = '\"4*(1.6054*@0*@0/4. + 0.07312*@1*@1 - 0.6854*@0*@1/2. + 0.00002*@1*@1 - 0.0018*@1*@1 + 0.0085*@0*@1/2. + 0.1699*@2*@2 + 0.00002*@2*@2 - 0.0031*@2*@2)\",a1_WW,kappa,kappa_tilde'\n \n self.modelBuilder.doVar('expr::R_WW('+str(ww_expr)+')')\n self.modelBuilder.doVar('expr::R_ZZ('+str(zz_expr)+')')\n self.modelBuilder.doVar('expr::R_Zgamma('+str(zgamma_expr)+')')\n self.modelBuilder.doVar('expr::R_gg('+str(gg_expr)+')')\n self.modelBuilder.doVar('expr::R_bb('+str(bb_expr)+')')\n self.modelBuilder.doVar('expr::R_cc('+str(cc_expr)+')')\n self.modelBuilder.doVar('expr::R_tautau('+str(tautau_expr)+')')\n self.modelBuilder.doVar('expr::R_mumu('+str(mumu_expr)+')')\n self.modelBuilder.doVar('expr:R_gammagamma('+str(gmgm_expr)+')')\n\n self.modelBuilder.doVar('expr::gammaH(\"(0.5824*@0 + 0.2137*@1 + 0.08187*@2 + 0.06272*@3 + 0.02891*@4 + 0.02619*@5 + 0.002270*@6 + 0.001533*@7 + 0.0002176*@8 )/0.9998\",R_bb,R_WW,R_gg,R_tautau,R_cc,R_ZZ,R_gammagamma,R_Zgamma,R_mumu)') \n\n ###########################\n\n self.g1V = GetCoupTerms(1,1,1,-0.0001,\"1V\") # Compensate for scaling of k1 templates \n self.g2V = GetCoupTerms(1,1,1,-0.0001,\"2V\") \n \n self.modelBuilder.doVar(\"expr::g2V_1(\\\"\"+str(self.g2V[0])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T1(\\\"((pow(@0,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T1_Neg(\\\"-1*((pow(@0,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\") \n self.modelBuilder.doVar(\"expr::g2V_2(\\\"\"+str(self.g2V[1])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T2(\\\"((pow(@0,3)*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T2_Neg(\\\"-1*((pow(@0,3)*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\") \n self.modelBuilder.doVar(\"expr::g2V_3(\\\"\"+str(self.g2V[2])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T3(\\\"((pow(@0,2)*pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T3_Neg(\\\"-1*((pow(@0,2)*pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\") \n self.modelBuilder.doVar(\"expr::g2V_4(\\\"\"+str(self.g2V[3])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T4(\\\"((@0*pow(@1,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T4_Neg(\\\"-1*((@0*pow(@1,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\") \n self.modelBuilder.doVar(\"expr::g2V_5(\\\"\"+str(self.g2V[4])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T5(\\\"((pow(@1,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T5_Neg(\\\"-1*((pow(@1,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\") \n self.modelBuilder.doVar(\"expr::g2V_6(\\\"\"+str(self.g2V[5])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T6(\\\"((pow(@0,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T6_Neg(\\\"-1*((pow(@0,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\") \n self.modelBuilder.doVar(\"expr::g2V_7(\\\"\"+str(self.g2V[6])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T7(\\\"((pow(@0,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T7_Neg(\\\"-1*((pow(@0,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\") \n self.modelBuilder.doVar(\"expr::g2V_8(\\\"\"+str(self.g2V[7])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T8(\\\"((@0*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T8_Neg(\\\"-1*((@0*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\") \n self.modelBuilder.doVar(\"expr::g2V_9(\\\"\"+str(self.g2V[8])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T9(\\\"((pow(@2,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T9_Neg(\\\"-1*((pow(@2,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\") \n self.modelBuilder.doVar(\"expr::g2V_10(\\\"\"+str(self.g2V[9])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T10(\\\"((pow(@0,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T10_Neg(\\\"-1*((pow(@0,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\") \n self.modelBuilder.doVar(\"expr::g2V_11(\\\"\"+str(self.g2V[10])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T11(\\\"((pow(@0,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T11_Neg(\\\"-1*((pow(@0,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\") \n self.modelBuilder.doVar(\"expr::g2V_12(\\\"\"+str(self.g2V[11])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T12(\\\"((@0*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T12_Neg(\\\"-1*((@0*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\") \n self.modelBuilder.doVar(\"expr::g2V_13(\\\"\"+str(self.g2V[12])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T13(\\\"((pow(@3,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T13_Neg(\\\"-1*((pow(@3,4))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\") \n self.modelBuilder.doVar(\"expr::g2V_14(\\\"\"+str(self.g2V[13])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T14(\\\"((pow(@1,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T14_Neg(\\\"-1*((pow(@1,3)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\") \n self.modelBuilder.doVar(\"expr::g2V_15(\\\"\"+str(self.g2V[14])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T15(\\\"((pow(@1,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T15_Neg(\\\"-1*((pow(@1,2)*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\") \n self.modelBuilder.doVar(\"expr::g2V_16(\\\"\"+str(self.g2V[15])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T16(\\\"((@1*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T16_Neg(\\\"-1*((@1*pow(@2,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\") \n self.modelBuilder.doVar(\"expr::g2V_17(\\\"\"+str(self.g2V[16])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T17(\\\"((pow(@1,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T17_Neg(\\\"-1*((pow(@1,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\") \n self.modelBuilder.doVar(\"expr::g2V_18(\\\"\"+str(self.g2V[17])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T18(\\\"((pow(@1,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T18_Neg(\\\"-1*((pow(@1,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\") \n self.modelBuilder.doVar(\"expr::g2V_19(\\\"\"+str(self.g2V[18])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T19(\\\"((@1*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T19_Neg(\\\"-1*((@1*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\") \n self.modelBuilder.doVar(\"expr::g2V_20(\\\"\"+str(self.g2V[19])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T20(\\\"((pow(@2,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T20_Neg(\\\"-1*((pow(@2,3)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\") \n self.modelBuilder.doVar(\"expr::g2V_21(\\\"\"+str(self.g2V[20])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T21(\\\"((pow(@2,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T21_Neg(\\\"-1*((pow(@2,2)*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\") \n self.modelBuilder.doVar(\"expr::g2V_22(\\\"\"+str(self.g2V[21])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T22(\\\"((@2*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T22_Neg(\\\"-1*((@2*pow(@3,3))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\") \n self.modelBuilder.doVar(\"expr::g2V_23(\\\"\"+str(self.g2V[22])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T23(\\\"((@0*@1*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T23_Neg(\\\"-1*((@0*@1*pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\") \n self.modelBuilder.doVar(\"expr::g2V_24(\\\"\"+str(self.g2V[23])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T24(\\\"((@0*pow(@1,2)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T24_Neg(\\\"-1*((@0*pow(@1,2)*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\") \n self.modelBuilder.doVar(\"expr::g2V_25(\\\"\"+str(self.g2V[24])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T25(\\\"((pow(@0,2)*@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T25_Neg(\\\"-1*((pow(@0,2)*@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\") \n self.modelBuilder.doVar(\"expr::g2V_26(\\\"\"+str(self.g2V[25])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T26(\\\"((@0*@1*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T26_Neg(\\\"-1*((@0*@1*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\") \n self.modelBuilder.doVar(\"expr::g2V_27(\\\"\"+str(self.g2V[26])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T27(\\\"((@0*pow(@1,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T27_Neg(\\\"-1*((@0*pow(@1,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\") \n self.modelBuilder.doVar(\"expr::g2V_28(\\\"\"+str(self.g2V[27])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T28(\\\"((pow(@0,2)*@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T28_Neg(\\\"-1*((pow(@0,2)*@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\") \n self.modelBuilder.doVar(\"expr::g2V_29(\\\"\"+str(self.g2V[28])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T29(\\\"((@0*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T29_Neg(\\\"-1*((@0*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\") \n self.modelBuilder.doVar(\"expr::g2V_30(\\\"\"+str(self.g2V[29])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T30(\\\"((@0*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T30_Neg(\\\"-1*((@0*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\") \n self.modelBuilder.doVar(\"expr::g2V_31(\\\"\"+str(self.g2V[30])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T31(\\\"((pow(@0,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T31_Neg(\\\"-1*((pow(@0,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\") \n self.modelBuilder.doVar(\"expr::g2V_32(\\\"\"+str(self.g2V[31])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T32(\\\"((@1*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T32_Neg(\\\"-1*((@1*@2*pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\") \n self.modelBuilder.doVar(\"expr::g2V_33(\\\"\"+str(self.g2V[32])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T33(\\\"((@1*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T33_Neg(\\\"-1*((@1*pow(@2,2)*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\") \n self.modelBuilder.doVar(\"expr::g2V_34(\\\"\"+str(self.g2V[33])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T34(\\\"((pow(@1,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T34_Neg(\\\"-1*((pow(@1,2)*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\") \n self.modelBuilder.doVar(\"expr::g2V_35(\\\"\"+str(self.g2V[34])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T35(\\\"((@0*@1*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\") \n self.modelBuilder.factory_(\"expr::scale_Ewk_T35_Neg(\\\"-1*((@0*@1*@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\") \n \n self.modelBuilder.doVar(\"expr::g1V_1(\\\"\"+str(self.g1V[0])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T1(\\\"((pow(@0,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T1_Neg(\\\"-1*((pow(@0,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\") \n self.modelBuilder.doVar(\"expr::g1V_2(\\\"\"+str(self.g1V[1])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T2(\\\"((@0*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T2_Neg(\\\"-1*((@0*@1)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\") \n self.modelBuilder.doVar(\"expr::g1V_3(\\\"\"+str(self.g1V[2])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T3(\\\"((pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T3_Neg(\\\"-1*((pow(@1,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\") \n self.modelBuilder.doVar(\"expr::g1V_4(\\\"\"+str(self.g1V[3])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T4(\\\"((@0*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T4_Neg(\\\"-1*((@0*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\") \n self.modelBuilder.doVar(\"expr::g1V_5(\\\"\"+str(self.g1V[4])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T5(\\\"((pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T5_Neg(\\\"-1*((pow(@2,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\") \n self.modelBuilder.doVar(\"expr::g1V_6(\\\"\"+str(self.g1V[5])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T6(\\\"((@0*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T6_Neg(\\\"-1*((@0*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\") \n self.modelBuilder.doVar(\"expr::g1V_7(\\\"\"+str(self.g1V[6])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T7(\\\"((pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T7_Neg(\\\"-1*((pow(@3,2))/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\") \n self.modelBuilder.doVar(\"expr::g1V_8(\\\"\"+str(self.g1V[7])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T8(\\\"((@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T8_Neg(\\\"-1*((@1*@2)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\") \n self.modelBuilder.doVar(\"expr::g1V_9(\\\"\"+str(self.g1V[8])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T9(\\\"((@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T9_Neg(\\\"-1*((@1*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\") \n self.modelBuilder.doVar(\"expr::g1V_10(\\\"\"+str(self.g1V[9])+\"\\\",)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T10(\\\"((@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\") \n self.modelBuilder.factory_(\"expr::scale_ggH_T10_Neg(\\\"-1*((@2*@3)/@4)*@5\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\") \n \n self.modelBuilder.doSet(\"POI\",poi)","def __init__(self, folder):\n print \"folder passed is \", folder\n self.folder = folder\n self.geometry = gf.geometry(self.folder)\n self.elements = gf.dictionary_set()\n self.area = np.zeros(shape = (8))\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\n *self.geometry.properties['span_width']/2))\n self.F = np.zeros(shape = (8, 8))\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\n self.geometry.properties['tra_sidewall_out'],\n self.geometry.properties['tra_cover_in'],\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\n self.geometry.properties['emi_sidewall_out'],\n self.geometry.properties['emi_cover_in'],\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\n if ((self.tr + self.em).any() > 1.0):\n print \"error in optical properties\"\n self.T = np.zeros(shape = (2,10))\n self.RH = np.zeros(shape = (2,10))\n # 8 inside,9 outside \n self.qcond = np.zeros(shape = (2,8))\n self.qconv = np.zeros(shape = (2,8))\n self.qrad = np.zeros(shape = (2,8))\n self.j = np.zeros(shape = (2,8))\n self.g = np.zeros(shape = (2,8))\n self.alpha = np.zeros(shape = (2,8))\n deltaT = 300\n RH_in = 0.6\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\n 278,\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\n self.geometry.properties['sky_temp'])\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\n self.geometry.properties['wind_speed'],\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\n self.geometry.properties['rho'],self.geometry.properties['cp'],\n self.Vol,self.geometry.properties['degree_window'],deltaT)","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"eAfb[0.6,-0.75,0.75]\");\n self.modelBuilder.doVar(\"eA0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doVar(\"dAfb[0.,-0.75,0.75]\");\n self.modelBuilder.doVar(\"dA0[0.0, -1.0, 1.0]\");\n #self.modelBuilder.doSet(\"POI\",\"dAfb,dA0\")\n self.modelBuilder.doSet(\"POI\",\"dAfb\")\n self.modelBuilder.factory_('expr::mAfb(\"@0+@1\",eAfb,dAfb)')\n self.modelBuilder.factory_('expr::mA0(\"(@0+@1)\",eA0,dA0)')\n\n \n self.modelBuilder.factory_('expr::eAlph(\"2.0*@0/(2.0-@0)\",eA0)')\n self.modelBuilder.factory_('expr::eNorm(\"3.0/4.0/(2.0+@0)\",eAlph)')\n self.modelBuilder.factory_('expr::eRAlph(\"@0*@1\",eAlph,eNorm)')\n self.modelBuilder.factory_('expr::eRpl(\"(@0+@1)\",eNorm,eAfb)')\n self.modelBuilder.factory_('expr::eRmn(\"(@0-@1)\",eNorm,eAfb)')\n\n self.modelBuilder.factory_('expr::mAlph(\"2.0*@0/(2.0-@0)\",mA0)')\n self.modelBuilder.factory_('expr::mNorm(\"3.0/4.0/(2.0+@0)\",mAlph)')\n self.modelBuilder.factory_('expr::mRAlph(\"@0*@1\",mAlph,mNorm)')\n self.modelBuilder.factory_('expr::mRpl(\"(@0+@1)\",mNorm,mAfb)')\n self.modelBuilder.factory_('expr::mRmn(\"(@0-@1)\",mNorm,mAfb)')","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"eAfb[0.6,-0.75,0.75]\");\n self.modelBuilder.doVar(\"eA0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doVar(\"rAfb[1.0,-5.0, 5.0]\");\n self.modelBuilder.doVar(\"rA0[1.0, -5.0, 5.0]\");\n self.modelBuilder.doSet(\"POI\",\"rAfb,rA0\")\n self.modelBuilder.factory_('expr::mAfb(\"@0*@1\",eAfb,rAfb)')\n self.modelBuilder.factory_('expr::mA0(\"(@0*@1)\",eA0,rA0)')\n\n \n self.modelBuilder.factory_('expr::eAlph(\"2.0*@0/(2.0-@0)\",eA0)')\n self.modelBuilder.factory_('expr::eNorm(\"3.0/4.0/(2.0+@0)\",eAlph)')\n self.modelBuilder.factory_('expr::eRAlph(\"@0*@1\",eAlph,eNorm)')\n self.modelBuilder.factory_('expr::eRpl(\"(@0+@1)\",eNorm,eAfb)')\n self.modelBuilder.factory_('expr::eRmn(\"(@0-@1)\",eNorm,eAfb)')\n\n self.modelBuilder.factory_('expr::mAlph(\"2.0*@0/(2.0-@0)\",mA0)')\n self.modelBuilder.factory_('expr::mNorm(\"3.0/4.0/(2.0+@0)\",mAlph)')\n self.modelBuilder.factory_('expr::mRAlph(\"@0*@1\",mAlph,mNorm)')\n self.modelBuilder.factory_('expr::mRpl(\"(@0+@1)\",mNorm,mAfb)')\n self.modelBuilder.factory_('expr::mRmn(\"(@0-@1)\",mNorm,mAfb)')","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"eAfb[0.6,-0.75,0.75]\");\n self.modelBuilder.doVar(\"eA0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doVar(\"mAfb[0.6,-0.75,0.75]\");\n self.modelBuilder.doVar(\"mA0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doSet(\"POI\",\"eAfb,mAfb\")\n\n \n self.modelBuilder.factory_('expr::eAlph(\"2.0*@0/(2.0-@0)\",eA0)')\n self.modelBuilder.factory_('expr::eNorm(\"3.0/4.0/(2.0+@0)\",eAlph)')\n self.modelBuilder.factory_('expr::eRAlph(\"@0*@1\",eAlph,eNorm)')\n self.modelBuilder.factory_('expr::eRpl(\"(@0+@1)\",eNorm,eAfb)')\n self.modelBuilder.factory_('expr::eRmn(\"(@0-@1)\",eNorm,eAfb)')\n\n self.modelBuilder.factory_('expr::mAlph(\"2.0*@0/(2.0-@0)\",mA0)')\n self.modelBuilder.factory_('expr::mNorm(\"3.0/4.0/(2.0+@0)\",mAlph)')\n self.modelBuilder.factory_('expr::mRAlph(\"@0*@1\",mAlph,mNorm)')\n self.modelBuilder.factory_('expr::mRpl(\"(@0+@1)\",mNorm,mAfb)')\n self.modelBuilder.factory_('expr::mRmn(\"(@0-@1)\",mNorm,mAfb)')","def new_param_energy(coords, params, topology, vecs, P=1.01, T=293.15,NPT=False,V=None,P_conv=1.e5,V_conv=1.e-6,Ener_conv=1.e-3,N_part=250.):\n\n #-------------------\n # CONSTANTS\n #-------------------\n kB = 0.0083145 #Boltzmann constant (Gas constant) in kJ/(mol*K)\n beta = 1/(kB*T)\n\n #-------------------\n # PARAMETERS\n #-------------------\n params = params\n\n mol2files = []\n for i in params:\n mol2files.append('../monomers/'+i.rsplit(' ',1)[0]+'.mol2')\n\n flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield\n mols = []\n mol = oechem.OEMol()\n for mol2file in mol2files:\n ifs = oechem.oemolistream(mol2file)\n ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)\n mol = oechem.OEGraphMol()\n while oechem.OEReadMolecule(ifs, mol):\n oechem.OETriposAtomNames(mol)\n mols.append(oechem.OEGraphMol(mol))\n K = len(params['cyclohexane'].keys())\n \n # Load forcefield file\n #ffxml = 'smirnoff99Frosst_with_AllConstraints.ffxml'#\n #print('The forcefield being used is smirnoff99Frosst_with_AllConstraints.ffxml')\n ffxml = get_data_filename('forcefield/smirnoff99Frosst.ffxml')\n print('The forcefield being used is smirnoff99Frosst.ffxml')\n\n ff = ForceField(ffxml)\n\n # Generate a topology\n top = topology#generateTopologyFromOEMol(mol)\n\n #-----------------\n # MAIN\n #-----------------\n\n # Calculate energies\n\n E_kn = np.zeros([K,len(coords)],np.float64)\n u_kn = np.zeros([K,len(coords)],np.float64)\n for i,j in enumerate(params):\n AlkEthOH_id = j\n for k,l in enumerate(params[AlkEthOH_id]):\n print(\"Anotha one\")\n for m,n in enumerate(params[AlkEthOH_id][l]):\n newparams = ff.getParameter(smirks=n[0])\n newparams[n[1]]=n[2]\n ff.setParameter(newparams,smirks=n[0])\n system = ff.createSystem(top,mols,nonbondedMethod=PME,nonbondedCutoff=1.125*nanometers,ewaldErrorTolerance=1.e-5)\n barostat = MonteCarloBarostat(P*bar, T*kelvin, 10)\n system.addForce(barostat)\n for o,p in enumerate(coords):\n e = get_energy(system,p,vecs[o])\n \n if not NPT:\n E_kn[k,o] = e._value\n u_kn[k,o] = e._value*beta\n else:\n E_kn[k,o] = e._value + P*P_conv*V[o]*V_conv*Ener_conv*N_part\n u_kn[k,o] = (e._value + P*P_conv*V[o]*V_conv*Ener_conv*N_part)*beta\n \n return E_kn,u_kn","def _init_projection(self):\n radius = 6370e3\n \n # Spherical latlon used by WRF\n self.latlon_sphere = pyproj.Proj(proj='latlong',\n a=radius, b=radius, towgs84='0,0,0', no_defs=True)\n\n # Lambert Conformal Conic used by WRF\n self.lambert_grid = pyproj.Proj(proj='lcc',\n lat_1=self.truelats[0],\n lat_2=self.truelats[1],\n lat_0=self.ref_latlon[0],\n lon_0=self.stand_lon,\n a=radius, b=radius, towgs84='0,0,0', no_defs=True)\n\n grid_size_i = (self.domain_size[0] - 2) * self.cell_size[0]\n grid_size_j = (self.domain_size[1] - 2) * self.cell_size[1]\n\n grid_center_i, grid_center_j = pyproj.transform(\n self.latlon_sphere, self.lambert_grid,\n self.ref_latlon[1], self.ref_latlon[0])\n \n self.offset_i = grid_center_i - grid_size_i * .5\n self.offset_j = grid_center_j - grid_size_j * .5","def find_eta_projection(self):\r\n \r\n # Get temporal range in terms of years\r\n timedelta = self.year_E_fore_gov[self.elms_E_fore_gov] - self.year_E_fore_gov[self.elms_E_fore_gov][0]\r\n # Number of years over time\r\n num_years = len(timedelta)\r\n \r\n self.t_eta_fit = np.zeros(num_years)\r\n \r\n for yr in range(0,num_years):\r\n \r\n self.t_eta_fit[yr] = timedelta[yr].days/365.25\r\n \r\n \r\n popt, _ = curve_fit(model_expected_eta,self.t_eta_fit,self.eta_gdp_fore[self.elms_E_fore_gov],p0=(0.7,0.1,0.01))\r\n \r\n self.eta_0 = popt[0]\r\n self.eta_b = popt[1]\r\n self.xi = popt[2]\r\n self.eta = model_expected_eta(self.t,self.eta_0,self.eta_b,self.xi)\r\n \r\n self.E_noncovid = model_emissions(self.eta,self.Y_noncovid)\r\n \r\n return","def get_sol(self):","def doParametersOfInterest(self):\r\n if self.fg4fixed:\r\n self.modelBuilder.doVar(\"CMS_zz4l_fg4[0]\")\r\n self.modelBuilder.doVar(\"r[1,0,4]\")\r\n print \"Fixing CMS_zz4l_fg4\"\r\n poi = \"r\"\r\n else:\r\n if self.modelBuilder.out.var(\"CMS_zz4l_fg4\"):\r\n print \"have fg4 inside\"\r\n else:\r\n self.modelBuilder.doVar(\"CMS_zz4l_fg4[0.,-1,1]\")\r\n poi = \"CMS_zz4l_fg4\"\r\n if self.cPOI:\r\n if self.modelBuilder.out.var(\"cww_zz\"):\r\n print \"have czz_ww inside\"\r\n else:\r\n self.modelBuilder.doVar(\"cww_zz[0.5,-10,10]\")\r\n poi += \",cww_zz\"\r\n\r\n if self.fg2POI:\r\n if self.modelBuilder.out.var(\"CMS_zz4l_fg2\"):\r\n print \"have fg2 inside\"\r\n else:\r\n self.modelBuilder.doVar(\"CMS_zz4l_fg2[0.,0,1]\")\r\n poi += \",CMS_zz4l_fg2\"\r\n if self.muFloating:\r\n self.modelBuilder.doVar(\"r[1,0,2000]\")\r\n if self.muAsPOI:\r\n print \"Treating r as a POI\"\r\n poi += \",r\"\r\n else:\r\n self.modelBuilder.out.var(\"r\").setAttribute(\"flatParam\")\r\n if self.phiFloating:\r\n if self.modelBuilder.out.var(\"CMS_zz4l_fg4phi\"):\r\n print \"have fg4phi inside\"\r\n else: \r\n self.modelBuilder.doVar(\"CMS_zz4l_fg4phi[0.,-3.1415926,3.1415926]\")\r\n if self.phiPOI:\r\n poi += \",CMS_zz4l_fg4phi\"\r\n else:\r\n self.modelBuilder.out.var(\"CMS_zz4l_fg4phi\").setAttribute(\"flatParam\")\r\n if self.phi2Floating:\r\n #self.modelBuilder.doVar(\"CMS_zz4l_fg4phi[0.,-math.pi,math.pi]\")\r\n if self.modelBuilder.out.var(\"CMS_zz4l_fg2phi\"):\r\n print \"have fg2phi inside\"\r\n else: \r\n self.modelBuilder.doVar(\"CMS_zz4l_fg2phi[0.,-3.1415926,3.1415926]\")\r\n self.modelBuilder.out.var(\"CMS_zz4l_fg2phi\").setAttribute(\"flatParam\")\r\n \r\n self.modelBuilder.doSet(\"POI\",poi)","def SOM(args):\n\n # Obtain the normalized set of cities (w/ coord in [0,1])\n cities = pd.read_csv(Path(args.data_dir) / 'data1.csv')\n\n iteration = args.iteration\n learning_rate = args.learning_rate\n decay = args.decay\n\n out_dir = Path(args.out_dir)\n out_dir.mkdir_p()\n\n cities_nm = cities.copy()\n\n cities_nm[['x', 'y']] = normalize(cities_nm[['x', 'y']])\n cities_nm.to_csv(out_dir/'cities_nm.csv')\n cities.to_csv(out_dir/'cities.csv')\n\n\n depot = cities_nm.query('city==0')[['x','y']].to_numpy()\n # The population size is 8 times the number of cities\n #n = cities_cp.shape[0] * 2# a single route's neurons\n n=100\n # Generate an adequate network of neurons:\n #network = generate_network(n)\n neuron_chains =init_neurons(size=n,depot=depot)\n print('--> Network of {} neurons created. Starting the iterations:'.format(n))\n best_routes=np.array([0])\n\n #save\n losses_sum_log={}#每个循环losses_sum值\n min_losses_sum_log = {}##保存最小值的路径losses\n min_losses_log={}#存储最好情况下四条路径的距离值\n min_routes_log={}\n best_id=0\n min_losses_sum=0\n\n for i in tqdm(range(iteration)):\n if not i % args.neuro_plot_freq:\n print('\\t> Iteration {}/{}'.format(i, iteration), end=\"\\r\")\n # Choose a random city\n sample = cities_nm.sample(1)\n if int(sample['city']) in args.depot_idxs:\n continue\n city = sample[['x', 'y']].values#随机抽样 random sampling\n group_idx,winner_idx = select_closest_gpid(neuron_chains, city)\n\n # Generate a filter that applies changes to the winner's gaussian\n gaussian = get_neighborhood(center=winner_idx, radix=n//10, domain=neuron_chains[0].shape[0])\n # Update the network's weights (closer to the city)\n neuron_chains[group_idx] += gaussian[:,np.newaxis] * learning_rate * (city - neuron_chains[group_idx])\n # Decay the variables\n learning_rate = learning_rate * decay\n n = n * decay\n\n\n if i % args.evaluate_freq==0:\n cities_od = rebuild_cities(cities_nm,neuron_chains,args.num_depots)\n cities_od[['x','y']] =cities.reindex(cities_od['city'])[['x','y']]\n losses = routes_distances(cities_od)\n losses_sum = sum(losses)\n losses_sum_log[i] = losses_sum\n\n if min_losses_sum == 0 or min_losses_sum > losses_sum:\n min_losses_sum = losses_sum\n best_id = i\n routes = get_routes(cities_od)\n routes = [list(item.astype(np.float64)) for item in routes]\n min_routes_log[i] = routes\n\n min_losses_sum_log[i] = losses_sum\n min_losses_log[i] = losses\n cities_od.to_csv(out_dir/'data_out_{:04d}.csv'.format(i))\n save_neuron_chains(neuron_chains,out_dir/\"neuron_chains_{:04d}.npy\".format(i))\n\n #end for\n\n # Check if any parameter has completely decayed.\n if n < 1:\n print('Radius has completely decayed, finishing execution',\n 'at {} iterations'.format(i))\n break\n if learning_rate < 0.001:\n print('Learning rate has completely decayed, finishing execution',\n 'at {} iterations'.format(i))\n break\n\n\n print('Completed {} iterations.'.format(iteration))\n\n results = {}\n\n results['losses_sum_log']=losses_sum_log\n results['best_id'] = best_id\n\n results['min_losses_sum_log']=min_losses_sum_log\n results['min_losses_log']=min_losses_log\n results['min_routes_log'] = min_routes_log\n\n\n p = Path(out_dir/'results.json')\n with open(p, 'w') as fp:\n json.dump(results, fp)\n print('ok')\n\n\n return results","def initializeParameters(self):\n \n # 0 - Output Workspace\n # 1 - Output Feature Name\n # 2 - X coordinate (longitude)\n # 3 - Y coordinate (latitude)\n # 4 - Z coordinate (elevation)\n # 5 - Observer offset (OFFSETA)\n # 6 - Terrain offset (OFFSETB)\n # 7 - Near distance (RADIUS1)\n # 8 - Far distance (RADIUS2\n # 9 - Left Azimuth (AZIMUTH1)\n # 10 - Right Azimuth (AZIMUTH2)\n # 11 - Top vertical angle (VERT1)\n # 12 - Bottom vertical angle (VERT2)\n # 13 - Spatial Reference\n # 14 - output point features\n \n \n #GETTING ERROR HERE, DOESN'T VALIDATE CORRECTLY, BUG?????\n #---------------------------\n #Testing get_ParameterInfo\n #---------------------------\n #initializeParameters Execution Error: Runtime error <type 'exceptions.AttributeError'>: 'NoneType' object has no attribute 'Type'\n #---------------------------\n #OK \n #---------------------------\n #\n #\n #self.params[0].Filter.Type = \"Workspace\"\n #self.params[0].Filter.List = [\"FileSystem\", \"LocalDatabase\", \"RemoteDatabase\"]\n #\n\n \n self.params[5].Value = 2.0 # OFFSETA\n self.params[6].Value = 0.0 # OFFSETB\n \n self.params[7].Value = 0.0 # RADIUS1\n self.params[8].Value = 1000.0 # RADIUS2\n \n self.params[9].Filter.Type = \"Range\" \n self.params[9].Filter.List = [0.0,360.0]\n self.params[9].Value = 0.0 # AZIMUTH1\n \n self.params[10].Filter.Type = \"Range\"\n self.params[10].Filter.List = [0.0,360.0]\n self.params[10].Value = 360.0 # AZIMUTH2\n \n self.params[11].Filter.Type = \"Range\"\n self.params[11].Filter.List = [-90.0,90.0]\n self.params[11].Value = 90.0 # VERT1\n \n self.params[12].Filter.Type = \"Range\"\n self.params[12].Filter.List = [-90.0,90.0]\n self.params[12].Value = -90.0 # VERT2\n\n # setting output parameter schema\n self.params[14].Schema.ExtentRule = \"Union\"\n self.params[14].Schema.FeatureTypeRule = \"AsSpecified\"\n self.params[14].Schema.FeatureType = \"Simple\"\n self.params[14].Schema.GeometryTypeRule = \"AsSpecified\"\n self.params[14].Schema.GeometryType = \"Point\"\n self.params[14].Schema.FieldsRule = \"All\" \n #spot_field = self.makeField(\"SPOT\", \"DOUBLE\", \"8\", \"4\", \"12\")\n offseta_field = self.makeField(\"OFFSETA\", \"DOUBLE\", \"8\", \"4\", \"12\")\n offsetb_field = self.makeField(\"OFFSETB\", \"DOUBLE\", \"8\", \"4\", \"12\")\n vert1_field = self.makeField(\"VERT1\", \"DOUBLE\", \"8\", \"4\", \"12\")\n vert2_field = self.makeField(\"VERT2\", \"DOUBLE\", \"8\", \"4\", \"12\")\n azimuth1_field = self.makeField(\"AZIMUTH1\", \"DOUBLE\", \"8\", \"4\", \"12\")\n azimuth2_field = self.makeField(\"AZIMUTH2\", \"DOUBLE\", \"8\", \"4\", \"12\")\n radius1_field = self.makeField(\"RADIUS1\", \"DOUBLE\", \"8\", \"4\", \"12\")\n radius2_field = self.makeField(\"RADIUS2\", \"DOUBLE\", \"8\", \"4\", \"12\")\n field_list = [offseta_field,offsetb_field,vert1_field,vert2_field,azimuth1_field,azimuth2_field,radius1_field,radius2_field]\n self.params[14].Schema.AdditionalFields = field_list\n\n return","def setup_method(self):\n self.x0 = (1.0, [1.0, 1.0])\n self.sol = (-0.195, np.array([-0.195, -0.1]))\n\n self.tol = 3 # number of decimal places\n\n self.niter = 100\n self.disp = False\n\n # fix random seed\n np.random.seed(1234)\n\n self.kwargs = {\"method\": \"L-BFGS-B\", \"jac\": True}\n self.kwargs_nograd = {\"method\": \"L-BFGS-B\"}","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"Afb[0.6,-0.7,0.7]\");\n self.modelBuilder.doVar(\"A0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doSet(\"POI\",\"Afb,A0\")\n\n # ss templates\n self.modelBuilder.doVar(\"R_ee_os_fakes[0.6,0.0,1.0]\");\n self.modelBuilder.doVar(\"ee16_fakes_norm[1.0, 0.01, 10.]\");\n self.modelBuilder.doVar(\"ee17_fakes_norm[1.0, 0.01, 10.]\");\n self.modelBuilder.doVar(\"ee18_fakes_norm[1.0, 0.01, 10.]\");\n #Remember, cant use spaces in these formulas!\n #self.modelBuilder.options.verbose = 10\n self.modelBuilder.factory_('expr::R_ee16_qcd_os(\"@0*@1\",ee16_fakes_norm,R_ee_os_fakes)')\n self.modelBuilder.factory_('expr::R_ee17_qcd_os(\"@0*@1\",ee17_fakes_norm,R_ee_os_fakes)')\n self.modelBuilder.factory_('expr::R_ee18_qcd_os(\"@0*@1\",ee18_fakes_norm,R_ee_os_fakes)')\n self.modelBuilder.factory_('expr::R_ee16_qcd_ss(\"@0*(1.0-@1)\",ee16_fakes_norm,R_ee_os_fakes)')\n self.modelBuilder.factory_('expr::R_ee17_qcd_ss(\"@0*(1.0-@1)\",ee17_fakes_norm,R_ee_os_fakes)')\n self.modelBuilder.factory_('expr::R_ee18_qcd_ss(\"@0*(1.0-@1)\",ee18_fakes_norm,R_ee_os_fakes)')\n \n self.modelBuilder.factory_('expr::Alph(\"2.0*@0/(2.0-@0)\",A0)')\n self.modelBuilder.factory_('expr::Norm(\"3.0/4.0/(2.0+@0)\",Alph)')\n self.modelBuilder.factory_('expr::RAlph(\"@0*@1\",Alph,Norm)')\n self.modelBuilder.factory_('expr::Rpl(\"(@0+@1)\",Norm,Afb)')\n self.modelBuilder.factory_('expr::Rmn(\"(@0-@1)\",Norm,Afb)')","def projection(self):\n pass","def main():\n # start_time = time.time()\n\n # city: (latitude, longtitude) +/- 0.5 degree\n # geocenter for EU: 50 9\n cities = {\n 'Vienna': (48, 16),\n 'Brussels': (51, 4),\n 'Sofia': (43, 23),\n 'Zagreb': (46, 16),\n 'Nicosia': (35, 33),\n 'Prague': (50, 14),\n 'Copenhagen': (55, 13),\n 'Tallinn': (59, 25),\n 'Helsinki': (60, 25),\n 'Paris': (49, 2),\n 'Berlin': (53, 13),\n 'Athens': (38, 24),\n 'Budapest': (48, 19),\n 'Dublin': (53, -6),\n 'Rome': (42, 13),\n 'Riga': (57, 24),\n 'Vilnius': (55, 25),\n 'Luxembourg': (50, 6),\n 'Valletta': (36, 15),\n 'Amsterdam': (52, 5),\n 'Warsaw': (52, 21),\n 'Lisbon': (39, -9),\n 'Bucharest': (44, 26),\n 'Bratislava': (48, 17),\n 'Ljubljana': (46, 15),\n 'Madrid': (40, -4),\n 'Stockholm': (59, 18),\n 'London': (52, 0)\n }\n\n cities = OrderedDict(sorted(cities.items(), key=lambda t: t[0]))\n cities_indices = [x for x in range(len(cities))]\n cities_names = [key for key in cities.keys()]\n\n for key, value in cities.items():\n nu_v = hf.equirectangular_projection(\n value[0], value[1], phi_0=50, l_0=9)\n cities[key] = nu_v\n\n decoder = {value: key for (key, value) in cities.items()}\n\n ga.cities = cities\n # ga.cities_names = cities_names\n # ga.cities_indices = cities_indices\n param_names = ['v1', 'v2', 't', 'n', 'pm', 'pc', 'tournsize', 'size']\n f = open('params.txt', 'r')\n param_values = [float(l) if '.' in l else int(l) for l in f]\n f.close()\n params = dict(zip(param_names, param_values))\n\n ga.Salesman.diploid = True\n starters = ga.mfp(params['size'])\n v1 = params['v1'] # velocity 1 in Poland\n v2 = params['v2'] # velocity 2 in Poland\n t = params['t'] # period of change of velocity in Poland\n n = params['n'] # number of generations\n pm = params['pm'] # probabilty of mutation (per gene)\n pc = params['pc'] # probability of crossover\n tournsize = params['tournsize']\n\n start_time = time.time()\n salesmen = starters\n ga.Salesman.velocity_pol = v1\n path_s = ga.findbest(salesmen).fitness\n print('first population best: ' + str(round(1 / path_s, 2)) + ' hours')\n\n results = [[0, path_s]]\n counter = 0\n for i in range(n):\n if counter == t // 2 - 1:\n ga.Salesman.velocity_pol = v1 if ga.Salesman.velocity_pol == v2 \\\n else v2\n counter = 0\n counter += 1\n salesmen = ga.evolution(salesmen, pm, pc, tournsize)\n path = ga.findbest(salesmen).fitness\n results.append([i + 1, path])\n\n path_d = ga.findbest(salesmen).fitness\n path_d_seq = ga.findbest(salesmen).best_seq\n print(str(n) + '-th population best (diploidal): ' +\n str(round(1 / path_d, 2)) + ' hours')\n print([decoder[x] for x in path_d_seq])\n print(\"Time elapsed: \" + str(time.time() - start_time) + 's')\n\n start_time = time.time()\n salesmen = starters\n ga.Salesman.diploid = False\n ga.Salesman.velocity_pol = v1\n\n results2 = [[0, path_s]]\n counter = 0\n for i in range(n):\n if counter == t // 2 - 1:\n ga.Salesman.velocity_pol = v1 if ga.Salesman.velocity_pol == v2 \\\n else v2\n counter = 0\n counter += 1\n salesmen = ga.evolution(salesmen, pm, pc, tournsize)\n path = ga.findbest(salesmen).fitness\n results2.append([i + 1, path])\n\n path_h = ga.findbest(salesmen).fitness\n path_h_seq = ga.findbest(salesmen).city_seq\n print(str(n) + '-th population best (haploidal): ' +\n str(round(1 / path_h, 2)) + ' hours')\n print([decoder[x] for x in path_h_seq])\n print(\"Time elapsed: \" + str(time.time() - start_time) + 's')\n\n # plot fitnesses:\n results = np.asarray(results)\n results2 = np.asarray(results2)\n plt.plot(results[:, 0], results[:, 1], 'b-', label='diploidal')\n plt.plot(results2[:, 0], results2[:, 1], 'g-', label='haploidal')\n plt.legend(loc=4)\n plt.show()\n\n # plot paths:\n fig, ax = plt.subplots(1)\n\n starters_best_seq = ga.findbest(starters).city_seq\n starters_best_seq += [starters_best_seq[0]] # close the loop\n starters_best_seq = np.asarray(starters_best_seq)\n plt.plot(starters_best_seq[:, 0], starters_best_seq[:, 1], 'r-', alpha=0.2)\n\n labels = cities_indices\n cities = np.asarray(list(ga.cities.values()))\n\n plt.scatter(cities[:, 0], cities[:, 1], color='r')\n for label, x, y in zip(labels, cities[:, 0], cities[:, 1]):\n plt.annotate(label, xy=(x, y), xytext=(-6, -12),\n textcoords='offset points')\n poland_c = hf.equirectangular_projection(52, 19, 50, 9)\n poland = plt.Circle(poland_c, .047, color='r', alpha=0.3)\n ax.add_artist(poland)\n\n path_d_seq = path_d_seq + [path_d_seq[0]]\n path_d_seq = np.asarray(path_d_seq)\n\n path_h_seq = path_h_seq + [path_h_seq[0]]\n path_h_seq = np.asarray(path_h_seq)\n\n plt.plot(path_h_seq[:, 0],\n path_h_seq[:, 1], 'g-', label='haploidal')\n plt.plot(path_d_seq[:, 0],\n path_d_seq[:, 1], 'b-', label='diploidal')\n\n legend = \"Legend:\\n\"\n legend += \"\\n\".join([str(ii) + ': ' + name\n for ii, name in enumerate(cities_names)])\n props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n ax.text(-0.15, 0.95, legend,\n transform=ax.transAxes,\n fontsize=14, verticalalignment='top', bbox=props)\n\n plt.axis('off')\n plt.legend(loc=4)\n plt.show()","def __init__(self, nb):\n\n # Approximation parameters\n self.o_min = -.1\n self.o_max = .1\n self.o_nb = nb\n self.o_bw = (self.o_max - self.o_min) / self.o_nb\n self.o_e = np.linspace(self.o_min, self.o_max, self.o_nb+1)\n self.o = self.o_e[:-1] + (self.o_bw/2)\n self.r_e = [0, 1]\n self.r_nb = len(self.r_e)\n self.mu_min = 0\n self.mu_max = 1\n self.mu_nb = nb\n self.mu_bw = (self.mu_max - self.mu_min) / self.mu_nb\n self.mu_e = np.linspace(self.mu_min, self.mu_max, self.mu_nb+1)\n self.mu = self.mu_e[:-1] + (self.mu_bw/2)\n self.p_s_giv_o_hat = np.nan\n self.S = np.nan\n self.p_mu_giv_r_o_hat = np.nan","def __init__(self,x=0.1,E=10.0, mpar={}, topchem='He', topden=1.78e-4, botchem='Sr50Cl100H110493.721O55246.86', botden=1.0032, element='Sr', line='Ka1', vslit= 0.04, detlen=10.5, qoff=0.0, yscale=1,int_bg=0, Rc=0, sur_den=0,ion_depth=0):\n if type(x)==list:\n self.x=np.array(x)\n else:\n self.x=x\n self.E=E\n self.__mpar__ = mpar\n self.topchem = topchem\n self.topden = topden\n self.botchem = botchem\n self.botden = botden\n self.element = element\n self.line = line\n self.vslit = vslit\n self.detlen = detlen\n self.qoff = qoff\n self.yscale = yscale\n self.int_bg = int_bg\n self.Rc = Rc\n self.sur_den = sur_den\n self.ion_depth = ion_depth\n elelist = xdb.atomic_symbols\n linelist = list(xdb.xray_lines(98).keys())\n self.choices={'element':elelist,'line': linelist} #If there are choices available for any fixed parameters\n self.output_params = {}\n self.init_params()\n self.__fit__=False\n self.__avoganum__ = scipy.constants.Avogadro\n self.__eleradius__ = scipy.constants.physical_constants['classical electron radius'][0]*1e10 #classic electron radius in \\AA","def getDefaultParams():\n defpar = [\n # coordinate system\n ['crd_sys', \"'sph'\", 'Coordinate system'],\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\n ['ny', '[10,30, 30, 10]',\n 'Number of grid points in the second dimension'],\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\n 'Number of radial grid points'],\n ['nz', '[361]', 'Number of grid points in the third dimension'],\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\n # star related\n ['tstar', '[3900.0]', 'Temperature of star'],\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\n ['rstar', '[2.5*rs]', 'Radius of star'],\n # gas density \n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \n ['ring_r', '[50*au]', 'location of gaussian ring'], \n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \n ['cutgdens', '1e-30', 'cut for density'], \n ['Rt', '100*au', 'radius for scale height'], \n ['Ht', '10*au', 'scale height'], \n ['qheight', '1.25', 'height power-law'], \n # gas species\n ['gasspec_mol_name', \"['12co']\", 'name of molecule'],\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\n ['gasspec_mol_dbase_type', \"['leiden']\", ''],\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\n # dust density\n # flat power-law parts\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\n # Lynden-Bell parts\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \n ['dLB_sig0', '[1e2]', 'surface density'], \n # ring parts\n ['dring_r', '[50*au]', 'location of gaussian ring'],\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\n ['cutddens', '1e-30', 'cut for dust density'],\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \n ['dHt', '[10*au]', 'scale height for each grain size'], \n ['dqheight', '[1.25]', 'scale height power-law for dust'], \n # temperature\n ['T0mid', '50', 'mid plane temperature at Rt'],\n ['T0atm', '50', 'atmosphere temperature at Rt'],\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\n ['qmid', '-0.5', 'midplane temperature exponent'],\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\n ['hdel', '2', 'temperature transition exponent '],\n ['cuttemp', '10', 'temperature cut'], \n # alignment\n ['altype', \"'toroidal'\", 'alignment type']\n ]\n\n return defpar","def doParametersOfInterest(self):\n ''' ref : physicsmodel -> rvf\n self.modelBuilder.out.var(\"MH\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\n self.modelBuilder.out.var(\"MH\").setConstant(False)\n '''\n\n self.modelBuilder.doVar(\"mu[0,0,1000]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doVar(\"Fvbf[0,0,1]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu,Fvbf\")\n self.modelBuilder.doVar(\"\")\n self.modelBuilder.factory_('expr::ggH_s_func(\"(@0-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_b_func(\"(1-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\"sqrt(@0)*(1.-@1)\", mu,Fvbf)')\n\n self.modelBuilder.factory_('expr::vbfH_s_func(\"(@0-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\"(1-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\"sqrt(@0)*(@1)\", mu,Fvbf)')","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def constant_2015():\n\n #Load the CMIP6 historical\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\n #Get low and high level emissions just in the last year (2014)\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\n final_cubes = iris.cube.CubeList()\n for cube in cubes:\n final_cube = cube[-12:]\n final_cubes.append(final_cube)\n \n #Set the year-on-year proportional reductions to be nothing\n yoy_rates = calc_perc_reducts()\n yoy_rates = np.array(yoy_rates)\n yoy_rates = np.ones_like(yoy_rates)\n\n #Create coordinates for new nc file between 2014 and 2100\n lat_coord = cubes[0].coord('latitude')\n lon_coord = cubes[0].coord('longitude')\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\n\n #Create the cube date\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\n #Set first year equal to 2014 in CMIP6 historical\n cube_data_surf[:12,...] = final_cubes[0].data\n cube_data_high[:12,...] = final_cubes[1].data\n #Apply equal emissions in all other years too\n for i in range(12,cube_data_surf.shape[0]):\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\n #Make the output cubes\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\n\n fut_cube_high.var_name = 'field569_1'\n fut_cube_high.units='kg/m2/s'\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\n fut_cube_surf.var_name = 'field569'\n fut_cube_surf.units='kg/m2/s'\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\n\n #Load the DMS cube from standard RCP2.6\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\n\n dms_cube.var_name = 'field570'\n dms_cube.attributes.pop('name')\n dms_cube.coord('time').var_name = 'time'\n dms_cube.coord('time').long_name = 'time'\n\n fut_cube_high = fut_cube_high[:-2]\n fut_cube_surf = fut_cube_surf[:-2]\n\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\n\n #Save the final cubes as netcdf (cutting them to be the same length)\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \"SO2DMS_const2014.nc\")\n os.system('ncatted -O -a calendar,time,m,c,\"360_day\" '+data_dir+ \"SO2DMS_const2014.nc\")\n\n return","def __init__(self, size=60, n=2, gamma=10, limit=15):\n self.n = n\n self.gamma = gamma\n self.limit = limit\n self.a = (1 / gamma) / (gamma - 1)\n\n x = np.arange(size)\n #endpoint=True breaks the plot of curve, \n #but allows work with [0, 1], not [0, 1) \n self.coord = []\n for i in x:\n for j in x:\n result = psi.inner_function((i / size, j / size), gamma, n)[0] \n self.coord.append((i, j, result))\n self.coord.sort(key=lambda x: x[2])\n self.x = np.array([i[0] for i in self.coord])\n self.y = np.array([i[1] for i in self.coord])","def _projections(self, nvar):\n min_var = self.proje_var.argsort()[:nvar]\n add_coeffs = 1 / self.proje_var[min_var]\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\n np.sum(add_coeffs)\n\n # consider covariance\n coverr = []\n try:\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\n coverr.append(1/np.sum(proje_cov_inv))\n except:\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\n cov_est_proje[:] = np.nan\n coverr.append(np.nan)\n return np.array([indp_est_proje, cov_est_proje])","def __init__(self, D, NP, nFES, nRuns, useAlgorithms, useBenchmarks, **kwargs):\n\t\tself.D = D\n\t\tself.NP = NP\n\t\tself.nFES = nFES\n\t\tself.nRuns = nRuns\n\t\tself.useAlgorithms = useAlgorithms\n\t\tself.useBenchmarks = useBenchmarks\n\t\tself.A = kwargs.get('A', 0.5)\n\t\tself.r = kwargs.get('r', 0.5)\n\t\tself.Qmin = kwargs.get('Qmin', 0.0)\n\t\tself.Qmax = kwargs.get('Qmax', 2.0)\n\t\tself.Pa = kwargs.get('Pa', 0.25)\n\t\tself.F = kwargs.get('F', 0.5)\n\t\tself.CR = kwargs.get('CR', 0.9)\n\t\tself.alpha = kwargs.get('alpha', 0.5)\n\t\tself.betamin = kwargs.get('betamin', 0.2)\n\t\tself.gamma = kwargs.get('gamma', 1.0)\n\t\tself.p = kwargs.get('p', 0.5)\n\t\tself.Ts = kwargs.get('Ts', 4)\n\t\tself.Mr = kwargs.get('Mr', 0.05)\n\t\tself.C1 = kwargs.get('C1', 2.0)\n\t\tself.C2 = kwargs.get('C2', 2.0)\n\t\tself.w = kwargs.get('w', 0.7)\n\t\tself.vMin = kwargs.get('vMin', -4)\n\t\tself.vMax = kwargs.get('vMax', 4)\n\t\tself.Tao = kwargs.get('Tao', 0.1)\n\t\tself.n = kwargs.get('n', 10)\n\t\tself.omega = kwargs.get('omega', 0.25)\n\t\tself.mu = kwargs.get('mu', 0.5)\n\t\tself.E_init = kwargs.get('E_init', 10)\n\t\tself.S_init = kwargs.get('S_init', 10)\n\t\tself.T_min = kwargs.get('T_min', -10)\n\t\tself.T_max = kwargs.get('T_max', 10)\n\t\tself.C_a = kwargs.get('C_a', 2)\n\t\tself.C_r = kwargs.get('C_r', 0.5)\n\t\tself.results = {}","def getcoor(im, win = \"get coordinates\", updatefunc=drawcoorpoints, prox=8, radius = 3, unique=True, col_out=black,col_in=red):\n # functions\n def getcoor_drawstats(self,points,col_out=black,col_in=green,radius=2):\n \"\"\"\n\n :param self:\n :param points:\n :param col_out:\n :param col_in:\n :param radius:\n :return:\n \"\"\"\n vis = self.rimg\n p = imcoors(points)\n self.data2 = np.zeros((vis.shape[0],vis.shape[1],1),dtype=np.uint8)\n drawcooraxes(vis,[p.boxCenter],col_out,col_in,radius)\n drawcooraxes(self.data2,[p.boxCenter],1,1,self.prox)\n drawcooraxes(vis,[p.mean],col_in,col_out,radius)\n drawcooraxes(self.data2,[p.mean],2,2,self.prox)\n p1 = imcoors(self.coors)\n self.mapdata2 = [None,\"center at \"+str(p1.boxCenter),\"mean at \"+str(p1.mean)]\n\n def getcoor_updatecoors(self):\n \"\"\"\n\n :param self:\n :return:\n \"\"\"\n self.coorlen = len(self.coors)\n self.updaterenderer()\n if self.coors != []:\n self.rcoors = self.coors[:]\n newc = self.coors[:]\n for j,i in enumerate(self.coors):\n newc[j] = self.real2render(i[0],i[1])\n self.rcoors[j] = limitaxispoints(newc[j],10000,-10000)\n if self.showstats:\n getcoor_drawstats(self,newc,radius=self.radius)\n self.rimg = self.updatefunc(self.rimg,newc,self.col_out,self.col_in,self.radius)\n else:\n self.data2[:] = 0\n self.coordinateText = [[\"xy({self.x},{self.y})\"]]\n\n def getcoor_mouse(self):\n \"\"\"\n\n :param self:\n :return:\n \"\"\"\n # control system\n controlled = self.builtincontrol()\n drawed = False\n\n # get nearest coordinate to pointer\n isnear = False\n if self.coors != [] and self.rx is not None and self.ry is not None:\n # vals = anorm(np.int32(self.coors) - (self.x, self.y)) # relative to real coordinates\n vals = anorm(np.int32(self.rcoors) - (self.rx, self.ry)) # relative to rendered coordinates\n near_point = np.logical_and(vals < self.prox, vals == np.min(vals))\n if np.any(near_point): # if near point\n idx = np.where(near_point)[0] # get index\n isnear = True\n val = self.coors[idx[0]]\n count = self.coors.count(val)\n self.coordinateText = [[\"point \"+str(idx[0])+\" at \"+str(val)+\"x\"+str(count)]]\n else:\n self.coordinateText = [[\"xy({self.x},{self.y})\"]]\n\n # coordinate system\n if not controlled and bool(self.flags):\n if self.event== cv2.EVENT_RBUTTONDBLCLK: # if middle button DELETE ALL COORDINATES\n self.coors = []\n self.img = self.data.copy()\n drawed = True\n elif isnear and self.event== cv2.EVENT_RBUTTONDOWN: # if right button DELETE NEAREST COORDINATE\n self.coors.pop(idx[0]) # if more than one point delete first\n drawed = True\n elif self.event== cv2.EVENT_LBUTTONDOWN: # if left button ADD COORDINATE\n val = (self.x,self.y)\n if not self.coors.count(val) or not self.unique:\n self.coors.append(val)\n drawed = True\n\n # update renderer\n if (controlled or drawed):\n getcoor_updatecoors(self)\n\n if self.y is not None and self.x is not None:\n if self.showstats:\n data = self.mapdata2[self.data2[self.ry,self.rx]]\n if not isnear and data is not None:\n self.coordinateText = [[data]]\n self.builtinplot(self.data[self.y,self.x])\n\n if type(im) is plotim:\n self = im\n else:\n self = plotim(win,im)\n # assign functions\n self.mousefunc = getcoor_mouse\n self.updatefunc = updatefunc\n self.userupdatefunc = updatefunc\n self.prox = prox # proximity to keypoint\n # initialize user variables\n self.radius = radius\n self.unique = unique\n self.col_out = col_out\n self.col_in = col_in\n # initialize control variables\n self.interpolation=cv2.INTER_AREA\n self.coors = []\n self.rcoors = []\n self.coorlen = 0\n self.showstats = False\n self.mapdata2 = [None,None,None]\n self.data2 = np.zeros((self.rH,self.rW,1),dtype=np.uint8)\n self.updatecoors = getcoor_updatecoors\n self.drawcooraxes = drawcooraxes\n self.drawcoorperspective = drawcoorperspective\n self.drawcoorpolyline = drawcoorpolyline\n self.drawcoorpoints = drawcoorpoints\n self.controlText[0].extend([\" No. coordinates: {self.coorlen}. \"])\n self.cmdeval.update({\"points\":\"self.updatefunc = self.drawcoorpoints\",\n \"polyline\":\"self.updatefunc = self.drawcoorpolyline\",\n \"perspective\":\"self.updatefunc = self.drawcoorperspective\",\n \"axes\":\"self.updatefunc = self.drawcooraxes\",\n \"user\":\"self.updatefunc = self.userupdatefunc\",\n \"end\":[\"self.getcoor_updatecoors(self)\",\"self.mousefunc(self)\"]})\n self.cmdlist.extend([\"unique\",\"showstats\",\"user\",\"points\",\"polyline\",\"perspective\",\"axes\"])\n # show window\n self.show()\n return self.coors # return coordinates","def problem3():\n t = np.array([-27.1, -2.9, -3.2])\n principal_point = np.array([8, -10])\n focal_length = 8\n\n # model transformations\n T = gettranslation(t)\n Ry = getyrotation(135)\n Rx = getxrotation(-30)\n Rz = getzrotation(90)\n print(T)\n print(Ry)\n print(Rx)\n print(Rz)\n\n K = getcentralprojection(principal_point, focal_length)\n\n P,M = getfullprojection(T, Rx, Ry, Rz, K)\n print(P)\n print(M)\n\n points = loadpoints()\n displaypoints2d(points)\n\n z = loadz()\n Xt = invertprojection(K, points, z)\n\n Xh = inverttransformation(M, Xt)\n\n worldpoints = hom2cart(Xh)\n displaypoints3d(worldpoints)\n\n points2 = projectpoints(P, worldpoints)\n displaypoints2d(points2)\n\n plt.show()","def GEEnasaNEXGDDP(ptsFile,metric,timeStep,startYear,endYear,scenarios,buf,poly,username,folderOut,models = ['ACCESS1-0', 'bcc-csm1-1', 'BNU-ESM',\n 'CanESM2', 'CCSM4', 'CESM1-BGC', 'CNRM-CM5', 'CSIRO-Mk3-6-0',\n 'GFDL-CM3', 'GFDL-ESM2G', 'GFDL-ESM2M', 'inmcm4', 'IPSL-CM5A-LR',\n 'IPSL-CM5A-MR', 'MIROC-ESM', 'MIROC-ESM-CHEM', 'MIROC5', 'MPI-ESM-LR',\n 'MPI-ESM-MR', 'MRI-CGCM3', 'NorESM1-M'], scalePix = 25000):\n \n # load required libraries\n import ee\n\n # Initialize the Earth Engine object, using the authentication credentials.\n ee.Initialize()\n\n ID_field = \"geeID\"\n\n #load pts or poly file\n pts1 = ee.FeatureCollection('users/' + username + '/' + str(ptsFile))\n\n time_d = {}\n time_d['day'] = 'projd'\n time_d['month'] = 'projm'\n time_d['year'] = 'projy'\n \n for met in metric:\n\n for scenario in scenarios:\n\n for model in models:\n\n NEX = (ee.ImageCollection('NASA/NEX-GDDP')\n .select(met)\n .filterMetadata('model', 'equals', model)\n .filterMetadata('scenario', 'equals', scenario))\n\n metL = [met]\n \n years = list(range(startYear, endYear + 1))\n monthsEE = ee.List(list(range(0,(12*len(years)))))\n yearsEE = ee.List(years)\n\n######Turned off unit conversion, because it fails when there are too many pts\n## if (met == 'pr'):\n##\n## def Scale1(img):\n## return (img.float()\n## .multiply(86400)\n## .copyProperties(img,['system:time_start','system:time_end']))\n##\n## NEX = NEX0.map(Scale1)\n## \n## elif any([(met == 'tasmin'),(met == 'tasmax')]):\n##\n## def KtoC(img):\n## return (img.float()\n## .subtract(273.15)\n## .copyProperties(img,['system:time_start','system:time_end']))\n##\n## NEX = NEX0.map(KtoC)\n \n if all([(timeStep == 'year'),any([(met == 'tasmin'),(met == 'tasmax')])]):\n\n def map_m(i):\n i = ee.Number(i).int()\n image2 = (NEX\n .filter(ee.Filter.calendarRange(i, i, 'year'))\n .first())\n filtered = (NEX\n .filter(ee.Filter.calendarRange(i, i, 'year'))\n .mean()\n .copyProperties(image2,['system:time_start','system:time_end']))\n return filtered\n\n img_col = ee.ImageCollection(yearsEE.map(map_m).flatten())\n\n elif all([(timeStep == 'month'),any([(met == 'tasmin'),(met == 'tasmax')])]):\n \n def map_m(i):\n i = ee.Number(i)\n y = i.divide(12).add(years[0]).int()\n m = i.mod(12).add(1)\n image2 = (NEX\n .filter(ee.Filter.calendarRange(m, m, 'month'))\n .filter(ee.Filter.calendarRange(y, y, 'year'))\n .first())\n filtered = (NEX\n .filter(ee.Filter.calendarRange(m, m, 'month'))\n .filter(ee.Filter.calendarRange(y, y, 'year'))\n .mean()\n .copyProperties(image2,['system:time_start','system:time_end']))\n return filtered\n\n img_col = ee.ImageCollection(monthsEE.map(map_m).flatten())\n\n elif all([(timeStep == 'year'),(met == 'pr')]):\n\n def map_m(i):\n i = ee.Number(i).int()\n image2 = (NEX\n .filter(ee.Filter.calendarRange(i, i, 'year'))\n .first())\n filtered = (NEX\n .filter(ee.Filter.calendarRange(i, i, 'year'))\n .sum()\n .copyProperties(image2,['system:time_start','system:time_end']))\n return filtered\n\n img_col = ee.ImageCollection(yearsEE.map(map_m).flatten())\n\n elif all([(timeStep == 'month'),(met == 'pr')]):\n \n def map_m(i):\n i = ee.Number(i)\n y = i.divide(12).add(years[0]).int()\n m = i.mod(12).add(1)\n image2 = (NEX\n .filter(ee.Filter.calendarRange(m, m, 'month'))\n .filter(ee.Filter.calendarRange(y, y, 'year'))\n .first())\n filtered = (NEX\n .filter(ee.Filter.calendarRange(m, m, 'month'))\n .filter(ee.Filter.calendarRange(y, y, 'year'))\n .sum()\n .copyProperties(image2,['system:time_start','system:time_end']))\n return filtered\n\n img_col = ee.ImageCollection(monthsEE.map(map_m).flatten())\n\n elif timeStep == 'day':\n\n img_col = NEX.filter(ee.Filter.calendarRange(startYear, endYear, 'year'))\n\n #else:\n #print(\"incorrect time step specified\")\n \n if buf > 0:\n bufL = [buf]\n def bufferPoly(feature):\n return feature.buffer(bufL[0])\n\n ptsB = pts1.map(bufferPoly)\n def table_m(image):\n table = (image\n .select(metL[0])\n .reduceRegions(collection = ptsB.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_ptsB',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n \n #print ('buffered pts by:' + str(buf) + ' for NEX: ' + met + ' ' + scenario + ' ' + model)\n\n elif poly > 0:\n \n def table_m(image):\n table = (image\n .select(metL[0])\n .reduceRegions(collection = pts1.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_poly1',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n \n #print ('spatial mean in poly: no buffer for NEX: ' + met + ' ' + scenario + ' ' + model)\n\n else:\n def table_m(image):\n table = (image\n .select(metL[0])\n .reduceRegions(collection = pts1.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_pts1',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n #print('value at point: no buffer for NEX: ' + met + ' ' + scenario + ' ' + model)","def __init__(self, Rect0=(0,0),Rect1=(1,1),Qw=1000,Qe=(250,250,250,250),h=10,phi=0.2):\n #Cornor Points\n self.Pts=[(Rect0[0],Rect0[1]),(Rect0[0],Rect1[1]),(Rect1[0],Rect1[1]),(Rect1[0],Rect0[1])]\n \n #Center Well\n self.Pts.append(((Rect0[0]+Rect1[0])/2,(Rect0[1]+Rect1[1])/2) )\n \n self.Qw=Qw\n self.Qe=Qe\n self.Qe_int=np.zeros(4)\n self.h=h\n self.phi=phi\n self.theta=[np.pi/2,np.pi/2,np.pi/2,np.pi/2]\n \n #Subgrid\n self.SubGrids=[]\n self.NeighborID=[(1,3),(2,0),(3,1),(0,2)]\n \n #Streamline\n self.SL=[]\n self.TOF=[]","def __setup_parameters__(self):\r\n self.M=self.N+1\r\n self.u=1+self.pu\r\n self.d=1-self.pd\r\n self.qu=(math.exp((self.r-self.div)*self.dt)-self.d)/(self.u-self.d)\r\n self.qd=1-self.qu","def sol549(design_parameters, phi_0, N):\r\n prt('Design governing by this mantras (in oder of importance): \\nsize, stall margin, cost, off-design', 'blue')\r\n n = 0\r\n m = 0\r\n phi_f = phi_0*1.2\r\n N_lineal_phi = int(0.4 * N)\r\n step = (phi_f-phi_0)/(N_lineal_phi-1)\r\n phi_dist = [float_f(phi_0+i*step, 4) for i in range(N_lineal_phi)] + [float_f(phi_f, 4) for i in range(N_lineal_phi, N)]\r\n phi_dist = Distribution(phi_dist)\r\n N_lineal_R = int(0.3 * N)\r\n R_0 = 0.7\r\n R_f = 0.65\r\n step = (R_f - R_0) / (N_lineal_R - 1)\r\n R_dist = [float_f(R_0+i*step, 4) for i in range(N_lineal_R)] + [float_f(R_f, 4) for i in range(N_lineal_R, N)]\r\n R_dist = Distribution(R_dist)\r\n\r\n Kc = 1-0.5*design_parameters[1]\r\n psi_dist = Distribution(psi_limit(phi_dist, R_dist, Kc))\r\n if inlet_angle_flow(phi_dist,psi_dist,R_dist):\r\n pass\r\n\r\n return phi_dist, psi_dist, R_dist, n,m","def observables(p0,pl0,e0,rho0,nb0,derivatives,E,Pl,Rho,Nb):\r\n global g , pmin\r\n y = array([p0,0,0,0,0,0,0])\r\n r = 0 ; dr = rk_step\r\n\r\n while not isinstance(y[0],complex):\r\n l = y[6]\r\n dy = derivatives(r,y,E,Pl,Rho,Nb)\r\n if y[0] + dy[0]*rk_max_step <= pmin or Pl(y[0]) <= 0 : break\r\n if r >= max_radius :\r\n print(\"Too many iterations\")\r\n return None\r\n y , r , dr = rk(derivatives,r,y,dr,atol,rtol,rk_max_step,rk_min_step,E,Pl,Rho,Nb)\r\n \r\n return [p0/g , pl0/g, e0 /g, rho0 , r , l, nb0 ]","def set_parameters(self, par):\n try:\n for l in self.cell.layers:\n r_curve = cmf.VanGenuchtenMualem(\n Ksat=10**par.pKsat, phi=par.porosity, alpha=par.alpha, n=par.n\n )\n r_curve.w0 = r_curve.fit_w0()\n l.soil = r_curve\n self.cell.saturated_depth = 0.5\n self.gw.potential = self.cell.z - 0.5\n except RuntimeError as e:\n sys.stderr.write(\"Set parameters failed with:\\n\" + str(par) + \"\\n\" + str(e))\n raise","def call_odeint(particle_object,dt,omega):\n \n# print \n# print '##########################'\n# \n r = particle_object.position\n v = particle_object.velocity \n beta = particle_object.beta \n# \n# print 'Initial parameters'\n# print 'r', r\n# print 'v', v\n# print 'beta',beta\n# print \n# beta = 0.15\n #particle_radius = particle_object.radius\n \n# ### updating the acceleration due to planet history with the position value before it is moved so that it is the acceleration due to the planet at the position that led to this nett acceleration. \n# particle_object.update_planet_acceleration_history(AccelerationDueToPlanet(r))\n \n u0 = np.array([r[0],r[1],r[2],v[0],v[1],v[2]])\n \n \n sol = odeint(acceleration_for_odeint, u0, np.array([0,dt]), args=(beta, omega,planet_pos)) ## The solution in the from [rx,ry,rz,vx,vy,vz]\n \n r_new = np.array([sol[1,0],sol[1,1],sol[1,2]])\n v_new = np.array([sol[1,3],sol[1,4],sol[1,5]]) \n \n# print 'New parameters'\n# print 'r', r_new\n# print 'v', v_new\n#\n# print \n \n #particle_object.update_position(r_new) \n #particle_object.update_velocity(v_new)\n \n ### add one to the particle's age \n particle_object.update_age() \n particle_object.update_timestep_history(timestep)\n \n #last_uvect = sol[1,:]\n \n #return last_uvect\n \n #return 0,0\n return r_new,v_new","def OrbitCom(galaxy, start, end, n=5):\n \n # compose the filename for output\n fileout = \"Orbit_\"+galaxy+\".txt\"\n \n # set tolerance and VolDec for calculating COM_P in CenterOfMass\n # for M33 that is stripped more, use different values for VolDec\n \n if (galaxy == 'M33'):\n delta = 0.1\n VolDec=4\n \n else:\n delta = 0.1\n VolDec = 2\n\n \n # generate the snapshot id sequence \n # it is always a good idea to also check if the input is eligible (not required)\n snap_ids = np.arange(start, end+1, step=n)\n \n \n # initialize the array for orbital info: t, x, y, z, vx, vy, vz of COM\n \n orbit = np.zeros((snap_ids.size, 7))\n \n # a for loop \n for i, snap_id in enumerate(snap_ids):\n \n # compose the data filename (be careful about the folder)\n # inputs to recontruct the filenumber to the value \"000\"\n ilbl = '000' + str(snap_id)\n # remove all but the last 3 digits\n ilbl = ilbl[-3:]\n filename = \"%s_\"%(galaxy) + ilbl + '.txt'\n \n # Initialize an instance of CenterOfMass class, using disk particles\n \n COM = CenterOfMass(filename, 2)\n\n # Store the COM pos and vel. Remember that now COM_P required VolDec\n COM_P = COM.COM_P(delta, VolDec)\n COM_V = COM.COM_V(COM_P[0],COM_P[1],COM_P[2])\n\n \n # store the time, pos, vel in ith element of the orbit array, without units (.value) \n # note that you can store \n # a[i] = var1, *tuple(array1)\n \n orbit[i] = COM.time.value/1000, *tuple(COM_P.value), *tuple(COM_V.value)\n \n # print snap_id to see the progress\n print(snap_id)\n \n # write the data to a 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 per galaxy.\n np.savetxt(fileout, orbit, fmt = \"%11.3f\"*7, comments='#',\n header=\"{:>10s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}\"\\\n .format('t', 'x', 'y', 'z', 'vx', 'vy', 'vz'))","def __call__(self):\n #Check source type and sensor type, then call appripriate methods to \n #generate intermediate data, cascading all the way back to geometry \n #calculation if it wasn't already done.\n #Then return a projection matrix...\n\n # NOTE: returned projection_matrix is a numpy.ndarray\n if isinstance(self.sensors, sensors_module.SensorsEEG):\n projection_matrix = self.eeg_gain()\n elif isinstance(self.sensors, sensors_module.SensorsMEG):\n projection_matrix = self.meg_gain()\n\n return projection_matrix","def set_params_proj(ima, p, xform = \"xform.projection\"):\n\tfrom EMAN2 import Vec2f\n\tt = Transform({\"type\":\"spider\",\"phi\":p[0],\"theta\":p[1],\"psi\":p[2]})\n\tt.set_trans(Vec2f(-p[3], -p[4]))\n\tima.set_attr(xform, t)","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"Afb[0.6,-0.75,0.75]\");\n self.modelBuilder.doVar(\"A0[0.05, -1.0, 1.0]\");\n self.modelBuilder.doSet(\"POI\",\"Afb,A0\")\n\n \n self.modelBuilder.factory_('expr::Alph(\"2.0*@0/(2.0-@0)\",A0)')\n self.modelBuilder.factory_('expr::Norm(\"3.0/4.0/(2.0+@0)\",Alph)')\n self.modelBuilder.factory_('expr::RAlph(\"@0*@1\",Alph,Norm)')\n self.modelBuilder.factory_('expr::Rpl(\"(@0+@1)\",Norm,Afb)')\n self.modelBuilder.factory_('expr::Rmn(\"(@0-@1)\",Norm,Afb)')","def test_project(self):\n import itertools\n from numpy import array, dot\n from numpy.linalg import det\n\n # our little magic constant\n magic = 0.33377777373737737777\n\n # test for all kinds of curvatures K\n for k in (0, 1, -1, 1/11, -1/11, 1 + magic, -1 - magic):\n \n s = space(curvature=k)\n\n # test line preserving projection\n # 3 points are colinear when\n # | x1 y1 1 |\n # | x2 y2 1 | = 0\n # | x3 y3 1 |\n # let's test this!\n\n for p, q in itertools.permutations((\n (1, 0),\n (3/5, 4/5),\n (-5/13, 12/13),\n (-8/17, -15/17),\n ), 2):\n p = s.make_point(p, magic)\n q = s.make_point(q, magic)\n u = p.project(projection_types.preserve_lines)\n v = (p+q).project(projection_types.preserve_lines)\n w = (p+(-magic)*q).project(projection_types.preserve_lines)\n d = det([[*u, 1],[*v, 1],[*w, 1]])\n self.assertTrue(abs(d) < 1e-9)\n\n # test angle preserving projection\n # map will be conformal, so we do like a secant test\n\n delta = 1e-9\n vi = s.make_point((1, 0, 0), delta)\n vj = s.make_point((0, 1, 0), delta)\n vk = s.make_point((0, 0, 1), delta)\n for p in (\n (1, 0, 0),\n (0, 3/5, 4/5),\n (-5/13, 12/13, 0),\n (2/11, 6/11, 9/11),\n (3/7, 6/7, 2/7)\n ):\n p = s.make_point(p, magic)\n pp = p.project(projection_types.preserve_angles)\n pi, pj, pk = (array((p+v).project(projection_types.preserve_angles)) - pp for v in (vi, vj, vk))\n # should stay orthogonal and same size\n # note that we're doing a secant thing so it's only approximate\n # thus we set a relatively high tolerance\n self.assertTrue(isclose(\n dot(pi, pi),\n dot(pj, pj),\n rel_tol = 1e-6\n ))\n self.assertTrue(isclose(\n dot(pi, pi),\n dot(pk, pk),\n rel_tol = 1e-6\n ))\n self.assertTrue(isclose(\n dot(pi, pj),\n 0,\n abs_tol = 1e-6\n ))\n self.assertTrue(isclose(\n dot(pi, pk),\n 0,\n abs_tol = 1e-6\n ))\n self.assertTrue(isclose(\n dot(pj, pk),\n 0,\n abs_tol = 1e-6\n ))","def awGrid(vis,HA,uvw,image_params,obs_params,Mterms,Mterms_ij):\t\n\tStokes = image_params['Stokes']\n\t\n\n\n\tprint '--------------Gridding X pol--------------------'\n\txgrid_wt, xgrid_uv = gridOnePolAWproj(vis[0],HA,uvw,image_params,obs_params,Mterms[0],Mterms_ij[0])\n\tprint '--------------Gridding Y pol--------------------'\n\tygrid_wt, ygrid_uv = gridOnePolAWproj(vis[1],HA,uvw,image_params,obs_params,Mterms[1],Mterms_ij[1])\n\n\tN = np.shape(xgrid_wt)[0]\n\tgrid_uv = np.zeros([N, N], dtype=complex)\n\tgrid_wt = np.zeros([N, N], dtype=complex)\n\t\n\tif Stokes == 'I':\n\t\t#combine X and Y gridded vis to create the I pol gridded vis\n\t\t# I = (XX+YY)/2\n\t\tgrid_uv.real = (ygrid_uv.real + xgrid_uv.real)/2\n\t\tgrid_uv.imag = (ygrid_uv.imag + xgrid_uv.imag)/2\n\n\t\t#combine X and Y gridded wt to create the I pol gridded wt\n\t\tgrid_wt.real = (ygrid_wt.real + xgrid_wt.real)/2\n\t\tgrid_wt.imag = (ygrid_wt.imag + xgrid_wt.imag)/2\n\n\telif Stokes == 'Q':\n\t\t#combine X and Y gridded vis to create the I pol gridded vis\n\t\t# Q = (XX-YY)/2\n\t\tgrid_uv.real = (ygrid_uv.real - xgrid_uv.real)/2\n\t\tgrid_uv.imag = (ygrid_uv.imag - xgrid_uv.imag)/2\n\n\t\t#combine X and Y gridded wt to create the I pol gridded wt\n\t\tgrid_wt.real = (ygrid_wt.real - xgrid_wt.real)/2\n\t\tgrid_wt.imag = (ygrid_wt.imag - xgrid_wt.imag)/2\n\n\n\tdty_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_uv)))\n\tpsf_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_wt)))\n\n\treturn dty_image, psf_image","def exo2():","def __init__(self, gridname=None, verbose=False):\n self.gridname = gridname\n g = re.match(r'(EASE2_[NST])([0-9\\.]+)km', gridname)\n if g is None:\n print(\"%s : error parsing gridname %s\" % (__name__, gridname),\n file=sys.stderr,\n flush=True)\n raise ValueError\n projection = g.group(1)\n resolution = g.group(2)\n\n # Check for typos in resolution\n if resolution not in resolutions:\n print(\"%s : unrecognized resolution %s\" % (__name__, resolution),\n file=sys.stderr,\n flush=True)\n raise ValueError\n\n # The geotransform information\n # is the set of GDAL affine transform parameters:\n # (map_UL_x, scale_x, b, map_UL_y, d, scale_y)\n if projection == \"EASE2_N\":\n # The geotransform is the set of GDAL affine transform parameters:\n # (map_UL_x, scale_x, b, map_UL_y, d, scale_y)\n self.proj4text = \"+proj=laea +lat_0=90 +lon_0=0 \" + \\\n \"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\"\n self.map_UL_x = -9000000.\n self.map_UL_y = 9000000.\n self.b = 0.\n self.d = 0.\n self.scale_x = float(resolution) * m_per_km\n self.scale_y = -1 * float(resolution) * m_per_km\n\n elif projection == \"EASE2_S\":\n self.proj4text = \"+proj=laea +lat_0=-90 +lon_0=0 \" + \\\n \"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\"\n self.map_UL_x = -9000000.\n self.map_UL_y = 9000000.\n self.b = 0.\n self.d = 0.\n self.scale_x = float(resolution) * m_per_km\n self.scale_y = -1 * float(resolution) * m_per_km\n\n elif projection == \"EASE2_T\":\n self.proj4text = \"+proj=cea +lat_0=0 +lon_0=0 +lat_ts=30 \" \\\n \"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\"\n self.map_UL_x = -17367530.44\n self.map_UL_y = 6756820.20000\n self.b = 0.\n self.d = 0.\n base_resolution_m = 25025.26000\n factor = resolutions.index(resolution)\n self.scale_x = base_resolution_m / (2. ** factor)\n self.scale_y = -1 * base_resolution_m / (2. ** factor)\n\n else:\n print(\"%s : unrecognized projection %s\" % (__name__, projection),\n file=sys.stderr,\n flush=True)\n raise ValueError\n\n # Thanks to affine help pages at\n # https://github.com/sgillies/affine/blob/master/README.rst\n # http://www.perrygeo.com/python-affine-transforms.html\n geotransform = (self.map_UL_x + self.scale_x / 2.,\n self.scale_x,\n self.b,\n self.map_UL_y + self.scale_y / 2.,\n self.d,\n self.scale_y)\n self.fwd = Affine.from_gdal(*geotransform)\n\n # Initialize and save coordinate transformation\n # for this projection\n self.gridSpatialRef = osr.SpatialReference()\n self.gridSpatialRef.SetFromUserInput(self.proj4text)\n\n # Initialize and save coordinate transformation\n # for EPSG4326 (lat/lon)\n self.epsg4326SpatialRef = osr.SpatialReference()\n self.epsg4326SpatialRef.SetFromUserInput(self.epsg4326Proj4text)\n\n # Initialize and save the forward and reverse transformations\n self.projToGeog = osr.CoordinateTransformation(\n self.gridSpatialRef, self.epsg4326SpatialRef)\n self.geogToProj = osr.CoordinateTransformation(\n self.epsg4326SpatialRef, self.gridSpatialRef)\n\n if verbose:\n print(\"%s : initialized new Ease2Transform object\" % (__name__),\n file=sys.stderr,\n flush=True)","def gen_plan_params(self, n):\r\n n = self.gen_input_check(n)\r\n # generate samples of semi-major axis\r\n ar = self.arange.to(\"AU\").value\r\n # check if constrainOrbits == True for eccentricity\r\n if self.constrainOrbits:\r\n # restrict semi-major axis limits\r\n arcon = np.array(\r\n [ar[0] / (1.0 - self.erange[0]), ar[1] / (1.0 + self.erange[0])]\r\n )\r\n a = (\r\n np.exp(\r\n np.random.uniform(\r\n low=np.log(arcon[0]), high=np.log(arcon[1]), size=n\r\n )\r\n )\r\n * u.AU\r\n )\r\n tmpa = a.to(\"AU\").value\r\n # upper limit for eccentricity given sma\r\n elim = np.zeros(len(a))\r\n amean = np.mean(ar)\r\n elim[tmpa <= amean] = 1.0 - ar[0] / tmpa[tmpa <= amean]\r\n elim[tmpa > amean] = ar[1] / tmpa[tmpa > amean] - 1.0\r\n elim[elim > self.erange[1]] = self.erange[1]\r\n elim[elim < self.erange[0]] = self.erange[0]\r\n\r\n # uniform distribution\r\n e = np.random.uniform(low=self.erange[0], high=elim, size=n)\r\n else:\r\n a = (\r\n np.exp(np.random.uniform(low=np.log(ar[0]), high=np.log(ar[1]), size=n))\r\n * u.AU\r\n )\r\n e = np.random.uniform(low=self.erange[0], high=self.erange[1], size=n)\r\n\r\n # generate geometric albedo\r\n pr = self.prange\r\n p = np.random.uniform(low=pr[0], high=pr[1], size=n)\r\n # generate planetary radius\r\n Rpr = self.Rprange.to(\"earthRad\").value\r\n Rp = (\r\n np.exp(np.random.uniform(low=np.log(Rpr[0]), high=np.log(Rpr[1]), size=n))\r\n * u.earthRad\r\n )\r\n\r\n return a, e, p, Rp","def __init__(self, random_org_parameters, composition_space, constraints):\n\n self.name = 'random organism creator'\n\n # defaults\n #\n # number of random organisms to make (only used for epa searches)\n self.default_number = 28\n # max number of atoms\n if composition_space.objective_function == 'epa':\n # make sure we can sample cells with two formula units\n target_number = constraints.min_num_atoms + 6\n num_formulas = target_number/composition_space.endpoints[\n 0].num_atoms\n if num_formulas < 2:\n min_of_max = int(2*composition_space.endpoints[0].num_atoms)\n else:\n min_of_max = int(round(\n num_formulas)*composition_space.endpoints[0].num_atoms)\n else:\n min_of_max = constraints.min_num_atoms + 6\n self.default_max_num_atoms = min(min_of_max, constraints.max_num_atoms)\n # allow structure with compositions at the endpoints (for pd searches)\n self.default_allow_endpoints = True\n # volume scaling behavior\n # default volumes per atom of elemental ground state structures\n # computed from structures on materials project (materialsproject.org)\n self.all_default_vpas = {'H': 13.89, 'He': 15.79, 'Li': 20.12,\n 'Be': 7.94, 'B': 7.25, 'C': 10.58,\n 'N': 42.73, 'O': 13.46, 'F': 16.00,\n 'Ne': 19.93, 'Na': 37.12, 'Mg': 23.04,\n 'Al': 16.47, 'Si': 20.44, 'P': 23.93,\n 'S': 36.03, 'Cl': 34.90, 'Ar': 44.87,\n 'K': 73.51, 'Ca': 42.42, 'Sc': 24.64,\n 'Ti': 17.11, 'V': 13.41, 'Cr': 11.57,\n 'Mn': 11.04, 'Fe': 11.55, 'Co': 10.92,\n 'Ni': 10.79, 'Cu': 11.82, 'Zn': 15.56,\n 'Ga': 20.34, 'Ge': 23.92, 'As': 22.45,\n 'Se': 38.13, 'Br': 37.53, 'Kr': 65.09,\n 'Rb': 90.44, 'Sr': 54.88, 'Y': 32.85,\n 'Zr': 23.50, 'Nb': 18.31, 'Mo': 15.89,\n 'Tc': 14.59, 'Ru': 13.94, 'Rh': 14.25,\n 'Pd': 15.45, 'Ag': 18.00, 'Cd': 23.28,\n 'In': 27.56, 'Sn': 36.70, 'Sb': 31.78,\n 'Te': 35.03, 'I': 50.34, 'Xe': 83.51,\n 'Cs': 116.17, 'Ba': 63.64, 'Hf': 22.50,\n 'Ta': 18.25, 'W': 16.19, 'Re': 15.06,\n 'Os': 14.36, 'Ir': 14.55, 'Pt': 15.72,\n 'Au': 18.14, 'Hg': 31.45, 'Tl': 31.13,\n 'Pb': 32.30, 'Bi': 36.60, 'La': 37.15,\n 'Ce': 26.30, 'Pr': 36.47, 'Nd': 35.44,\n 'Pm': 34.58, 'Sm': 33.88, 'Eu': 46.28,\n 'Gd': 33.33, 'Tb': 32.09, 'Dy': 31.57,\n 'Ho': 31.45, 'Er': 30.90, 'Tm': 30.30,\n 'Yb': 40.45, 'Lu': 29.43, 'Ac': 45.52,\n 'Th': 32.03, 'Pa': 25.21, 'U': 19.98,\n 'Np': 18.43, 'Pu': 18.34}\n\n self.default_vpas = self.get_default_vpas(composition_space)\n\n # set to defaults\n if random_org_parameters in (None, 'default'):\n self.number = self.default_number\n self.max_num_atoms = self.default_max_num_atoms\n self.allow_endpoints = self.default_allow_endpoints\n self.vpas = self.default_vpas\n # parse the parameters and set to defaults if necessary\n else:\n # the number to make\n if 'number' not in random_org_parameters:\n self.number = self.default_number\n elif random_org_parameters['number'] in (None, 'default'):\n self.number = self.default_number\n else:\n self.number = random_org_parameters['number']\n\n # the max number of atoms\n if 'max_num_atoms' not in random_org_parameters:\n self.max_num_atoms = self.default_max_num_atoms\n elif random_org_parameters['max_num_atoms'] in (None, 'default'):\n self.max_num_atoms = self.default_max_num_atoms\n elif random_org_parameters['max_num_atoms'] > \\\n constraints.max_num_atoms:\n print('The value passed to the \"max_num_atoms\" keyword in the '\n 'InitialPopulation block may not exceed the value passed'\n ' to the \"max_num_atoms\" keyword in the Constraints '\n 'block.')\n print('Quitting...')\n quit()\n elif random_org_parameters['max_num_atoms'] < \\\n constraints.min_num_atoms:\n print('The value passed to the \"max_num_atoms\" keyword in the '\n 'InitialPopulation block may not be smaller than the '\n 'value passed to the \"min_num_atoms\" keyword in the '\n 'Constraints block.')\n print('Quitting...')\n quit()\n else:\n self.max_num_atoms = random_org_parameters['max_num_atoms']\n\n # allowing composition space endpoints (only used for pd searches)\n if 'allow_endpoints' not in random_org_parameters:\n self.allow_endpoints = self.default_allow_endpoints\n elif random_org_parameters['allow_endpoints'] in (None, 'default'):\n self.allow_endpoints = self.default_allow_endpoints\n else:\n self.allow_endpoints = random_org_parameters['allow_endpoints']\n\n # volume scaling\n self.vpas = self.default_vpas\n if 'volumes_per_atom' not in random_org_parameters:\n pass\n elif random_org_parameters['volumes_per_atom'] in (None,\n 'default'):\n pass\n else:\n # replace the specified volumes per atom with the given values\n for symbol in random_org_parameters['volumes_per_atom']:\n self.vpas[symbol] = random_org_parameters[\n 'volumes_per_atom'][symbol]\n\n self.num_made = 0 # number added to initial population\n self.is_successes_based = True # it's based on number added\n self.is_finished = False","def ParameterFitness(self,planet_params):\n\t\t\n\t\ttFinal = self.Observations.tFinal() + np.max(self.Observations.PeriodEstimates)\n\t\n\t\t# Full 3-D input\n\t\tif len(planet_params.reshape(-1))== 7 * self.Observations.nplanets:\n\t\t\ttransits,success = self.MCMC_Param_TransitTimes(planet_params,tFinal)\n\t\n\t\t# Nodes relative to inner planet node inputs\n\t\telif len(planet_params.reshape(-1)) == 7 * self.Observations.nplanets - 1:\n\t\t\ttransits,success = self.MCMC_RelativeNodeParam_TransitTimes(planet_params,tFinal)\n\t\n\t\t# All inclinations = 90 deg. only nodes of non-first planet vary\n\t\telif len(planet_params.reshape(-1)) == 6 * self.Observations.nplanets:\n\t\t\ttransits,success = self.MCMC_NodeOnlyParam_TransitTimes(planet_params,tFinal)\n\n\t\t# All coplanar\n\t\telif len(planet_params.reshape(-1)) == 5 * self.Observations.nplanets :\n\t\t\ttransits,success = self.MCMC_CoplanarParam_TransitTimes(planet_params,tFinal)\n\t\telse:\n\t\t\traise ValueError(\"Bad input dimensions: %d \"%(len(planet_params.reshape(-1))))\n\t\t\n\t\tif not success:\n\t\t\treturn -np.inf\n\t\ttry:\n\t\t\ttransit_list = [ transits[i][nums] for i,nums in enumerate(self.Observations.transit_numbers) ]\n\t\texcept:\n\t\t\t# If the number of computed transits is less than the number of observed transits\n\t\t\t#\tthen -infinity should be returned\n\t\t\treturn -np.inf\n\t\t\t\n\t\t\t\n\t\tchi2 = self.Observations.get_chi2(transit_list)\n\t\treturn - 0.5 * chi2","def get_params_proj(ima, xform = \"xform.projection\"):\n\tt = ima.get_attr(xform)\n\td = t.get_params(\"spider\")\n\treturn d[\"phi\"],d[\"theta\"],d[\"psi\"],-d[\"tx\"],-d[\"ty\"]","def runSimulation(self, R=5000, N=1,s=1000, method='RL'):\n global n_ec\n import numpy as np\n import matplotlib.pyplot as plt\n import matplotlib\n matplotlib.use('Agg')\n matplotlib.pyplot.switch_backend('agg')\n\n plt.rcParams.update({'font.size':20})\n plt.rc('xtick', labelsize=20)\n plt.rc('ytick', labelsize=20)\n # step = 2 fs\n # each round is 2 fs * 1000 = 2 ps\n\n init = 'ala2_1stFrame.pdb' #pdb name\n inits = init\n n_ec = 2 # angles\n count = 1\n newPoints_name = 'start_r_'+str(count)+'.pdb'\n \n #W_0 = [1/n_ec for i in range(n_ec)] # no direction\n #W_0 = [[0.25, 0.25], [0.25, 0.25]]\n W_0 = [[1/(2*n_ec), 1/(2*n_ec)] for i in range(n_ec)] # directional\n print(W_0)\n\n Ws = []\n Ws.append(W_0)\n \n trj1 = self.run(production_steps = s, start=inits, production='trj_R_0.pdb') # return mdtraj object\n comb_trj1 = trj1 # single trajectory\n trjs = comb_trj1\n trj1_theta = self.map_angles(trj1) # changed for angles to display\n print('trj1_theta', len(trj1_theta), len(trj1_theta[0]))\n trj1_Ps_theta, index = self.PreSamp(trj1_theta, myn_clusters = 10) # pre analysis (least count)\n trj1_Ps_w_theta, index_w = self.PreSamp(trj1_theta, myn_clusters = 100) # for updating the weights\n print('trj1_Ps_theta', len(trj1_Ps_theta), len(trj1_Ps_theta[0]))\n\n newPoints_index_orig = self.findStarting(trj1_Ps_theta, index, W_0, starting_n = N , method = 'RL') #need change\n newPoints = trj1[newPoints_index_orig[0]]\n newPoints.save_pdb(newPoints_name)\n \n \n print('trj1_theta[0]',trj1_theta[0])\n plt.scatter(trj1_theta[0], trj1_theta[1], color='dodgerblue', s=5, alpha=0.2)\n plt.xlim([-180, 180])\n plt.ylim([-180, 180])\n newPoints_theta_x = trj1_theta[0][newPoints_index_orig[0]]\n newPoints_theta_y = trj1_theta[1][newPoints_index_orig[0]]\n plt.scatter(newPoints_theta_x, newPoints_theta_y, color='red', s=50)\n plt.xlabel(r'$\\phi$')\n plt.ylabel(r'$\\psi$')\n plt.savefig('fig_'+str(count))\n plt.close()\n trjs_theta = trj1_theta\n trjs_Ps_theta = trj1_Ps_theta\n trjs_Ps_w_theta = trj1_Ps_w_theta \n for round in range(R):\n self.updateStat(trjs_theta) # based on all trajectories\n #W_1 = self.updateW(trjs_Ps_theta, W_0) \n W_1 = self.updateW(trjs_Ps_w_theta, W_0) \n W_0 = W_1\n W_1 = W_0\n Ws.append(W_0)\n s = 1000\n trj1 = self.run(production_steps = s, start=newPoints_name, production='trj_R_'+str(count)+'.pdb') # return mdtraj object\n com_trjs = trjs.join(trj1) \n trjs = com_trjs\n trjs_theta = np.array(self.map_angles(trjs)) \n trjs_Ps_theta, index = self.PreSamp(trjs_theta, myn_clusters = 100)\n myn_clusters1 = 100 #int(10*(round)+1)\n trjs_Ps_w_theta = trjs_Ps_theta\n #trjs_Ps_w_theta, index_w = self.PreSamp(trjs_theta, myn_clusters = myn_clusters1)\n newPoints_index_orig = self.findStarting(trjs_Ps_theta, index, W_1, starting_n = N , method = 'RL')\n newPoints = trjs[newPoints_index_orig[0]] \n \n count = count + 1\n newPoints_name = 'start_r_'+str(count)+'.pdb'\n newPoints.save_pdb(newPoints_name)\n\n print( myn_clusters1, W_1, self.theta_mean)\n plt.scatter(trjs_theta[0], trjs_theta[1], color='dodgerblue', s=5, alpha=0.2)\n plt.xlim([-np.pi, np.pi])\n plt.ylim([-np.pi, np.pi])\n newPoints_theta_x = trjs_theta[0][newPoints_index_orig[0]]\n newPoints_theta_y = trjs_theta[1][newPoints_index_orig[0]]\n plt.scatter(newPoints_theta_x, newPoints_theta_y, color='red', s=50)\n plt.scatter(trjs_Ps_w_theta[0], trjs_Ps_w_theta[1], color='green', s=5)\n plt.xlabel(r'$\\phi$')\n plt.ylabel(r'$\\psi$')\n plt.savefig('fig_'+str(count))\n plt.close()\n \n np.save('w_'+'r'+str(int(R))+'N'+str(N)+'s'+str(s), Ws)\n np.save('trjs_theta', trjs_theta)\n return","def __init__(self,SO,d_dimp,rd_dimp,N_e,N_a):\n self.sphere = SO;\n self.d_dimp = d_dimp;\n self.rd_dimp = rd_dimp;\n self.N_e = N_e;\n self.N_a = N_a;","def __init__(self, espectro, Npicos):\r\n self.Npicos = Npicos\r\n self.spec = espectro.real\r\n self.ppmGridDir = espectro.ppmGridDir\r\n self.ppmGridInd = espectro.ppmGridInd \r\n self.regiones = self.crear_regiones(Npicos)\r\n self.integrales = None","def get_problem():\n\n #User Defined Terrain Elevation\n #def terr( x_pos, y_pos ):\n #Defines terrain elevation [m] as a function of x and y positions [m]\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\n # return elev\n\n #User Defined Tunnel Cost\n #def tunnel(depth):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #depth below the ground.\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\n # return TunnelCost\n\n #def bridge(height):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #heigh above the ground.\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\n # return BridgeCost\n\n # Rename this and/or move to optim package?\n problem = beluga.optim.Problem('surftest_noinc')\n\n #Define independent variables\n problem.independent('t', 's')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','m') \\\n .state('y','V*sin(hdg)','m') \\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\n .state('hdg','cmax/V*sin(hdgA)','rad')\n\n # Define controls\n #problem.control('thrA','rad') \\\n # .control('hdgA','rad')\n problem.control('hdgA','rad')\n\n # Define Cost Functional\n problem.cost['path'] = Expression('1','s')\n\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\n\n #+ \\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\n\n #Define constraints\n problem.constraints().initial('x-x_0','m') \\\n .initial('y-y_0','m') \\\n .initial('V-V_0','m/s') \\\n .initial('hdg-hdg_0','rad') \\\n .terminal('x-x_f','m') \\\n .terminal('y-y_f','m')\n #.terminal('V-V_f','m/s')\n #.initial('hdg-hdg_0','rad') \\\n\n #Define constants\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\n problem.constant('eps',10,'m/s^2') #Error constant\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\n problem.constant('thrA',0,'rad')\n\n #Unit scaling\n problem.scale.unit('m','x') \\\n .unit('s','x/V') \\\n .unit('rad',1) \\\n .unit('USD',1)\n\n #Configure solver\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\n\n #Initial Guess\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\n\n #Add Continuation Steps\n problem.steps.add_step().num_cases(10) \\\n .terminal('x', 10) \\\n .terminal('y', 0)\n\n problem.steps.add_step().num_cases(10) \\\n .const('eps', 0.2)\n\n #problem.steps.add_step().num_cases(10) \\\n # .terminal('y', 2*pi*1000) \\\n # .terminal('z', 0.0) \\\n # .terminal('inc', 0.0)\n #^ City B\n return problem","def __init__(self,):\r\n self.g = 9.81\r\n self.l = 0.5\r\n self.m1 = 1.0\r\n self.m2 = 1.0\r\n self.m3 = 1.0\r\n self.r1 = 1.0\r\n self.r2 = 1.0\r\n self.tau = 0.001\r\n self.theta1 = 1.0\r\n self.theta2 = 1.0\r\n self.theta3 = 1.0","def prj(self,method):\n valid_methods={\"max\",\"sum\",\"mean\"}\n if method not in valid_methods:\n warnings.warn(\"Projection method is not valid, pick from following valid methods: {valid_methods}\", UserWarning)\n elif method==\"max\":\n self.maxprj=(np.amax(self.pixels,axis=0))\n elif method==\"sum\":\n self.sumprj=(np.sum(self.pixels,axis=0))\n elif method==\"mean\":\n self.meanprj=(np.mean(self.pixels,axis=0))","def project(self, X):","def project(self, X):","def solar_model():\n \n latitude, longitude, timezone, elevation = location_input()\n year, time = time_input()\n\n lat_r = latitude/180*np.pi\n lon_r = longitude/180*np.pi \n n = 0\n for i in range(1900,year):\n if i%4 == 0:\n n += 366\n else:\n n+=365\n JulD = n + time + 2415018.5 - (timezone)/24\n LT = time - int(time)\n JC = (JulD - 2451545) / 36525\n x = 46.815 + JC * (0.00059 - JC * 0.001813)\n M_OE = 23 + (26 + (21.448 - JC * x) / 60) / 60\n EEO = 0.016708634 - JC * (0.000042037 + 0.0000001267 * JC)\n GMAS = 357.52911 + JC * (35999.05029 - 0.0001537 * JC)\n GMAS_r = m.radians(GMAS)\n GMLS = (280.46646 + JC * (36000.76983 + JC * 0.0003032))%360\n GMLS_r = m.radians(GMLS)\n Obliq_C = M_OE + 0.00256 * np.cos((125.04 - 1934.136 * JC) / 180 * np.pi)\n Obliq_C_r = m.radians(Obliq_C)\n SEC = np.sin(GMAS_r) * (1.914602 - JC * (0.004817 + 0.000014 * JC)) + np.sin(2 * GMAS_r) * (0.019993 - 0.000101 * JC) + np.sin(3 * GMAS_r) * 0.000289\n STL = GMLS + SEC\n SAL = STL - 0.00569 - 0.00478 * np.sin((125.04 - 1934.136 * JC) / 180 * np.pi)\n SAL_r = m.radians(SAL)\n sin_Delta = np.sin(Obliq_C_r) * np.sin(SAL_r)\n Delta_r = np.arcsin(sin_Delta) #in radians \n Var_y = np.tan((Obliq_C / 2) / 180 * np.pi) * np.tan((Obliq_C / 2) / 180 * np.pi)\n EOT_prime = Var_y * np.sin(2 * GMLS_r) - 2 * EEO * np.sin(GMAS_r) + 4 * EEO * Var_y * np.sin(GMAS_r) * np.cos(2 * GMLS_r) - 0.5 * Var_y * Var_y * np.sin(4 * GMLS_r) - 1.25 * EEO * EEO * np.sin(2 * GMAS_r)\n EOT = 4 * EOT_prime / np.pi * 180 \n TST = (LT * 1440 + EOT + 4 * longitude - 60 * timezone)%1440\n if TST / 4 < 0:\n Omega = TST/4+180\n else:\n Omega = TST/4 - 180 \n Omega_r = m.radians(Omega)\n \n cos_Zenith = np.sin(lat_r) * np.sin(Delta_r) + np.cos(lat_r) * np.cos(Delta_r) * np.cos(Omega_r)\n Zenith_r = np.arccos(cos_Zenith) #in radians\n Aprime_r = np.arccos((np.sin(lat_r) * np.cos(Zenith_r) - np.sin(Delta_r)) / (np.cos(lat_r) * np.sin(Zenith_r)))\n Aprime = Aprime_r / np.pi * 180\n if Omega > 0:\n Azimuth = (Aprime + 180) % 360 #in degrees\n else:\n Azimuth = (540 - Aprime) % 360 #in degrees \n Azimuth_r = Azimuth / 180 * np.pi\n Elev_angle = (np.pi)/2 - Zenith_r\n\n \n # calculate incidence angle\n # Beta is equal to angle of tilted surface to horizontal (in radians)\n Beta = 45 # in degrees\n Beta_r = m.radians(Beta)\n \n cos_incidence = np.sin(Delta_r)* np.sin(lat_r) * np.cos(Beta_r) - np.sin(Delta_r) * np.cos(lat_r) * np.sin(Beta_r) * np.cos(Azimuth_r) + np.cos(Delta_r) * np.cos(lat_r) * np.cos(Beta_r) * np.cos(Omega_r) + np.cos(Delta_r) * np.sin(lat_r) * np.sin(Beta_r) * np.cos(Azimuth_r) * np.cos(Omega_r) + np.cos(Delta_r) * np.sin(Beta_r) * np.sin(Azimuth_r) * np.sin(Omega_r) \n incidence_ang_r = np.arccos(cos_incidence)\n \n return Delta_r, lat_r, Omega_r, Zenith_r, Azimuth_r, Elev_angle","def __init__(self, rp_dim:int,gamma,rp_method='Classical',rp_mode='Gaussian',solve_method='Exact'):\n self.rp_dim = rp_dim\n self.rp_method = rp_method\n self.rp_mode = rp_mode\n self.solve_method = solve_method\n if self.rp_method not in ['Classical', 'Hessian']:\n raise NotImplementedError('Only Classical and Hessian methods are supported.')\n if self.rp_mode not in ['Gaussian', 'SJLT']:\n raise NotImplementedError('Only Gaussian and SJLT modes are supported.')\n if self.solve_method not in ['Exact','ShiWoodbury']:\n raise NotImplementedError('Only Exact and ShiWoodbury methods are implemented')\n if not isinstance(gamma,list):\n self.gamma = [gamma]\n else:\n self.gamma = gamma","def __init__(self, ni, nj, nk):\n \n self.ni = ni\n self.nj = nj\n self.nk = nk\n \n self.nn = np.zeros(3)\n \n self.nn[0] = self.ni\n self.nn[1] = self.nj\n self.nn[2] = self.nk\n \n self.x0 = np.zeros(3)\n self.dh = np.zeros(3)\n self.xm = np.zeros(3)\n self.xc = np.zeros(3)\n \n self.EPS_0 = 8.85418782e-12\n self.QE = 1.602176565e-19;\n self.AMU = 1.660538921e-27\n self.ME = 9.10938215e-31;\n self.K = 1.380648e-23;\n self.EvToK = self.QE/self.K;\n \n self.phi = np.zeros((self.ni, self.nj, self.nk))\n self.phi_new = np.zeros((self.ni, self.nj, self.nk))\n self.R = np.zeros((self.ni, self.nj, self.nk))\n self.rho = np.zeros((self.ni, self.nj, self.nk))\n self.node_vol = np.zeros((self.ni, self.nj, self.nk))\n self.ef = np.zeros((self.ni, self.nj, self.nk, 3))","def new_param_energy_vac(coords, params, T=293.15):\n\n #-------------------\n # CONSTANTS\n #-------------------\n kB = 0.0083145 #Boltzmann constant (Gas constant) in kJ/(mol*K)\n beta = 1/(kB*T)\n\n #-------------------\n # PARAMETERS\n #-------------------\n params = params\n \n # Determine number of states we wish to estimate potential energies for\n mols = []\n for i in params:\n mols.append(i)\n mol = '../monomers/'+mols[0]+'.mol2'\n K = len(params[mols[0]].keys())\n\n\n #-------------\n # SYSTEM SETUP\n #-------------\n verbose = False # suppress echos from OEtoolkit functions\n ifs = oechem.oemolistream(mol)\n mol = oechem.OEMol()\n # This uses parm@frosst atom types, so make sure to use the forcefield-flavor reader\n flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield\n ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)\n oechem.OEReadMolecule(ifs, mol )\n # Perceive tripos types\n oechem.OETriposAtomNames(mol)\n\n # Load forcefield file\n #ffxml = 'smirnoff99Frosst_with_AllConstraints.ffxml'#\n #print('The forcefield being used is smirnoff99Frosst_with_AllConstraints.ffxml')\n ffxml = get_data_filename('forcefield/smirnoff99Frosst.ffxml')\n print('The forcefield being used is smirnoff99Frosst.ffxml')\n\n ff = ForceField(ffxml)\n\n # Generate a topology\n topology = generateTopologyFromOEMol(mol)\n\n #-----------------\n # MAIN\n #-----------------\n\n # Calculate energies\n\n E_kn = np.zeros([K,len(coords)],np.float64)\n u_kn = np.zeros([K,len(coords)],np.float64)\n for i,j in enumerate(params):\n AlkEthOH_id = j\n for k,l in enumerate(params[AlkEthOH_id]):\n print(\"Anotha one\")\n for m,n in enumerate(params[AlkEthOH_id][l]):\n newparams = ff.getParameter(smirks=n[0]) \n newparams[n[1]]=n[2]\n ff.setParameter(newparams,smirks=n[0])\n system = ff.createSystem(topology, [mol])\n #print(newparams)\n for o,p in enumerate(coords):\n e = get_energy_vac(system,p)\n E_kn[k,o] = e._value\n u_kn[k,o] = e._value*beta\n\n\n return E_kn,u_kn","def setup(self, method='dist', w=None, p=0.20, lamb=1e-2, n=32, s=20., ratio=0.1):\n # parameters for GREIT projection\n if w is None:\n w = np.ones_like(self.alpha)\n self.params = {\n 'w': w,\n 'p': p,\n 'lamb': lamb,\n 'n': n,\n 's': s,\n 'ratio': ratio\n }\n # action (currently only support 'dist')\n if method is 'dist':\n self.H = self._build_dist()\n else:\n raise ValueError('method ' + method + ' not supported yet')","def updateParameters(self, parameters):\r\n if parameters[0].altered:\r\n in_nc_file = parameters[0].valueAsText\r\n\r\n # Establish an object for reading the input NetCDF file\r\n ncFP = arcpy.NetCDFFileProperties(in_nc_file)\r\n\r\n # Loop through global variables in NetCDF file to gather projection information\r\n ncVarNames = ncFP.getVariablesByDimension('west_east')\r\n ncMassgridNames = []\r\n for x in ncVarNames:\r\n mgridvar = ncFP.getAttributeValue(x, 'stagger') # Only use variables on Massgrid for now ('M')\r\n if mgridvar == 'M':\r\n ncMassgridNames.append(x)\r\n parameters[1].filter.list = ncMassgridNames\r\n return","def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \"north\"):\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n\n mlatA = self.mlatA[inds]\n mlatB = self.mlatB[inds]\n mlatC = self.mlatC[inds]\n\n mean_range = 5\n NeA = self.meanie(NeA, mean_range)\n NeB = self.meanie(NeB, mean_range)\n NeC = self.meanie(NeC, mean_range)\n \n \n N = int((len(NeA)/n*2) - 1) #nr of windows\n \n dx = (secondsB[1]-secondsB[0])*self.velB[0]\n \n nBAs = []\n nBCs = []\n nACs = []\n \n for i in range(N):\n startind = int(i/2*n)\n stopind = int((i/2+1)*n)\n temp_NeA = NeA[startind:stopind]\n temp_NeB = NeB[startind:stopind]\n temp_NeC = NeC[startind:stopind]\n \n temp_secondsA = secondsA[startind:stopind]\n temp_secondsB = secondsB[startind:stopind]\n temp_secondsC = secondsC[startind:stopind]\n \n \n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\n if np.sum(curr_timediff) > 2:\n continue\n \n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\n \n if np.max(gradA) < 0.9:\n continue\n \n stdA = np.std(gradA)\n stdB = np.std(gradB)\n stdC = np.std(gradC)\n \n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\n \n p0A = [1, meanA, stdA]\n p0B = [1, meanB, stdB]\n p0C = [1, meanB, stdB]\n \n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\n \n nBA = poptB[1] - poptA[1]\n nBC = poptB[1] - poptC[1]\n nAC = poptA[1] - poptC[1]\n \n nBAs.append(nBA)\n nBCs.append(nBC)\n nACs.append(nAC)\n \n \n sBA = self.BA_shift/2 #time delay BA\n sBC = self.BC_shift/2 #time delay BC\n sAC = (self.BC_shift - self.BA_shift)/2\n V = self.velA[0]\n for i in range(len(nBAs)):\n VBA = self.along_track_velo(V, sBA, nBAs[i])\n VBC = self.along_track_velo(V, sBC, nBCs[i])\n VAC = self.along_track_velo(V, sAC, nACs[i])\n \n print(VBA)\n print(VBC)\n print(VAC)\n print(\"________________________________________\")","def solve(self):","def __init__(self, f, N_elements, C, D, analytical, grid_points):\n\n\n\n self.Ne = N_elements\n self.gp = grid_points\n self.C = C\n self.D = D\n self.f = lambda x: f(x)\n self.tol = 10e-4\n self.x = sym.Symbol(\"x\")\n\n self.h = 1/(2*self.Ne)\n self.global_matrix = np.zeros([2*self.Ne, 2*self.Ne])\n self.global_vector = np.zeros([2*self.Ne])\n self.psi = sym.zeros(3*self.Ne,1)\n\n self.analytical = lambda x,C,D: analytical(x,C,D)\n\n self.x_values = np.linspace(0,1,self.gp)","def projectionManip(*args, fitBBox: bool=True, projType: int=0, switchType: bool=True, q=True,\n query=True, **kwargs)->Union[None, Any]:\n pass","def __SetSFParams(self):\n\n # If radial structure functions are in output\n if self.__containsRadial:\n # Defines radial attributes\n self.__nc_RSoft_O.radial_error_tolerance = self.etol_radial\n\n # Defines radial dimensions\n self.__nc_RSoft_O.createDimension('radial_structure_functions',\\\n len(self.mus))\n\n # Defines radial variables\n mus_var_id_O = self.__nc_RSoft_O.createVariable('mus', \\\n 'f4', ('radial_structure_functions'))\n Ls_var_id_O = self.__nc_RSoft_O.createVariable('Ls', \\\n 'f4', ('radial_structure_functions'))\n radial_Xs_var_id_O = self.__nc_RSoft_O.createVariable(\\\n 'radial_Xs', 'i4', ('radial_structure_functions'))\n radial_Ys_var_id_O = self.__nc_RSoft_O.createVariable(\\\n 'radial_Ys', 'i4', ('radial_structure_functions'))\n\n # Sets radial structure function variables\n mus_var_id_O[:] = self.mus\n Ls_var_id_O[:] = self.Ls\n radial_Xs_var_id_O[:] = self.radial_Xs\n radial_Ys_var_id_O[:] = self.radial_Ys\n\n # If angular structure functions are in output\n if self.__containsAngular:\n # Defines angular attributes\n self.__nc_RSoft_O.angular_error_tolerance = self.etol_angular\n\n # Defines angular dimensions\n self.__nc_RSoft_O.createDimension('angular_structure_functions',\\\n len(self.xis))\n\n # Defines angular variables\n xis_var_id_O = self.__nc_RSoft_O.createVariable('xis', \\\n 'f4', ('angular_structure_functions'))\n zetas_var_id_O = self.__nc_RSoft_O.createVariable('zetas', \\\n 'i4', ('angular_structure_functions'))\n lambdas_var_id_O = self.__nc_RSoft_O.createVariable('lambdas', \\\n 'i4', ('angular_structure_functions'))\n angular_Xs_var_id_O = self.__nc_RSoft_O.createVariable(\\\n 'angular_Xs', 'i4', ('angular_structure_functions'))\n angular_Ys_var_id_O = self.__nc_RSoft_O.createVariable(\\\n 'angular_Ys', 'i4', ('angular_structure_functions'))\n angular_Zs_var_id_O = self.__nc_RSoft_O.createVariable(\\\n 'angular_Zs', 'i4', ('angular_structure_functions')) \n\n # Sets angular structure function variables\n xis_var_id_O[:] = self.xis\n zetas_var_id_O[:] = self.zetas\n lambdas_var_id_O[:] = self.lambdas\n angular_Xs_var_id_O[:] = self.angular_Xs\n angular_Ys_var_id_O[:] = self.angular_Ys\n angular_Zs_var_id_O[:] = self.angular_Zs","def doParametersOfInterest(self):\n self.modelBuilder.doVar(\"kappa_W[1,0.0,2.0]\") \n self.modelBuilder.doVar(\"kappa_Z[1,0.0,2.0]\") \n self.modelBuilder.doVar(\"kappa_tau[1,0.0,3.0]\")\n self.modelBuilder.doVar(\"kappa_mu[1,0.0,5.0]\") \n self.modelBuilder.factory_(\"expr::kappa_mu_expr(\\\"@0*@1+(1-@0)*@2\\\", CMS_use_kmu[0], kappa_mu, kappa_tau)\")\n self.modelBuilder.doVar(\"kappa_t[1,0.0,4.0]\")\n # additional kappa for the anomalous coupling\n self.modelBuilder.doVar(\"kappa_tilde_t[0.0,0.0,4.0]\")\n self.modelBuilder.doVar(\"kappa_b[1,0.0,3.0]\")\n if not self.resolved:\n self.modelBuilder.doVar(\"kappa_g[1,0.0,2.0]\")\n self.modelBuilder.doVar(\"kappa_gam[1,0.0,2.5]\")\n\tself.modelBuilder.doVar(\"BRinv[0,0,1]\")\n self.modelBuilder.out.var(\"BRinv\").setConstant(True)\n # adding additional kappa to list of parameters of interest\n pois = 'kappa_W,kappa_Z,kappa_tau,kappa_t,kappa_tilde_t,kappa_b'\n if not self.resolved:\n pois += ',kappa_g,kappa_gam'\n self.doMH()\n self.modelBuilder.doSet(\"POI\",pois)\n # use modified Higgs Builder\n self.SMH = AnomalousTopHiggsBuilder(self.modelBuilder)\n self.setup()","def geocube():","def parameters(self):","def iter_fun(self):\n\n run_id = self._run_id\n etopo_dir = driver_home\n topodir = driver_home\n\n # load input info\n if self._input_info == None:\n scn_fname = os.path.join(self._run_home,'scenario_pts.txt') \n scn = np.loadtxt(scn_fname)\n scn_list = scn.tolist()\n else:\n scn_list = self._input_info\n \n # total number of runs\n M = len(scn_list)\n N = 8*M + 2 # 8*M runs plus two empty bathymetry runs\n\n if run_id == N:\n raise StopIteration()\n\n else:\n \n #=========================\n # set coarse and fine grids\n #\n t_shelf = 0. # time approaching continental slope\n t_harbor = 0. # time approaching harbor\n\n if ((run_id >= 0) and (run_id < 4*M)) or (run_id == 8*M):\n #------------------\n # setrun for coarse\n #\n grid = 'coarse'\n \n self._rundata.amrdata.amr_levels_max = 4\n # coarse grid run = 10\"\n # dx = 30', 5', 1', 10\"\n self._rundata.amrdata.refinement_ratios_x = [6, 5, 6]\n self._rundata.amrdata.refinement_ratios_y = [6, 5, 6]\n self._rundata.amrdata.refinement_ratios_t = [6, 5, 6]\n\n\n # add topography (coarse)\n topofiles = self._rundata.topo_data.topofiles\n # for topography, append lines of the form\n # [topotype, minlevel, maxlevel, t1, t2, fname]\n topofiles = []\n\n topofiles.append([3, 1, 4, 0., 1.e10, \\\n os.path.join(etopo_dir, 'etopo1_-130_-124_38_45_1min.asc')])\n topofiles.append([-3, 3, 4, 0., 1.e10, \\\n os.path.join(topodir, 'cc-1sec.asc')])\n\n # add regions\n regions = self._rundata.regiondata.regions \n # between shelf and CC \n regions = []\n regions.append(\\\n [2, 3, t_shelf, 1e9, -125, -124.05, 40.5, 43]) \n regions.append(\\\n [3, 4, t_harbor, 1e9, -124.26, -124.14, 41.67, 41.79])\n regions.append(\\\n [4, 4, t_harbor, 1e9, -124.218,-124.17, 41.7345, 41.77])\n\n # == fgmax.data values ==\n fgmax_files = self._rundata.fgmax_data.fgmax_files\n fgmax_files = []\n \n # for fixed grids append to this list names of any fgmax input files\n fgmax1_fname = os.path.join(driver_home,'fgmax1_coarse.txt')\n fgmax2_fname = os.path.join(driver_home,'fgmax2_coarse.txt')\n fgmax3_fname = os.path.join(driver_home,'fgmax3_coarse.txt')\n\n fgmax_files.append(fgmax1_fname) \n fgmax_files.append(fgmax2_fname) \n fgmax_files.append(fgmax3_fname) \n \n self._rundata.fgmax_data.num_fgmax_val = 2\n \n \n elif ((run_id >= 4*M) and (run_id < 8*M)) or (run_id == 8*M+1):\n #----------------\n # setrun for fine\n #\n grid = 'fine'\n \n self._rundata.amrdata.amr_levels_max = 6\n\n ## fine grid run = 2/3\"\n ## dx = 30', 5', 1', 10\", 2\", 2/3\"\n self._rundata.amrdata.refinement_ratios_x = [6, 5, 6, 5, 3]\n self._rundata.amrdata.refinement_ratios_y = [6, 5, 6, 5, 3]\n self._rundata.amrdata.refinement_ratios_t = [6, 5, 6, 5, 3]\n\n regions = self._rundata.regiondata.regions \n regions = []\n # between shelf and CC\n regions.append(\\\n [2, 4, t_shelf, 1e9, -125, -124.05, 40.5, 43]) \n regions.append(\\\n [4, 5, t_harbor, 1e9, -124.26, -124.14, 41.67, 41.79])\n regions.append(\\\n [6, 6, t_harbor, 1e9, -124.218,-124.17, 41.7345, 41.77])\n\n # add topography (fine)\n topofiles = self._rundata.topo_data.topofiles\n # for topography, append lines of the form\n # [topotype, minlevel, maxlevel, t1, t2, fname]\n topofiles = []\n\n topofiles.append([3, 1, 6, 0., 1.e10, \\\n os.path.join(etopo_dir, 'etopo1_-130_-124_38_45_1min.asc')])\n topofiles.append([-3, 4, 6, 0., 1.e10, \\\n os.path.join(topodir, 'cc-1sec.asc')])\n topofiles.append([3, 6, 6, 0., 1.e10, \\\n os.path.join(topodir,'cc-1_3sec-c_pierless.asc')])\n \n # == fgmax.data values ==\n fgmax_files = self._rundata.fgmax_data.fgmax_files\n fgmax_files = []\n \n # for fixed grids append to this list names of any fgmax input files\n fgmax1_fname = os.path.join(driver_home,'fgmax1_fine.txt')\n fgmax2_fname = os.path.join(driver_home,'fgmax2_fine.txt')\n fgmax3_fname = os.path.join(driver_home,'fgmax3_fine.txt')\n\n fgmax_files.append(fgmax1_fname) \n fgmax_files.append(fgmax2_fname) \n fgmax_files.append(fgmax3_fname) \n \n self._rundata.fgmax_data.num_fgmax_val = 2\n \n\n\n #\n # set desired magnitude\n #\n if ((run_id >= 0) and (run_id < M)) \\\n or ((run_id >= 4*M) and (run_id < 5*M)):\n self.KL_Mw_desired = 8.6\n elif ((run_id >= M) and (run_id < 2*M)) \\\n or ((run_id >= 5*M) and (run_id < 6*M)):\n self.KL_Mw_desired = 8.8\n elif ((run_id >= 2*M) and (run_id < 3*M)) \\\n or ((run_id >= 6*M) and (run_id < 7*M)):\n self.KL_Mw_desired = 9.0\n elif ((run_id >= 3*M) and (run_id < 4*M)) \\\n or ((run_id >= 7*M) and (run_id < 8*M)):\n self.KL_Mw_desired = 9.2\n \n #\n # set slip distribution\n #\n run_id_mod = run_id - 100*(run_id/100)\n m = scn_list[run_id_mod]\n self.set_KL_slip(m)\n \n if run_id < 8*M:\n dir_grid_Mw = '../geoclaw_output/' + str(grid) + '_' + str(self.KL_Mw_desired)\n self._rundir = os.path.join(dir_grid_Mw, 'run_' + str(run_id_mod))\n else:\n # empty runs to obtain bathymetry\n \n dir_grid_Mw = '../geoclaw_output/' + str(grid) + '_B0'\n self._rundir = dir_grid_Mw\n self.KL_Mw_desired = 0.0\n self.set_KL_slip([0.]*len(m)) # set output\n self._rundata.clawdata.output_times = [1.0, 3.0]\n \n self._run_id += 1\n \n return self","def __init__(self, mesh, bndry, interface, dt, theta, v_max, lambda_s, mu_s, rho_s, \n mu_f, rho_f, result, *args, **kwargs):\n\n self.mesh = mesh\n self.dt = Constant(dt)\n self.theta = theta\n self.t = 0.0\n self.v_max = v_max\n\n self.mu_f = mu_f\n self.rho_f = rho_f\n self.lambda_s = lambda_s\n self.mu_s = mu_s\n self.rho_s = rho_s\n \n self.bndry = bndry\n self.interface = interface\n\n # bounding box tree\n self.bb = BoundingBoxTree()\n self.bb.build(self.mesh)\n\n # Define finite elements\n eV = VectorElement(\"CG\", mesh.ufl_cell(), 2)\t\t# velocity element\n eB = VectorElement(\"Bubble\", mesh.ufl_cell(), mesh.geometry().dim()+1) # Bubble element\n eU = VectorElement(\"CG\", mesh.ufl_cell(), 2)\t\t# displacement element\n eP = FiniteElement(\"DG\", mesh.ufl_cell(), 1)\t\t# pressure element\n\n eW = MixedElement([eV, eB, eU, eB, eP]) # final mixed element\n W = FunctionSpace(self.mesh, eW) # mixed space\n self.W = W\n self.V = FunctionSpace(self.mesh, eV)\n\n # Set boundary conditions\n self.v_in = Expression((\"t<2.0? 0.5*(1.0 - cos(0.5*pi*t))*v_max*4/(gW*gW)*(x[1]*(gW - x[1])): \\\n v_max*4/(gW*gW)*(x[1]*(gW - x[1]))\", \"0.0\"),\n degree = 2, v_max = Constant(self.v_max), gW = Constant(gW), t = self.t)\n\n #info(\"Expression set.\")\n bc_v_in = DirichletBC(self.W.sub(0), self.v_in, bndry, _INFLOW)\n bc_v_walls = DirichletBC(self.W.sub(0), Constant((0.0, 0.0)), bndry, _WALLS)\n bc_v_circle = DirichletBC(self.W.sub(0), Constant((0.0, 0.0)), bndry, _CIRCLE)\n bc_u_in = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _INFLOW)\n bc_u_circle = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _CIRCLE)\n bc_u_walls = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _WALLS)\n bc_u_out = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _OUTFLOW)\n self.bcs = [bc_v_in, bc_v_walls, bc_v_circle, bc_u_in, bc_u_walls, bc_u_circle, bc_u_out]\n\n #info(\"Mesh BC.\")\n bc_mesh = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), interface, _FSI)\n self.bcs_mesh = [bc_mesh]\n\n\n #info(\"Normal and Circumradius.\")\n self.n = FacetNormal(self.mesh)\n self.h = Circumradius(self.mesh)\n I = Identity(self.W.mesh().geometry().dim())\n\n # Define functions\n self.w = Function(self.W) # solution to current time step\n self.w0 = Function(self.W) # solution from previous time step\n\n (v__, bv_, u__, bu_, p_) = TestFunctions(self.W)\n\n # sum bubble elements with corresponding Lagrange elements\n v_ = v__ + bv_\n u_ = u__ + bu_\n (v, bv, u, bu, self.p) = split(self.w)\n self.v = v + bv\n self.u = u + bu\n (v0, bv0, u0, bu0, self.p0) = split(self.w0)\n self.v0 = v0 + bv0\n self.u0 = u0 + bu0\n\n\n # define deformation gradient, Jacobian\n self.FF = I + grad(self.u)\n self.FF0 = I + grad(self.u0)\n self.JJ = det(self.FF)\n self.JJ0 = det(self.FF0)\n\n # write ALE mesh movement \n self.gamma = 9.0/8.0\n h = CellVolume(self.mesh)**(self.gamma)\n E = Constant(1.0)\n\n E_mesh = E/h\n nu_mesh = Constant(-0.02)\n\n mu_mesh = E_mesh/(2*(1.0+nu_mesh))\n lambda_mesh = (nu_mesh*E_mesh)/((1+nu_mesh)*(1-2*nu_mesh))\n\n F_mesh = inner(mu_mesh*2*sym(grad(self.u)), grad(u_))*dx(0) \\\n + lambda_mesh*inner(div(self.u), div(u_))*dx(0)\n\n\n # define referential Grad and Div shortcuts\n def Grad(f, F): return dot( grad(f), inv(F) )\n def Div(f, F): return tr( Grad(f, F) )\n\n # approximate time derivatives\n du = (1.0/self.dt)*(self.u - self.u0)\n dv = (1.0/self.dt)*(self.v - self.v0)\n\n # compute velocuty part of Cauchy stress tensor for fluid\n self.T_f = -self.p*I + 2*self.mu_f*sym(Grad(self.v, self.FF))\n self.T_f0 = -self.p*I + 2*self.mu_f*sym(Grad(self.v0, self.FF0))\n\n # Compute 1st Piola-Kirhhoff tensro for fluid \n # - for computing surface integrals for forces in postprocessing \n self.S_f = self.JJ *self.T_f*inv(self.FF).T\n \n # write equations for fluid\n a_fluid = inner(self.T_f , Grad(v_, self.FF))*self.JJ*dx(0) \\\n - inner(self.p, Div(v_, self.FF))*self.JJ*dx(0) \\\n + inner(self.rho_f*Grad(self.v, self.FF )*(self.v - du), v_)*self.JJ*dx(0)\n a_fluid0 = inner(self.T_f0, Grad(v_, self.FF0))*self.JJ0*dx(0) \\\n - inner(self.p, Div(v_, self.FF))*self.JJ*dx(0) \\\n + inner(self.rho_f*Grad(self.v0, self.FF0)*(self.v0 - du), v_)*self.JJ0*dx(0)\n\n b_fluid = inner(Div( self.v, self.FF ), p_)*self.JJ*dx(0)\n b_fluid0 = inner(Div( self.v, self.FF ), p_)*self.JJ*dx(0)\n\n self.F_fluid = (self.theta*self.JJ+(1.0 - self.theta)*self.JJ0)*self.rho_f*inner(dv, v_)*dx(0)\\\n + self.theta*(a_fluid + b_fluid) + (1.0 - self.theta)*(a_fluid0 + b_fluid0) \\\n + F_mesh\n\n # compute 1st Piola-Kirchhoff tensor for solid (St. Vennant - Kirchhoff model)\n B_s = self.FF.T *self.FF\n B_s0 = self.FF0.T*self.FF0\n S_s = self.FF *(0.5*self.lambda_s*tr(B_s - I)*I + self.mu_s*(B_s - I))\n S_s0 = self.FF0*(0.5*self.lambda_s*tr(B_s0 - I)*I + self.mu_s*(B_s0 - I))\n\n # write equation for solid\n alpha = Constant(1.0) # Constant(1e10) #\n self.F_solid = rho_s*inner(dv, v_)*dx(1) \\\n + self.theta*inner(S_s , grad(v_))*dx(1) + (1.0 - self.theta)*inner(S_s0, grad(v_))*dx(1) \\\n + alpha*inner(du - (self.theta*self.v + (1.0 - self.theta)*self.v0), u_)*dx(1)\n\n\n dF_solid = derivative(self.F_solid, self.w)\n dF_fluid = derivative(self.F_fluid, self.w)\n\n self.problem = Problem(self.F_fluid, self.F_solid, dF_fluid, dF_solid, self.bcs_mesh, self.bcs)\n self.solver = NewtonSolver()\n\n # configure solver parameters\n self.solver.parameters['relative_tolerance'] = 1e-6\n self.solver.parameters['maximum_iterations'] = 15\n self.solver.parameters['linear_solver'] = 'mumps'\n\n # create files for saving\n if my_rank == 0:\n if not os.path.exists(result):\n os.makedirs(result)\n self.vfile = XDMFFile(\"%s/velocity.xdmf\" % result)\n self.ufile = XDMFFile(\"%s/displacement.xdmf\" % result)\n self.pfile = XDMFFile(\"%s/pressure.xdmf\" % result)\n self.sfile = XDMFFile(\"%s/stress.xdmf\" % result)\n self.vfile.parameters[\"flush_output\"] = True\n self.ufile.parameters[\"flush_output\"] = True\n self.pfile.parameters[\"flush_output\"] = True\n self.sfile.parameters[\"flush_output\"] = True\n with open(result+'/data.csv', 'w') as data_file:\n writer = csv.writer(data_file, delimiter=';', lineterminator='\\n')\n writer.writerow(['time', 'mean pressure on outflow', 'pressure_jump', \n 'x-coordinate of end of beam', 'y-coordinate of end of beam',\n 'pressure difference', \n 'drag_circle', 'drag_fluid', 'drag_solid', 'drag_fullfluid',\n 'lift_circle', 'lift_fluid', 'lift_solid', 'lift_fullfluid'])","def get_proj(self):\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\n\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\n\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \n worldM = proj3d.world_transformation(xmin, xmax,\n ymin, ymax,\n zmin, zmax)\n\n # look into the middle of the new coordinates \n R = np.array([0.5, 0.5, 0.5])\n\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\n zp = R[2] + np.sin(relev) * self.dist\n E = np.array((xp, yp, zp))\n\n self.eye = E\n self.vvec = R - E\n self.vvec = self.vvec / proj3d.mod(self.vvec)\n\n if abs(relev) > np.pi/2:\n # upside down \n V = np.array((0, 0, -1))\n else:\n V = np.array((0, 0, 1))\n\n zfront, zback = -self.dist, self.dist\n\n viewM = proj3d.view_transformation(E, R, V)\n perspM = proj3d.persp_transformation(zfront, zback)\n M0 = np.dot(viewM, worldM)\n M = np.dot(perspM, M0)\n return M","def elaboratedCurve(radius = 10, resolution = 22, robotHeight = -90,distx = 10,disty = 10, lines = 20):\n \n if resolution%4 != 0:\n while resolution%4 != 0:\n resolution += 1\n \n t = np.linspace(0, m.pi/2, int(resolution/4))\n elaboratedCurvePos = []\n for num in t:\n x = m.cos(num)*radius - distx\n y = -m.sin(num)*radius + disty\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\n\n t = np.linspace(0, 2*m.pi, resolution)\n for num in t:\n x = -m.sin(num)*radius - distx\n y = m.cos(num)*radius - disty\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\n\n t = np.linspace(0, 3*m.pi/2, int(3*resolution/4))\n for num in t:\n x = -m.sin(num)*radius - distx\n y = -m.cos(num)*radius + disty\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\n\n \n elaboratedCurvePos.append([lines, disty, robotHeight, 0, 0, 0, 'lin'])\n\n z = np.linspace(0, m.pi, int(resolution/2))\n for num in z:\n x = m.sin(num)*radius + lines\n y = m.cos(num)*radius\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\n\n elaboratedCurvePos.append([0, -disty, robotHeight, 0, 0, 0, 'lin'])\n time.sleep(2) #TODO: Sleep wegmachen\n\n elaboratedCurvePos.append([0,0,-127,0,0,0,'mov'])\n #return elaboratedCurvePos\n return elaboratedCurvePos","def doParametersOfInterest(self):\n self.modelBuilder.doVar(\"mu[1,0,100]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu\")\n self.modelBuilder.factory_('expr::ggH_s_func(\"@0-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::ggH_b_func(\"1-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\"sqrt(@0)\", mu)')","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 pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\n def compute_avec(vec,aaa,bbb,grd):\n\n avec=np.empty(grd.np0,)\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\n avec[grd.vp1] = vec[grd.vp1]\n\n return avec,\n if name_grd is not None:\n if os.path.isfile(name_grd):\n with open(name_grd, 'rb') as f:\n grd = pickle.load(f)\n else:\n grd = Grid(lon,lat)\n with open(name_grd, 'wb') as f:\n pickle.dump(grd, f)\n f.close()\n else:\n grd = Grid(lon,lat)\n\n ny,nx,=np.shape(hg)\n g=grd.g\n\n\n x=hg[grd.indi,grd.indj]\n q1d=q[grd.indi,grd.indj]\n\n aaa=g/grd.f01d\n bbb=-g*grd.f01d/c**2\n ccc=+q1d\n\n aaa[grd.vp1]=0\n bbb[grd.vp1]=1\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\n\n vec=+x\n\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n p=-gg\n\n for itr in range(nitr-1):\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n tmp=np.dot(p,avec)\n\n if tmp!=0. : s=-np.dot(p,gg)/tmp\n else: s=1.\n\n a1=np.dot(gg,gg)\n x=x+s*p\n vec=+x\n avec,=compute_avec(vec,aaa,bbb,grd)\n gg=avec-ccc\n a2=np.dot(gg,gg)\n\n if a1!=0: beta=a2/a1\n else: beta=1.\n\n p=-gg+beta*p\n\n vec=+p\n avec,=compute_avec(vec,aaa,bbb,grd)\n val1=-np.dot(p,gg)\n val2=np.dot(p,avec)\n if (val2==0.):\n s=1.\n else:\n s=val1/val2\n\n a1=np.dot(gg,gg)\n x=x+s*p\n\n # back to 2D\n h=np.empty((ny,nx))\n h[:,:]=np.NAN\n h[grd.indi,grd.indj]=x[:]\n\n\n return h","def potential_energy_per_mode(proj_displ,eigvals): #,hess=None,check=False): \n return 0.5 * ( np.square(proj_displ).T * eigvals ).T #, 0.5 * proj_displ * omega_sqr @ proj_displ","def eui_modesign():\n\n # setup design space\n # N ds ws wc lc g\n GAP = Struct()\n GAP.gd_min = np.array([1, 1e-3, 1e-3, 1e-3, 1e-3, 1e-5])\n GAP.gd_max = np.array([1e3, 1e-1, 1e-1, 1e-1, 1e-1, 1e-2])\n\n\n # setup genetic algorithm parameters--------------------------------------\n nobj=2 # number of objectives\n ngen=100 # number of generations\n npop = 100 # population size\n \n problem = MyProblem()\n problem.n_var = len(GAP.gd_min)\n problem.n_obj = nobj\n problem.n_constr = 2\n problem.xl = GAP.gd_min\n problem.xu = GAP.gd_max\n problem.elementwise_evaluation = True\n\n algorithm = NSGA2(\n pop_size=npop,\n eliminate_duplicates=True\n )\n \n # conduct the optimization-------------------------------------------------\n res = minimize(problem, algorithm, (\"n_gen\", ngen), verbose=True)\n\n # save results-------------------------------------------------------------\n return res","def gpt2_1w (station, dmjd,dlat,dlon,hell,it):\n\n# need to find diffpod and difflon\n if (dlon < 0):\n plon = (dlon + 2*np.pi)*180/np.pi;\n else:\n plon = dlon*180/np.pi;\n# transform to polar distance in degrees\n ppod = (-dlat + np.pi/2)*180/np.pi; \n\n# % find the index (line in the grid file) of the nearest point\n# \t % changed for the 1 degree grid (GP)\n ipod = np.floor(ppod+1); \n ilon = np.floor(plon+1);\n \n# normalized (to one) differences, can be positive or negative\n#\t% changed for the 1 degree grid (GP)\n diffpod = (ppod - (ipod - 0.5));\n difflon = (plon - (ilon - 0.5));\n\n\n# change the reference epoch to January 1 2000\n print('Modified Julian Day', dmjd)\n dmjd1 = dmjd-51544.5 \n\n pi2 = 2*np.pi\n pi4 = 4*np.pi\n\n# mean gravity in m/s**2\n gm = 9.80665;\n# molar mass of dry air in kg/mol\n dMtr = 28.965E-3 \n# dMtr = 28.965*10^-3 \n# universal gas constant in J/K/mol\n Rg = 8.3143 \n\n# factors for amplitudes, i.e. whether you want time varying\n if (it==1):\n print('>>>> no refraction time variation ')\n cosfy = 0; coshy = 0; sinfy = 0; sinhy = 0;\n else: \n cosfy = np.cos(pi2*dmjd1/365.25)\n coshy = np.cos(pi4*dmjd1/365.25) \n sinfy = np.sin(pi2*dmjd1/365.25) \n sinhy = np.sin(pi4*dmjd1/365.25) \n cossin = np.matrix([1, cosfy, sinfy, coshy, sinhy])\n# initialization of new vectors\n p = 0; T = 0; dT = 0; Tm = 0; e = 0; ah = 0; aw = 0; la = 0; undu = 0;\n undul = np.zeros(4)\n Ql = np.zeros(4)\n dTl = np.zeros(4)\n Tl = np.zeros(4)\n pl = np.zeros(4)\n ahl = np.zeros(4)\n awl = np.zeros(4)\n lal = np.zeros(4)\n Tml = np.zeros(4)\n el = np.zeros(4)\n#\n pgrid, Tgrid, Qgrid, dTgrid, u, Hs, ahgrid, awgrid, lagrid, Tmgrid = read_4by5(station,dlat,dlon,hell)\n#\n for l in [0,1,2,3]:\n KL = l #silly to have this as a variable like this \n# transforming ellipsoidal height to orthometric height:\n# Hortho = -N + Hell\n undul[l] = u[KL] \n hgt = hell-undul[l] \n# pressure, temperature at the height of the grid\n T0 = Tgrid[KL,0] + Tgrid[KL,1]*cosfy + Tgrid[KL,2]*sinfy + Tgrid[KL,3]*coshy + Tgrid[KL,4]*sinhy;\n tg = float(Tgrid[KL,:] *cossin.T)\n# print(T0,tg)\n\n p0 = pgrid[KL,0] + pgrid[KL,1]*cosfy + pgrid[KL,2]*sinfy + pgrid[KL,3]*coshy + pgrid[KL,4]*sinhy;\n \n# humidity \n Ql[l] = Qgrid[KL,0] + Qgrid[KL,1]*cosfy + Qgrid[KL,2]*sinfy + Qgrid[KL,3]*coshy + Qgrid[KL,4]*sinhy;\n \n# reduction = stationheight - gridheight\n Hs1 = Hs[KL]\n redh = hgt - Hs1;\n\n# lapse rate of the temperature in degree / m\n dTl[l] = dTgrid[KL,0] + dTgrid[KL,1]*cosfy + dTgrid[KL,2]*sinfy + dTgrid[KL,3]*coshy + dTgrid[KL,4]*sinhy;\n \n# temperature reduction to station height\n Tl[l] = T0 + dTl[l]*redh - 273.15;\n\n# virtual temperature\n Tv = T0*(1+0.6077*Ql[l]) \n c = gm*dMtr/(Rg*Tv) \n \n# pressure in hPa\n pl[l] = (p0*np.exp(-c*redh))/100 \n \n# hydrostatic coefficient ah\n ahl[l] = ahgrid[KL,0] + ahgrid[KL,1]*cosfy + ahgrid[KL,2]*sinfy + ahgrid[KL,3]*coshy + ahgrid[KL,4]*sinhy;\n \n# wet coefficient aw\n awl[l] = awgrid[KL,0] + awgrid[KL,1]*cosfy + awgrid[KL,2]*sinfy + awgrid[KL,3]*coshy + awgrid[KL,4]*sinhy;\n\t\t\t\t\t \n# water vapor decrease factor la - added by GP\n lal[l] = lagrid[KL,0] + lagrid[KL,1]*cosfy + lagrid[KL,2]*sinfy + lagrid[KL,3]*coshy + lagrid[KL,4]*sinhy;\n\t\t\t\t\t \n# mean temperature of the water vapor Tm - added by GP\n Tml[l] = Tmgrid[KL,0] + Tmgrid[KL,1]*cosfy + Tmgrid[KL,2]*sinfy + Tmgrid[KL,3]*coshy + Tmgrid[KL,4]*sinhy;\n\t\t\t\t\t \t\t \n# water vapor pressure in hPa - changed by GP\n e0 = Ql[l]*p0/(0.622+0.378*Ql[l])/100; # % on the grid\n aa = (100*pl[l]/p0)\n bb = lal[l]+1\n el[l] = e0*np.power(aa,bb) # % on the station height - (14) Askne and Nordius, 1987\n \n dnpod1 = np.abs(diffpod); # % distance nearer point\n dnpod2 = 1 - dnpod1; # % distance to distant point\n dnlon1 = np.abs(difflon);\n dnlon2 = 1 - dnlon1;\n \n# pressure\n R1 = dnpod2*pl[0]+dnpod1*pl[1];\n R2 = dnpod2*pl[2]+dnpod1*pl[3];\n p = dnlon2*R1+dnlon1*R2;\n \n# temperature\n R1 = dnpod2*Tl[0]+dnpod1*Tl[1];\n R2 = dnpod2*Tl[2]+dnpod1*Tl[3];\n T = dnlon2*R1+dnlon1*R2;\n \n# temperature in degree per km\n R1 = dnpod2*dTl[0]+dnpod1*dTl[1];\n R2 = dnpod2*dTl[2]+dnpod1*dTl[3];\n dT = (dnlon2*R1+dnlon1*R2)*1000;\n \n# water vapor pressure in hPa - changed by GP\n R1 = dnpod2*el[0]+dnpod1*el[1];\n R2 = dnpod2*el[2]+dnpod1*el[3];\n e = dnlon2*R1+dnlon1*R2;\n \n# hydrostatic\n R1 = dnpod2*ahl[0]+dnpod1*ahl[1];\n R2 = dnpod2*ahl[2]+dnpod1*ahl[3];\n ah = dnlon2*R1+dnlon1*R2;\n \n# wet\n R1 = dnpod2*awl[0]+dnpod1*awl[1];\n R2 = dnpod2*awl[2]+dnpod1*awl[3];\n aw = dnlon2*R1+dnlon1*R2;\n \n# undulation\n R1 = dnpod2*undul[0]+dnpod1*undul[1];\n R2 = dnpod2*undul[2]+dnpod1*undul[3];\n undu = dnlon2*R1+dnlon1*R2;\n\n# water vapor decrease factor la - added by GP\n R1 = dnpod2*lal[0]+dnpod1*lal[1];\n R2 = dnpod2*lal[2]+dnpod1*lal[3];\n la = dnlon2*R1+dnlon1*R2;\n\t\t\n# mean temperature of the water vapor Tm - added by GP\n R1 = dnpod2*Tml[0]+dnpod1*Tml[1];\n R2 = dnpod2*Tml[2]+dnpod1*Tml[3];\n Tm = dnlon2*R1+dnlon1*R2; \n\n return p, T, dT,Tm,e,ah,aw,la,undu","def test_born_newton(self):\n\n n0 = 3.4\n omega = 2*np.pi*200e12\n dl = 0.01\n chi3 = 2.8E-18\n\n width = 1\n L = 5\n L_chi3 = 4\n\n width_voxels = int(width/dl)\n L_chi3_voxels = int(L_chi3/dl)\n\n Nx = int(L/dl)\n Ny = int(3.5*width/dl)\n\n eps_r = np.ones((Nx, Ny))\n eps_r[:, int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = np.square(n0)\n\n nl_region = np.zeros(eps_r.shape)\n nl_region[int(Nx/2-L_chi3_voxels/2):int(Nx/2+L_chi3_voxels/2), int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = 1\n\n simulation = Simulation(omega, eps_r, dl, [15, 15], 'Ez')\n simulation.add_mode(n0, 'x', [17, int(Ny/2)], width_voxels*3)\n simulation.setup_modes()\n simulation.add_nl(chi3, nl_region, eps_scale=True, eps_max=np.max(eps_r))\n\n srcval_vec = np.logspace(1, 3, 3)\n pwr_vec = np.array([])\n T_vec = np.array([])\n for srcval in srcval_vec:\n simulation.setup_modes()\n simulation.src *= srcval\n\n # Newton\n simulation.solve_fields_nl(solver_nl='newton')\n E_newton = simulation.fields[\"Ez\"]\n\n # Born\n simulation.solve_fields_nl(solver_nl='born')\n E_born = simulation.fields[\"Ez\"]\n\n # More solvers (if any) should be added here with corresponding calls to assert_allclose() below\n\n assert_allclose(E_newton, E_born, rtol=1e-3)","def doParametersOfInterest(self):\n self.modelBuilder.doVar(\"mu[0,0,1000]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu\")\n self.modelBuilder.factory_('expr::vbfH_s_func(\"@0-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\"1-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\"sqrt(@0)\", mu)')","def spatial(self):","def construct_param_dict(params,K_RC,K_CP,m_P):\n ###scaling constants\n w=params['w']\n pd=params['pd'] # in 3D and 0.21 in 2D\n pv=params['pv']\n Er=params['Er'] ;Ek=params['Ek']\n ER=params['ER'];EC=params['EC'];EP=params['EP'];\n Eq1=params['Eq1'];Eq2=params['Eq2']\n\n\n #capture success function\n a = params['a']\n b = params['b']\n c = params['c']\n formC = params['formC']\n formPC = params['formPC']\n formPR = params['formPR']\n \n ###variables\n TR= params['TR'] ;TC= params['TC'];TP=params['TP'];D_R= params['D_R']; D_C= params['D_C']\n K_RP=K_RC*K_CP\n fmC=params['fmC'];thermyR=params['thermyR']\n thermyC=params['thermyC'];thermyP=params['thermyP']\n fmPR=params['fmPR']\n fmPC=params['fmPC']\n m_C = K_CP*m_P;m_R = K_RP*m_P\n ###normalization constants and boltzmann constant\n r0 = params['r0']\n k0 = params['k0'] # will depend on the productivity of the habitat\n a01 = a02 = params['a012'] # will depedend on the dimension of the habitat \n a03 = params['a03']\n d0= params['d0']\n q10 = params['q10'];q20 = params['q20'];\n v0R = params['v0R'];v0C =params['v0C'];v0P =params['v0P'];k = b_k\n hC0 = params['hC0'];hP0 = params['hP0'] \n \n #intrapopulation parameters\n q1=set_q1(q10,m_C,w,Eq1,TR,k)\n q2=set_q2(q20,m_P,w,Eq2,TC,k)\n K=set_K(k0,m_R,w,Ek,TR,k)\n r=set_r(r0,m_R,w,Er,TR,k)\n\n #interpopulation parameters\n a1=set_alfa(m_C,a01,K_RC,pv,pd,TR,TC,ER,EC,D_R,v0R,v0C,g,alfa,fmC,thermyR,thermyC,k,a,b,c,formC)\n a2=set_alfa(m_P,a02,K_RP,pv,pd,TR,TP,ER,EP,D_R,v0R,v0P,g,alfa,fmPR,thermyR,thermyP,k,a,b,c,formPR)\n a3=set_alfa(m_P,a03,K_CP,pv,pd,TC,TP,EC,EP,D_C,v0C,v0P,g,alfa,fmPC,thermyC,thermyP,k,a,b,c,formPC)\n\n t_hp = set_th(hP0,m_P,w,EP,k,TP)\n t_hc = set_th(hC0,m_C,w,EC,k,TC)\n param_dict={'q1':q1,'q2':q2,'K':K,'r':r,'a1':a1,'a2':a2,'a3':a3,'t_hp':t_hp,'t_hc':t_hc}\n \n return param_dict","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"Rdy[1.,0.0,10.0]\");\n self.modelBuilder.doVar(\"Rqcd[1,0.0,10.0]\");\n self.modelBuilder.doSet(\"POI\",\"Rdy,Rqcd\")","def _init_parameters(self,diameterInd):\n\n\t\t# topological parameters\n\t\tself.nNodes = 21\n\t\tself._axonNodes=self.nNodes\n\t\tself._paraNodes1=40\n\t\tself._paraNodes2=40\n\t\tself._axonInter=120\n\t\tself._axonTotal=221\n\t\t# morphological parameters\n\t\tpossibleDiameters = [5.7, 7.3, 8.7, 10.0, 11.5, 12.8, 14.0, 15.0, 16.0]\n\t\tself._fiberD=possibleDiameters[diameterInd]\n\t\tself._paraLength1=3 \n\t\tself._nodeLength=1.0\n\t\tself._spaceP1=0.002 \n\t\tself._spaceP2=0.004\n\t\tself._spaceI=0.004\n\t\t# electrical parameters\n\t\tself._rhoa=0.7e6 #Ohm-um\n\t\tself._mycm=0.1 #uF/cm2/lamella membrane\n\t\tself._mygm=0.001 #S/cm2/lamella membrane\n\n\t\tif self._fiberD==5.7:\n\t\t\tself._g=0.605 \n\t\t\tself._axonD=3.4\n\t\t\tself._nodeD=1.9\n\t\t\tself._paraD1=1.9\n\t\t\tself._paraD2=3.4\n\t\t\tself._deltax=500\n\t\t\tself._paraLength2=35\n\t\t\tself._nl=80\n\t\tif self._fiberD==8.7:\n\t\t\tself._g=0.661\n\t\t\tself._axonD=5.8\n\t\t\tself._nodeD=2.8\n\t\t\tself._paraD1=2.8\n\t\t\tself._paraD2=5.8\n\t\t\tself._deltax=1000\n\t\t\tself._paraLength2=40\n\t\t\tself._nl=110\n\t\tif self._fiberD==10.0:\n\t\t\tself._g=0.690\n\t\t\tself._axonD=6.9\n\t\t\tself._nodeD=3.3\n\t\t\tself._paraD1=3.3\n\t\t\tself._paraD2=6.9\n\t\t\tself._deltax=1150\n\t\t\tself._paraLength2=46\n\t\t\tself._nl=120\n\t\tif self._fiberD==11.5:\n\t\t\tself._g=0.700\n\t\t\tself._axonD=8.1\n\t\t\tself._nodeD=3.7\n\t\t\tself._paraD1=3.7\n\t\t\tself._paraD2=8.1\n\t\t\tself._deltax=1250\n\t\t\tself._paraLength2=50\n\t\t\tself._nl=130\n\t\tif self._fiberD==12.8:\n\t\t\tself._g=0.719\n\t\t\tself._axonD=9.2\n\t\t\tself._nodeD=4.2\n\t\t\tself._paraD1=4.2\n\t\t\tself._paraD2=9.2\n\t\t\tself._deltax=1350\n\t\t\tself._paraLength2=54\n\t\t\tself._nl=135\n\t\tif self._fiberD==14.0:\n\t\t\tself._g=0.739\n\t\t\tself._axonD=10.4\n\t\t\tself._nodeD=4.7\n\t\t\tself._paraD1=4.7\n\t\t\tself._paraD2=10.4\n\t\t\tself._deltax=1400\n\t\t\tself._paraLength2=56\n\t\t\tself._nl=140\n\t\tif self._fiberD==15.0:\n\t\t\tself._g=0.767\n\t\t\tself._axonD=11.5\n\t\t\tself._nodeD=5.0\n\t\t\tself._paraD1=5.0\n\t\t\tself._paraD2=11.5\n\t\t\tself._deltax=1450\n\t\t\tself._paraLength2=58\n\t\t\tself._nl=145\n\t\tif self._fiberD==16.0:\n\t\t\tself._g=0.791\n\t\t\tself._axonD=12.7\n\t\t\tself._nodeD=5.5\n\t\t\tself._paraD1=5.5\n\t\t\tself._paraD2=12.7\n\t\t\tself._deltax=1500\n\t\t\tself._paraLength2=60\n\t\t\tself._nl=150\n\n\t\tself._Rpn0=(self._rhoa*.01)/(np.pi*((((self._nodeD/2)+self._spaceP1)**2)-((self._nodeD/2)**2)))\n\t\tself._Rpn1=(self._rhoa*.01)/(np.pi*((((self._paraD1/2)+self._spaceP1)**2)-((self._paraD1/2)**2)))\n\t\tself._Rpn2=(self._rhoa*.01)/(np.pi*((((self._paraD2/2)+self._spaceP2)**2)-((self._paraD2/2)**2)))\n\t\tself._Rpx=(self._rhoa*.01)/(np.pi*((((self._axonD/2)+self._spaceI)**2)-((self._axonD/2)**2)))\n\t\tself._interLength=(self._deltax-self._nodeLength-(2*self._paraLength1)-(2*self._paraLength2))/6","def objective(rp,n=5000,C=-2*10**11,a=300,b=1):\n l = log(rp)/n\n r = exp(l)\n rm1 = r-1\n return (rp-1)*((a-b*n)*rm1 + 1) - C*(rm1)*(rm1)\n #return rm1","def simulateUpTo2016FullPop3params(params, extraParams):\n beta, betaW, mu = params\n\n aseason, delta, gamma, gammaA, gammaE, k, m, nInfected, pseason, Pop, red_beta, red_mu, rlen, rep, \\\n sigma, tau, tspan_length, V, vrate, waterMat, wRate = extraParams\n\n beta_A = red_beta*beta\n mu_A = red_mu*mu\n\n repMat = [rep]*10\n\n numDep = 10\n\n travelMat = formTravelMat1(numDep, rlen, tau, vrate, Pop)\n #set initial conditions:\n S0 = np.copy(Pop) - nInfected\n E0 = np.zeros(np.size(Pop))\n I0 = map(lambda x: x / reporting_rate, nInfected)#nInfected/rep # np.zeros(np.size(Pop))\n A0 = np.zeros(np.size(Pop))\n R0 = np.zeros(np.size(Pop))\n RA0 = np.zeros(np.size(Pop))\n W0 = np.zeros(np.size(Pop)) # 15*Pop*365\n C0 = I0\n\n\n\n initCond = np.array([S0, E0, I0, A0, R0, RA0, W0, C0]).reshape((8 * numDep))\n # print initCond\n tspan = range(tspan_length)\n\n paramsODE = [aseason, beta, beta_A, betaW, delta, gamma, gammaA, gammaE, k, m, mu, mu_A, numDep, \\\n pseason, sigma, travelMat, V, wRate, waterMat]\n\n\n sol, info = odeint(choleraEqs10WithoutVaccinationNetwork, initCond, tspan,\n args=(paramsODE,), full_output=True)\n\n\n if info['message'] == 'Integration successful.':\n temp = sol[:, 70:]\n newcases = np.zeros((np.size(sol[:, 0]), 10))\n\n newcases[0, :] = sol[0, 70:80]\n\n for jvals in range(10):\n for t in range(1, len(tspan)):\n newcases[t, jvals] = (np.sum(temp[t, jvals]) - np.sum(temp[t - 1, jvals]))\n\n # newcases[:, jvals] = repMat[jvals] * newcases[:, jvals]\n\n\n # print np.shape(newcases)\n return [sol, newcases]\n else:\n # print 'hola'\n return [0, np.ones((tspan_length, 10))*10**8]","def run(self, event, Collection):\n ret = {}\n inputVars = []\n score_ = -99 \n cat_ = -99 \n\n \"\"\" Get lepton and jet objects \"\"\"\n # Get the list of leptons\n all_leps = [j for j in Collection(event,\"LepGood\")]\n nFO = getattr(event,\"nLepFO_Recl\")\n chosen = getattr(event,\"iLepFO_Recl\")\n \n # These are the objects we have to use\n leps = [all_leps[chosen[i]] for i in range(nFO)]\n alljets = [j for j in Collection(event,\"JetSel_Recl\")]\n year = event.year\n\n\n \"\"\" A partir de aqui hay que modificar en funcion del modelo !!!!\"\"\"\n bjets = []\n nonbjets = []\n for jet in alljets:\n wp = jet.btagDeepFlavB\n is_btagged = (((wp >= 0.3093) and (year == 2016)) or \n ((wp >= 0.3033) and (year == 2017)) or \n ((wp >= 0.2770) and (year == 2018)))\n if is_btagged:\n bjets.append(jet)\n else:\n nonbjets.append(jet)\n\n\n htjet25 = event.htJet25j_Recl\n jet3_pt = nonbjets[2].pt\n jet2_pt = nonbjets[1].pt\n jet2_mass = nonbjets[2].mass\n nJet25_Recl = event.nJet25_Recl\n jet4_pt = nonbjets[3].pt\n combipt = leps[0].pt + leps[1].pt\n lep1_charge = np.sign(leps[0].pdgId)\n lep2_mass = leps[1].mass\n mlj12 = self.moo(\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\n (nonbjets[1].pt, nonbjets[1].eta, nonbjets[1].eta, nonbjets[1].mass)\n )\n lep2_elec = (np.abs(leps[1].pdgId) == 11)\n lep2_pt = leps[1].pt\n Flav_muon = (np.abs(leps[0].pdgId) == np.abs(leps[1].pdgId)) and (np.abs(leps[0].pdgId) == 13)\n B2_pt = -99\n mlj11 = self.moo(\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\n (nonbjets[0].pt, nonbjets[0].eta, nonbjets[0].eta, nonbjets[0].mass)\n )\n mlj21 = self.moo(\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass),\n (nonbjets[0].pt, nonbjets[0].eta, nonbjets[0].eta, nonbjets[0].mass)\n )\n mlj22 = self.moo(\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass),\n (nonbjets[1].pt, nonbjets[1].eta, nonbjets[1].eta, nonbjets[1].mass)\n )\n mll = self.moo(\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass)\n )\n Flav_elec = (np.abs(leps[0].pdgId) == np.abs(leps[1].pdgId)) and (np.abs(leps[0].pdgId) == 11)\n nBJetMedium25_Recl = event.nBJetMedium25_Recl\n deltarjb11 = deltaR(nonbjets[0].phi, nonbjets[0].eta, bjets[0].phi, bjets[0].eta)\n jet3_eta = nonbjets[2].eta\n deltarjet = deltaR(nonbjets[0].phi, nonbjets[0].eta, nonbjets[1].phi, nonbjets[1].eta)\n jet5_pt = nonbjets[4]\n\n\n # El orden de las variables es importante!!!\n inputVars = [\n year, \n htjet25,\n jet2_pt,\n jet3_pt,\n jet2_mass,\n nJet25_Recl,\n leps[1].pt,\n mlj11,\n nonbjets[2].mass,\n nonbjets[1].pt,\n nonbjets[3].mass,\n lep1_charge, \n leps[1].mass,\n jet4_pt, \n jet3_eta,\n nonbjets[2].phi,\n nonbjets[0].pt,\n Flav_muon,\n nonbjets[3].phi,\n mll,\n abs(leps[1].pdgId) == 11,\n nonbjets[3].eta,\n mlj12,\n nonbjets[4].eta,\n Flav_elec,\n mlj21,\n mlj22,\n combipt,\n np.sign(leps[1].pdgId),\n ]\n \n # Esto te permite evaluar el modelo usando las inputVariables que nos hemos cocinado previamente\n score_, cat_ = self.model.predict(inputVars)\n ret[\"ttwmva_prob\"] = score_ \n ret[\"ttwmva_cat\"] = cat_\n return ret","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"Afb[0.6,-0.75,0.75]\");\n self.modelBuilder.doSet(\"POI\",\"Afb\")\n\n # ss templates\n self.modelBuilder.doVar(\"Dilu_ratio[1.0,0.0,10.0]\");\n self.modelBuilder.doVar(\"Rdy_mumu_ss[1.0,0.0,10.0]\");\n self.modelBuilder.doVar(\"Rdy_ee_ss[1.0,0.0,10.0]\");\n \n self.modelBuilder.factory_('expr::Rpl(\"0.5*(1.+@0*@1)\",Afb, Dilu_ratio)')\n self.modelBuilder.factory_('expr::Rmn(\"0.5*(1.-@0*@1)\",Afb, Dilu_ratio)')","def project(self, latitude, longitude):\n longitude = longitude if longitude > 0 else 360 + longitude\n\n lon_array = self.ecmwf_data.longitude\n lat_array = self.ecmwf_data.latitude\n\n # Find in the lon_array / lat_array the index interval\n # Including lon_ul and lat_ul\n a_lon = np.where((lon_array < longitude))[0][-1]\n if longitude > lon_array.max():\n # lon is between 359.6 and 0 ...\n b_lon = 0\n else:\n b_lon = np.where((lon_array >= longitude))[0][0]\n\n a_lat = np.where((lat_array < latitude))[0][0]\n b_lat = np.where((lat_array >= latitude))[0][-1]\n\n # Compute geo extent around the point :\n # => extent definition : LR,LL,UL,UR\n extent = [lon_array[a_lon], lat_array[a_lat],\n lon_array[b_lon], lat_array[a_lat],\n lon_array[b_lon], lat_array[b_lat],\n lon_array[a_lon], lat_array[b_lat]]\n\n extent_index = [a_lon, a_lat,\n b_lon, a_lat,\n b_lon, b_lat,\n a_lon, b_lat]\n\n log.info(' - Selected vertex : ')\n log.info('LL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[0]), str(extent_index[1]), str(extent[0]), str(extent[1])))\n log.info('LR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[2]), str(extent_index[3]), str(extent[2]), str(extent[3])))\n log.info('UR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[4]), str(extent_index[5]), str(extent[4]), str(extent[5])))\n log.info('UL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[6]), str(extent_index[7]), str(extent[6]), str(extent[7])))\n\n # TIE Point grid defined - compute linear transformation\n # to estimate value at the lat/lon location\n # origin : extent_ul[0], extent_ul[1]\n delta_lon = 0.4 # extent[4] - extent[6] # UR - UL\n delta_lat = -0.4 # extent[1] - extent[7] # LL - UL\n\n lambda_lat = latitude - extent[7]\n lambda_lon = longitude - extent[6]\n\n beta_longitude = lambda_lon / delta_lon\n beta_latitude = lambda_lat / delta_lat\n\n # Processing of all keys\n for key in self.ecmwf_data.mandatory_attributes:\n M = getattr(self.ecmwf_data, key)\n v = self.linear_estimate(M,\n beta_latitude,\n beta_longitude,\n extent_index)\n setattr(self, key, v)","def calc_visible( observatory, date_start, date_end, sigtype='transits', \\\n ofilename_byplanet='default', ofilename_chronolog='default',\n sun_alt_max=-6, sun_alt_twil=-12, sun_alt_dark=-18, \\\n moon_alt_set=-6, target_elev_min=25, oot_deltdur=0.5, \\\n tr_signals='signals_transits.txt', ec_signals='signals_eclipses.txt', \\\n exclude_unranked=False, max_rank=None ):\n\n # Convert the minimum target altitude to a maximum zenith angle:\n zenith_max = 90 - target_elev_min\n\n # Read in the basic target information for all transiting exoplanets:\n targets, vmags, ras, decs, ttrs, pers, durs = read_eph( EPH_FILE )\n\n # Read in the rankings for transit and eclipse signals:\n targets_ec, ranks_ec = eclipse_ranks( ec_signals )\n targets_tr, ranks_tr = transit_ranks( tr_signals ) \n\n # Create the databases that will be used by pyephem for calculating\n # ephemerides for each object:\n ntargets = len( targets )\n dbs = []\n for i in range( ntargets ):\n db_str = '{targ},f|S,{ra},{dec},{vmag}'.format( targ=targets[i], \\\n ra=ras[i], \\\n dec=decs[i], \\\n vmag=vmags[i] )\n dbs += [ db_str ]\n\n # Open the output file and write a header:\n if ofilename_byplanet=='default':\n if sigtype=='transits':\n ofilename_byplanet = '{0}_transits_byplanet.txt'.format( observatory )\n ofilename_chronolog = '{0}_transits_chronolog.txt'.format( observatory )\n elif sigtype=='eclipses':\n ofilename_byplanet = '{0}_eclipses_byplanet.txt'.format( observatory )\n ofilename_chronolog = '{0}_eclipses_chronolog.txt'.format( observatory ) \n else:\n pdb.set_trace() #this shouldn't happen\n\n # Create the strings that will be used for column headers:\n colheadingsa_bp, colheadingsb_bp = make_colheadings( 'byplanet' )\n colheadingsa_ch, colheadingsb_ch = make_colheadings( 'chronolog' )\n nchar_bp = np.max( [ len( colheadingsa_bp ), len( colheadingsb_bp ) ] )\n nchar_ch = np.max( [ len( colheadingsa_ch ), len( colheadingsb_ch ) ] )\n\n ofile_bp = open( ofilename_byplanet, 'w' )\n ofile_bp.write( '{0}\\n#\\n'.format( '#'*nchar_bp ) )\n\n ofile_ch = open( ofilename_chronolog, 'w' )\n ofile_ch.write( '{0}\\n#\\n#'.format( '#'*nchar_ch ) )\n \n if sigtype=='transits':\n sigtype_lower_singular = 'transit'\n sigtype_upper_singular = 'Transit'\n else:\n sigtype_lower_singular = 'eclipse'\n sigtype_upper_singular = 'Eclipse'\n\n ofile_bp.write( '# Visible primary {0}s from {1} between {2} and {3}, arranged by planet\\n#\\n'\\\n .format( sigtype_lower_singular, observatory, date_start, date_end ) )\n ofile_ch.write( '# Visible primary {0}s from {1} between {2} and {3}, arranged in chronological order\\n#\\n'\\\n .format( sigtype_lower_singular, observatory, date_start, date_end ) )\n if max_rank!=None:\n header_str = '# Only considered the top {0} ranked signals and of these only those with {1}s\\n'\\\n .format( max_rank, sigtype_lower_singular )\n header_str += '# where the mid-time occurs at a zenith angle <{0}deg\\n#\\n'\\\n .format( zenith_max )\n else:\n header_str = '# Considered all published transiting planets but output only printed where the\\n'\n header_str += '# {0} mid-time occurs at a zenith angle <{0}deg\\n#\\n'.format( zenith_max )\n if oot_deltdur>0:\n header_str += '# Accounts for {0:.2f} transit durations before and after the transit to sample\\n'.format( oot_deltdur )\n header_str += '# the out-of-transit baseline flux level\\n#\\n'\n else:\n header_str += '# No allowance made for time required to sample the out-of-transit baseline flux\\n'\n header_str += '# before and after the transit\\n#\\n'\n header_str += '# The sun elevation angle has been divided into the following ranges:\\n#\\n'\n header_str += '# 1. Maximum acceptable = {0}deg\\n'.format( sun_alt_max )\n header_str += '# 2. Dawn/Dusk = [ {0}deg to {1}deg ]\\n'.format( sun_alt_twil, sun_alt_max )\n header_str += '# 3. Twilight = [ {0}deg to {1}deg ]\\n'.format( sun_alt_dark, sun_alt_twil )\n header_str += '# 4. Dark < {0}deg\\n#\\n'.format( sun_alt_dark )\n header_str += '# {0}s are described by a string with format {{type}}-{{details}}, where:\\n#\\n'\\\n .format( sigtype_upper_singular )\n header_str += '# {{type}} refers to whether or not we get all of the {0} with the sun below its\\n'.format( sigtype_lower_singular )\n header_str += '# maximum acceptable value:\\n'\n header_str += '# - \\'full\\' if the sun elevation is less than the maximum acceptable value for the\\n'\n header_str += '# entire duration of the {0}\\n'.format( sigtype_lower_singular )\n header_str += '# - \\'partial\\' if the sun elevation is less than the maximum acceptable value at\\n'\n header_str += '# the {0} mid-time, but not for the entire duration of the {0}\\n#\\n'\\\n .format( sigtype_lower_singular )\n if oot_deltdur==0:\n header_str += '# {details} can have the following values:\\n'\n else:\n header_str += '# {{details}} refer to the full span of the observations including the {0:.2f} transit\\n'.format( oot_deltdur )\n header_str += '# durations before and after the {0} itself for sampling the baseline flux:\\n'.format( sigtype_lower_singular )\n header_str += '# - \\'all_in_darktime\\' if the sun elevation is within the dark range for the entire\\n'\n header_str += '# duration of the observations\\n'\n header_str += '# - \\'dark_to_twilight\\' if the sun elevation is within the dark range at the start\\n'\n header_str += '# of the observations and within the twilight range at the end of the observations\\n'\n header_str += '# - \\'twilight_to_dark\\' if the sun elevation is within the twilight range at the \\n'\n header_str += '# start of the observations and within the dark range at the end of the observations\\n'\n header_str += '# - \\'start_at_dusk\\' if the sun elevation is within the twilight range at the start\\n'\n header_str += '# of the observations\\n'\n header_str += '# - \\'end_at_dawn\\' if the sun elevation is within the twilight range at the end of\\n'\n header_str += '# the observations\\n'\n if oot_deltdur>0:\n header_str += '# - \\'partial_oot\\' if the sun elevation is above the maximum acceptable value at some\\n'\n header_str += '# time during either the pre- or post-{0} baseline flux observations\\n'.format( sigtype_lower_singular )\n header_str += '# - \\'miss_ingress\\' if the sun elevation is above the maximum acceptable value at\\n'\n header_str += '# ingress but below this value at egress\\n'\n header_str += '# - \\'miss_ingress\\' if the sun elevation is below the maximum acceptable value at\\n'\n header_str += '# ingress but above this value at egress\\n'\n header_str += '# - \\'only_middle\\' if the sun elevation is above the maximum acceptable value at\\n'\n header_str += '# value at both ingress and egress, but descends below this value at some point\\n'\n header_str += '# during the {0}\\n#\\n'.format( sigtype_lower_singular )\n ofile_bp.write( header_str )\n ofile_ch.write( header_str )\n\n # Create the observatory and timezone objects:\n obs, tz = setup_observatory( observatory )\n if ( obs==None ) and ( tz==None ):\n ofile_bp.close()\n os.remove( ofilename_byplanet )\n return None\n\n # Generate instances of the Sun and Moon:\n sun = ephem.Sun()\n moon = ephem.Moon()\n\n # Convert start and end dates of observing period\n # to pyephem float objects:\n date_start = ephem.Date( date_start )\n date_end = ephem.Date( date_end )\n\n # Go through the targets one-at-a-time, checking for visible transits:\n mjds = []\n date_floats = []\n outstrs_ch = []\n print '\\nCalculating visible transits for:'\n for i in range( ntargets ):\n\n print ' ... target {0:d} of {1:d} --> {2} '\\\n .format( i+1, ntargets, targets[i] )\n first_i = True\n per_i = pers[i]\n dur_i = durs[i] / 24.\n \n # Initiate the ephem object for the target:\n target_i = ephem.readdb( dbs[i] )\n\n # Check to see if the current target's signal has been ranked,\n # and if it has, make sure that it was ranked highly enough,\n # otherwise we skip to the next target straight away:\n if sigtype=='transits':\n nranked = len( targets_tr )\n for j in range( nranked ):\n if targets_tr[j]==target_i.name:\n rank_i = int( ranks_tr[j] )\n if ( max_rank!=None ):\n if ( max_rank != -1 ) * ( rank_i>max_rank ):\n include = False\n else:\n include = True\n unranked = False\n break\n else:\n if j==nranked-1:\n unranked = True\n elif sigtype=='eclipses':\n nranked = len( targets_ec )\n for j in range( nranked ):\n if targets_ec[j]==target_i.name:\n rank_i = int( ranks_ec[j] )\n if ( max_rank!=None ):\n if ( max_rank!=-1 ) * ( rank_i>max_rank ):\n include = False\n else:\n include = True\n unranked = False\n break\n else:\n if j==nranked-1:\n unranked = True\n # See if we want to skip the current target for some reason:\n if unranked==True:\n if exclude_unranked==True:\n continue\n else:\n if include==False:\n continue\n \n # Convert the JD transit time to a pyephem date:\n ttr_i = jd2pyephemdate( ttrs[i] )\n\n # If we're wanting eclipse information, approximate the eclipse\n # time by subtracting half a period (the more eccentric the orbit,\n # the worse this approximation will be):\n if sigtype=='eclipses':\n ttr_i -= 0.5 * per_i\n\n # Find the transit with mid-time occurring immediately\n # before the observing run:\n if ttr_i>date_start:\n while ttr_i>date_start:\n ttr_i -= per_i\n else:\n while ttr_i<date_start:\n ttr_i += per_i\n ttr_i -= per_i\n\n # If it's not even partially visible, start at the next transit: \n if ( ttr_i + 0.5*dur_i )<date_start:\n ttr_i += per_i\n\n # Now that we have a starting time, loop over successive transits\n # until we reach the one with mid-time immediately before the end\n # of the observing window:\n while ttr_i<date_end:\n\n # Set the UT date of the current transit within the\n # observatory object:\n obs.date = ttr_i\n\n # Update the target ephemerides and calculate its\n # elevation in the sky:\n target_i.compute( obs )\n target_i_alt_midtime = np.rad2deg( float( target_i.alt ) )\n # If the target is not above the minimum elevation, bump up to\n # the next transit and go back to the top of the loop:\n if target_i_alt_midtime<target_elev_min:\n ttr_i += per_i\n continue\n\n # Given the altitude, calculate the approximate airmass:\n zenith_i_midtime = 90 - target_i_alt_midtime\n airmass = calc_airmass( zenith_i_midtime )\n \n # Update the Sun and Moon ephemerides and work out\n # their elevations with respect to the horizon:\n sun.compute( obs )\n sun_alt_midtime = np.rad2deg( float( sun.alt ) )\n moon.compute( obs )\n moon_alt_midtime = np.rad2deg( float( moon.alt ) )\n # If the Sun is above the maximum elevation limit, bump up to\n # the next transit and go back to the top of the loop:\n if sun_alt_midtime>sun_alt_max:\n ttr_i += per_i\n continue\n # Get the Moon phase as a percentage of the illuminated face:\n moonphase = '{0:d}'.format( int( np.round( moon.phase ) ) )\n # Get the target-Moon angular separation:\n moondist = int( np.round( np.rad2deg( ephem.separation( ( target_i.az, target_i.alt ), \\\n ( moon.az, moon.alt ) ) ) ) )\n moondist = '{0:d}'.format( moondist )\n\n # If we make it to here we will consider the transit potentially\n # observable. Next, evaluate whether or not its detectability rank\n # meets our requirements:\n if first_i==True:\n\n # Write the header for the current object to the output file:\n nchar = max( [ len( colheadingsa_bp ), len( colheadingsb_bp ) ] )\n ofile_bp.write( '\\n\\n{0}\\n#\\n'.format( '#'*( nchar_bp ) ) )\n if unranked==True:\n if sigtype=='transits':\n header_str = '# {0} --> not enough information to rank primary transit signal \\n#\\n'\\\n .format( targets[i] )\n else:\n header_str = '# {0} --> not enough information to rank secondary eclipse signal \\n#\\n'\\\n .format( targets[i] )\n else:\n if sigtype=='transits':\n header_str = '# {0} --> primary transit signal ranked {1} out of {2} \\n#\\n'\\\n .format( targets[i], str( rank_i ), str( nranked ) )\n else:\n header_str = '# {0} --> secondary eclipse signal ranked {1} out of {2} \\n#\\n'\\\n .format( targets[i], str( rank_i ), str( nranked ) )\n header_str += '# RA (hh mm ss.s) Dec (dd mm ss.s)\\n'\n ra_str = ras[i].replace( ':', ' ' )\n dec_str = decs[i].replace( ':', ' ' )\n header_str += '# {0} {1}\\n#\\n'.format( ra_str, dec_str )\n header_str += colheadingsa_bp\n header_str += colheadingsb_bp\n\n ofile_bp.write( header_str )\n ofile_bp.write( '{0}{1}\\n'.format( '#', '-'*( nchar_bp-1 ) ) )\n \n first_i = False\n \n # Now we want to work out some more details about\n # what kind of transit it will be.\n\n # Determine the Sun, Moon and target elevations\n # at the start of the observations:\n obs.date = ttr_i - dur_i*( 0.5 + oot_deltdur )\n sun.compute( obs )\n sun_alt_start = np.rad2deg( float( sun.alt ) )\n moon.compute( obs )\n moon_alt_start = np.rad2deg( float( moon.alt ) )\n target_i.compute( obs )\n target_i_alt_start = np.rad2deg( float( target_i.alt ) ) \n\n # Do the same for the end of the observations:\n obs.date = ttr_i + dur_i*( 0.5 + oot_deltdur )\n sun.compute( obs )\n sun_alt_end = np.rad2deg( float( sun.alt ) )\n moon.compute( obs )\n moon_alt_end = np.rad2deg( float( moon.alt ) )\n target_i.compute( obs )\n target_i_alt_end = np.rad2deg( float( target_i.alt ) )\n\n # Determine the Sun, Moon and target elevations\n # at ingress:\n obs.date = ttr_i-0.5*dur_i\n sun.compute( obs )\n sun_alt_ingress = np.rad2deg( float( sun.alt ) )\n moon.compute( obs )\n moon_alt_ingress = np.rad2deg( float( moon.alt ) )\n target_i.compute( obs )\n target_i_alt_ingress = np.rad2deg( float( target_i.alt ) ) \n\n # Do the same for egress:\n obs.date = ttr_i+0.5*dur_i\n sun.compute( obs )\n sun_alt_egress = np.rad2deg( float( sun.alt ) )\n moon.compute( obs )\n moon_alt_egress = np.rad2deg( float( moon.alt ) )\n target_i.compute( obs )\n target_i_alt_egress = np.rad2deg( float( target_i.alt ) )\n\n # First category of transits are those where the entire transit and\n # requested out-of-transit baselines either side of ingress and egress\n # occur while the Sun is below the maximum acceptable altitude:\n if ( sun_alt_start<sun_alt_max )*( sun_alt_end<sun_alt_max ):\n\n # Case 1 = The Sun is always below our dark night time threshold:\n if ( sun_alt_start<sun_alt_dark )*( sun_alt_end<sun_alt_dark ):\n trtype = 'full-all_in_darktime'\n\n # Case 2 = The Sun remains within the twilight range for the entire transit:\n elif ( sun_alt_start>sun_alt_dark )*( sun_alt_start<sun_alt_twil )*\\\n ( sun_alt_end>sun_alt_dark )*( sun_alt_end<sun_alt_twil ):\n trtype = 'full-all_in_twilight'\n \n # Case 3 = The Sun starts low enough to be classified as twilight,\n # but not low enough to be classified dark, and by the end of the\n # transit has descended low enough to be considered dark: \n elif ( sun_alt_start<sun_alt_twil )*( sun_alt_start>sun_alt_dark )* \\\n ( sun_alt_end<sun_alt_dark ):\n trtype = 'full-twilight_to_dark'\n\n # Case 4 = The Sun starts low enough to be considered at dark, but\n # by the end of the transit it has ascended enough that it is no\n # longer considered dark but twilight instead:\n elif ( sun_alt_end<sun_alt_twil )*( sun_alt_end>sun_alt_dark)* \\\n ( sun_alt_start<sun_alt_dark ):\n trtype = 'full-dark_to_twilight'\n\n # Case 5 = At the start of the transit, the Sun is at an altitude\n # somewhere between its maximum acceptable value and the twilight\n # value, so we say the transit starts at 'dusk':\n elif ( sun_alt_start<sun_alt_max )*( sun_alt_start>sun_alt_twil ):\n trtype = 'full-start_at_dusk'\n\n # Case 6 = At the end of the transit, the Sun is at an altitude\n # somewhere between its maximum acceptable value and the twilight\n # value, so we say the transit ends at 'dawn':\n elif ( sun_alt_end<sun_alt_max )*( sun_alt_end>sun_alt_twil ):\n trtype = 'full-end_at_dawn'\n\n # Don't think there should be any other cases?\n else:\n pdb.set_trace() #if this happens, need to work out what the Case should be\n print 'backstop'\n pdb.set_trace()\n \n # The following variations describe cases where we do not get the\n # full transit plus out-of-transit baseline:\n\n elif ( sun_alt_ingress<sun_alt_max )*( sun_alt_egress<sun_alt_max ):\n\n # Case 6 = The sky darkness was within our acceptable range for the\n # full duration of the transit but we don't get the full out-of-transit\n # baseline either before or after the transit within this range:\n trtype = 'full-partial_oot'\n\n elif ( sun_alt_ingress>sun_alt_max )*( sun_alt_end<sun_alt_max ):\n\n # Case 7 = At the start of the transit, the Sun was above our minimum\n # acceptable altitude, but by the time of mid-transit it had descended\n # below this level and remained acceptable until the end of the transit:\n trtype = 'partial-miss_ingress'\n\n elif ( sun_alt_start<sun_alt_max )*( sun_alt_egress>sun_alt_max ):\n\n # Case 8 = At the start of the transit, the Sun was above our minimum\n # acceptable altitude, but by the time of mid-transit it had descended\n # below this level and remained acceptable until the end of the transit:\n trtype = 'partial-miss_egress'\n\n else:\n # Case 9 = In the case of a transit lasting longer than the entire night,\n # the Sun altitude meets the minimum requirement at the transit mid-time,\n # but it's at an unacceptable altitude for both the start and end:\n trtype = 'partial-only_middle'\n\n # Now work out if the Moon is above or below the horizon:\n if ( moon_alt_start<moon_alt_set )*( moon_alt_end<moon_alt_set ):\n moonpos = 'moon-down'\n moonphase = '-'\n moondist = '-'\n else:\n if ( moon_alt_start>0 )*( moon_alt_end>0 ):\n moonpos = 'moon-up'\n elif ( moon_alt_start<0 )*( moon_alt_end>moon_alt_set ):\n moonpos = 'moon-rising'\n elif ( moon_alt_start>moon_alt_set )*( moon_alt_end<0 ):\n moonpos = 'moon-setting'\n else:\n pdb.set_trace() #this shouldn't happen\n\n # Determine the start and end times of transit in UT: \n utc_tstart_tuple = ephem.date( ttr_i-0.5*dur_i ).tuple()\n utc_tstart_dt = datetime.datetime( int(utc_tstart_tuple[0]), \\\n int(utc_tstart_tuple[1]), \\\n int(utc_tstart_tuple[2]), \\\n int(utc_tstart_tuple[3]), \\\n int(utc_tstart_tuple[4]), \\\n int(utc_tstart_tuple[5]), \\\n tzinfo=pytz.utc )\n\n utc_tend_tuple = ephem.date( ttr_i+0.5*dur_i ).tuple()\n utc_tend_dt = datetime.datetime( int(utc_tend_tuple[0]), \\\n int(utc_tend_tuple[1]), \\\n int(utc_tend_tuple[2]), \\\n int(utc_tend_tuple[3]), \\\n int(utc_tend_tuple[4]), \\\n int(utc_tend_tuple[5]), \\\n tzinfo=pytz.utc )\n \n # Express the transit mid-time as a Modified Julian Date:\n mjd = ephem.julian_date( ttr_i ) - 2400000.5\n\n # Prepare and write output line to file:\n outstr_bp = make_outstr_bp( mjd, utc_tstart_dt, utc_tend_dt, zenith_i_midtime, \\\n airmass, trtype, moonpos, moondist, moonphase )\n ofile_bp.write( outstr_bp )\n\n # Also save the lines to be written to other chronological output file later:\n mjds += [ mjd ]\n date_floats += [ ephem.Date( utc_tstart_dt )+1.0 ] # number of days since midday on 1 Jan 1900 \n\n outstr_ch = make_outstr_ch( targets[i], mjd, utc_tstart_dt, utc_tend_dt, zenith_i_midtime, \\\n airmass, trtype, moonpos, moondist, moonphase )\n outstrs_ch += [ outstr_ch ]\n\n # Tick over to the next transit for the next loop:\n ttr_i += per_i\n\n # Now that we've identified all of the transits, sort them into\n # chronological order and write this information to output:\n header_str = '#\\n#\\n{0}\\n'.format( '#'*nchar_ch )\n header_str += colheadingsa_ch\n header_str += colheadingsb_ch\n ofile_ch.write( header_str )\n ofile_ch.write( '{0}{1}\\n'.format( '#', '-'*( nchar_ch-1 ) ) )\n mjds = np.array( mjds )\n date_floats = np.array( date_floats )\n ixs = np.argsort( mjds )\n for i in range( len( mjds ) ):\n j = ixs[i]\n df = np.floor( date_floats[j] )\n if i!=0:\n df_prev = np.floor( date_floats[ixs[i-1]] )\n if df-df_prev>=1.0:\n ofile_ch.write( '#{0}\\n'.format( '-'*( nchar_ch-1 ) ) )\n ofile_ch.write( outstrs_ch[j] )\n ofile_ch.write( '{0}{1}\\n'.format( '#', '-'*( nchar-1 ) ) )\n\n # Save the output files and finish:\n ofile_bp.close()\n ofile_ch.close()\n print '\\nSaved output in:'\n print ' %s' % ofilename_byplanet\n print ' %s' % ofilename_chronolog\n\n return ofilename_byplanet, ofilename_chronolog","def _UpdateCriteria(self):\n grad = self.traj.grad[-1]\n disp = self.traj.coords[-1] - self.traj.coords[-2]\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\n self.grad_max = numpy.amax(grad)\n self.disp_max = numpy.amax(disp)\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\n self.disp_rms = math.sqrt(numpy.mean(disp**2))","def __init__(\n self,\n newE0=None,\n newE1=None,\n newE2=None,\n newMaximumHorizontalProjection=None,\n newMaximumVerticalProjection=None,\n newEquivalentHorizontalRadius=None,\n ):\n\n # Required Keys\n if newE0 is not None:\n self.e0 = newE0\n else:\n self.e0 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\n\n if newE1 is not None:\n self.e1 = newE1\n else:\n self.e1 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\n\n if newE2 is not None:\n self.e2 = newE2\n else:\n self.e2 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\n\n if newMaximumHorizontalProjection is not None:\n self.maximumHorizontalProjection = newMaximumHorizontalProjection\n\n if newMaximumVerticalProjection is not None:\n self.maximumVerticalProjection = newMaximumVerticalProjection\n\n if newEquivalentHorizontalRadius is not None:\n self.equivalentHorizontalRadius = newEquivalentHorizontalRadius","def extractOblateEllipse(kperp,kpar,aniso):\n\n if aniso > 1.:\n #print(\"Swapping axis for oblate ellipse\")\n aniso = 1. / aniso\n\n # Define the eccentricity of the ellipse\n e = np.sqrt( 1. - aniso**2. )\n\n\n # the oblate surface area\n surface = 2. * np.pi * kperp**2. * ( 1. + ( (1. - e**2.) / e ) * np.arctanh(e) )\n\n return surface","def __init__(self, *args, **kwargs):\n try:\n geometry = kwargs['geometry']\n except:\n pass\n # ...\n dim = geometry.dim\n if dim == 1:\n func_one = lambda x : [ 1. ]\n func_zero = lambda x : [ 0. ]\n func_stiff = lambda x : [ 1. ]\n if dim == 2:\n func_one = lambda x,y : [ 1. ]\n func_zero = lambda x,y : [ 0. ]\n func_stiff = lambda x,y : [ 1., 0. \\\n , 0., 1. ]\n if dim == 3:\n func_one = lambda x,y,z : [ 1. ]\n func_zero = lambda x,y,z : [ 0. ]\n func_stiff = lambda x,y,z : [ 1., 0., 0. \\\n , 0., 1., 0. \\\n , 0., 0., 1. ]\n # ...\n\n # ...\n tc_d = {}\n tc_d['A'] = func_stiff\n tc_d['b'] = func_zero\n try:\n tc_d['AllDirichlet'] = kwargs['AllDirichlet']\n except:\n pass\n try:\n tc_d['bc_dirichlet'] = kwargs['bc_dirichlet']\n except:\n pass\n try:\n tc_d['bc_neumann'] = kwargs['bc_neumann']\n except:\n pass\n try:\n tc_d['Metric'] = kwargs['Metric']\n except:\n pass\n # ...\n\n # ...\n poisson.__init__(self, *args, **kwargs)\n self.Dn = basicPDE(geometry=geometry, testcase=tc_d)\n # ...\n\n # ...","def initialize_variables(self):\n super(D2Model, self).initialize_variables()\n\n s = \"::: initializing 2D variables :::\"\n print_text(s, cls=self)\n\n # Depth below sea level :\n class Depth(Expression):\n def eval(self, values, x):\n values[0] = abs(min(0, x[2]))\n self.D = Depth(element=self.Q.ufl_element())\n \n # Enthalpy model\n self.theta_surface = Function(self.Q, name='theta_surface')\n self.theta_float = Function(self.Q, name='theta_float')\n self.theta_app = Function(self.Q, name='theta_app')\n self.theta = Function(self.Q, name='theta')\n self.theta0 = Function(self.Q, name='theta0')\n self.W0 = Function(self.Q, name='W0')\n self.thetahat = Function(self.Q, name='thetahat')\n self.uhat = Function(self.Q, name='uhat')\n self.vhat = Function(self.Q, name='vhat')\n self.what = Function(self.Q, name='what')\n self.mhat = Function(self.Q, name='mhat')\n self.rho_b = Function(self.Q, name='rho_b')\n\n # Age model \n self.age = Function(self.Q, name='age')\n self.a0 = Function(self.Q, name='a0')\n\n # Surface climate model\n self.precip = Function(self.Q, name='precip')\n\n # Stokes-balance model :\n self.u_s = Function(self.Q, name='u_s')\n self.u_t = Function(self.Q, name='u_t')\n self.F_id = Function(self.Q, name='F_id')\n self.F_jd = Function(self.Q, name='F_jd')\n self.F_ib = Function(self.Q, name='F_ib')\n self.F_jb = Function(self.Q, name='F_jb')\n self.F_ip = Function(self.Q, name='F_ip')\n self.F_jp = Function(self.Q, name='F_jp')\n self.F_ii = Function(self.Q, name='F_ii')\n self.F_ij = Function(self.Q, name='F_ij')\n self.F_iz = Function(self.Q, name='F_iz')\n self.F_ji = Function(self.Q, name='F_ji')\n self.F_jj = Function(self.Q, name='F_jj')\n self.F_jz = Function(self.Q, name='F_jz')\n self.tau_iz = Function(self.Q, name='tau_iz')\n self.tau_jz = Function(self.Q, name='tau_jz')","def doParametersOfInterest(self):\n\n self.modelBuilder.doVar(\"Afb[0.6,-0.70,0.70]\");\n self.modelBuilder.doSet(\"POI\",\"Afb\")\n\n # ss templates\n self.modelBuilder.doVar(\"Rdy_mumu_ss[1.0,0.0,10.0]\");\n self.modelBuilder.doVar(\"Rdy_ee_ss[1.0,0.0,10.0]\");\n \n self.modelBuilder.factory_('expr::Rpl(\"(1.+@0)\",Afb)')\n self.modelBuilder.factory_('expr::Rmn(\"(1.-@0)\",Afb)')","def __init__(self,E,px,py,pz):\n Particle.__init__(self)\n self.E=float(E)\n self.px=float(px)\n self.py=float(py)\n self.pz=float(pz)\n self.cal_pt()\n self.cal_phi()\n self.cal_eta()\n #self.cal_mass()\n #print self.E,self.px,self.py,self.pz\n #print self.pt,self.phi,self.eta","def simulation_OFC(self,ncmE,ncmC,f,g,Cfun,h,dt,tf,x0,z0=None,dscale=10.0,\\\n xnames=\"num\",Ncol=1,FigSize=(20,10),FontSize=20,phis=None):\n \"\"\"\n \n \n 1) SIMULATION\n \n \n \"\"\"\n if len(sig(f).parameters) == 1:\n fun1 = f\n f = lambda x,p: fun1(x)\n if len(sig(g).parameters) == 1:\n fun2 = g\n g = lambda x,p: fun2(x)\n if len(sig(Cfun).parameters) == 1:\n fun3 = Cfun\n Cfun = lambda x,p: fun3(x)\n if len(sig(h).parameters) == 1:\n fun4 = h\n h = lambda x,p: fun4(x)\n print(\"========================================================\")\n print(\"====================== SIMULATIOM ======================\")\n print(\"========================================================\")\n if dt <= self.dt_rk:\n self.dt_rk = dt\n self.Nrk = int(dt/self.dt_rk)\n Nsim = int(tf/dt)\n np.set_printoptions(precision=1)\n print(\"time step =\",dt)\n print(\"terminal time =\",tf)\n print(\"initial state =\",x0)\n print(\"estimated initial state =\",z0)\n funx = lambda x,p,dEf: f(x,p)+dEf(x,p)\n z = z0\n zhis = np.zeros((Nsim+1,self.n))\n zhis[0,:] = z\n x = x0\n xhis = np.zeros((Nsim+1,self.n))\n xhis[0,:] = x\n tit1 = \"Performance of NCM-based Output Feedback (1)\"\n tit2 = \"Performance of NCM-based Output Feedback (2)\"\n tit3 = \"Performance of NCM-based Output Feedback (3)\"\n tit4 = \"Performance of NCM-based Output Feedback (4)\"\n ly = r\"estimation error: $\\|x-\\hat{x}\\|_2$\"\n l1 = r\"estimation error\"\n lyb = r\"tracking error: $\\|x-x_d\\|_2$\"\n l1b = r\"tracking error\"\n bNam1 = \"=================== ESTIMATION ERROR ===================\"\n bNam2 = \"============ ESTIMATION ERROR OF EACH STATE ============\"\n bNam3 = \"==================== Tracking ERROR ====================\"\n bNam4 = \"============= Tracking ERROR OF EACH STATE =============\"\n l2 = r\"optimal steady-state upper bound\"\n if phis == None:\n phis = np.linspace(self.plims[0,:],self.plims[1,:],Nsim)\n for k in range(Nsim):\n p = phis[k,:]\n Mc = ncmC.ncm(z,p)\n u = -g(z,p).T@Mc@z\n dEfC = lambda x,p: g(x,p)@u\n d1 = self.unifrand2(ncmC.d1_over,np.size(ncmC.Bw(x,p),1))*dscale\n x = self.rk4(x,p,dEfC,funx)+ncmC.Bw(x,p)@d1*dt\n xhis[k+1,:] = x\n Me = ncmE.ncm(z,p)\n Cx = Cfun(z,p)\n Lx = Me@Cx.T\n #Lx = K.T\n d2 = self.unifrand2(ncmE.d2_over,np.size(ncmE.Gw(x,p),1))*dscale\n y = h(x,u,p)+ncmE.Gw(x,p)@d2\n funz = lambda z,p,dEf: f(z,p)+g(z,p)@u+dEf(z,p)\n dEfE = lambda z,p: Lx@(y-h(z,u,p))\n z = self.rk4(z,p,dEfE,funz)\n zhis[k+1,:] = z\n this = np.linspace(0,tf,Nsim+1)\n \"\"\"\n \n \n 2) FIGURE GENERATION\n \n \n \"\"\"\n print(\"========================================================\")\n print(bNam1)\n print(\"========================================================\")\n matplotlib.rcParams.update({\"font.size\": 15})\n matplotlib.rc(\"text\",usetex=True)\n plt.figure()\n plt.plot(this,np.sqrt(np.sum((xhis-zhis)**2,1)))\n plt.plot(this,np.ones(np.size(this))*ncmE.Jcv_opt)\n plt.xlabel(r\"time\",fontsize=FontSize)\n plt.ylabel(ly,fontsize=FontSize)\n plt.legend([l1,l2],loc=\"best\")\n plt.title(tit1,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam2)\n print(\"========================================================\")\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\n if Ncol == 1:\n ax = np.reshape(ax,(self.n,1))\n elif Nrow == 1:\n ax = np.reshape(ax,(1,self.n))\n if xnames == \"num\":\n xnames = []\n for i in range(self.n):\n xnames += [r\"state \"+str(i+1)]\n for row in range(Nrow):\n for col in range(Ncol):\n i = Ncol*row+col\n if i+1 <= self.n:\n ax[row,col].plot(this,xhis[:,i]-zhis[:,i])\n ax[row,col].set_xlabel(r\"time\",fontsize=FontSize)\n LabelName = r\"estimation error: \"+xnames[i]\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\n fig.suptitle(tit2,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam3)\n print(\"========================================================\")\n matplotlib.rcParams.update({\"font.size\": 15})\n matplotlib.rc(\"text\",usetex=True)\n plt.figure()\n plt.plot(this,np.sqrt(np.sum((xhis)**2,1)))\n plt.plot(this,np.ones(np.size(this))*ncmC.Jcv_opt)\n plt.xlabel(r\"time\",fontsize=FontSize)\n plt.ylabel(lyb,fontsize=FontSize)\n plt.legend([l1b,l2],loc=\"best\")\n plt.title(tit3,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(bNam4)\n print(\"========================================================\")\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\n if Ncol == 1:\n ax = np.reshape(ax,(self.n,1))\n elif Nrow == 1:\n ax = np.reshape(ax,(1,self.n))\n if xnames == \"num\":\n xnames = []\n for i in range(self.n):\n xnames += [r\"state \"+str(i+1)]\n for row in range(Nrow):\n for col in range(Ncol):\n i = Ncol*row+col\n if i+1 <= self.n:\n ax[row,col].plot(this,xhis[:,i])\n ax[row,col].set_xlabel(r\"time\",fontsize=FontSize)\n LabelName = r\"tracking error: \"+xnames[i]\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\n fig.suptitle(tit4,fontsize=FontSize)\n plt.show()\n print(\"========================================================\")\n print(\"==================== SIMULATIOM END ====================\")\n print(\"========================================================\")\n return this,xhis,zhis","def projected():\n # pull updated list of donors(class)\n projected_list = create_donors_list()\n print('''Welcome to the Projection Option. Here you can run projections for contributions. \n Help Companies structure their matching donations based on past contribution amounts.\n Simply enter the minumum and maximum donation range that will be matched and see the total contribution:''')\n try:\n minimum_input = float(\n input('Enter a minimum donation amount (0 if none): '))\n maximum_input = float(\n input('Enter a maximum donation amount (0 if none): '))\n factor = float(\n input('Please enter the factor you wish to multiply these donations by >> '))\n except ValueError:\n print('Please follow instructions and enter a number only')\n\n projections = projection(projected_list, factor,\n minimum_input, maximum_input)\n print('\\nProjected contribution value: ${:,.2f}'.format(projections))"],"string":"[\n \"def Projection(W, TYPE_PROJ = proj_l11ball, ETA = 100, AXIS = 0, ETA_STAR = 100, device = \\\"cpu\\\" ): \\n \\n #global TYPE_PROJ, ETA, ETA_STAR, AXIS, device \\n if TYPE_PROJ == 'No_proj':\\n W_new = W\\n if (TYPE_PROJ == proj_l1ball or TYPE_PROJ == proj_l11ball or TYPE_PROJ == proj_l11ball_line ):\\n W_new = TYPE_PROJ(W, ETA, device)\\n if TYPE_PROJ == proj_l21ball or TYPE_PROJ == proj_l12ball:\\n W_new = TYPE_PROJ(W, ETA, AXIS, device = device)\\n if TYPE_PROJ == proj_nuclear:\\n W_new = TYPE_PROJ(W, ETA_STAR, device=device)\\n return W_new\",\n \"def doParametersOfInterest(self):\\n \\n self.modelBuilder.doVar('expr::cosW(\\\"0.87681811112\\\",)')\\n self.modelBuilder.doVar('expr::sinW(\\\"0.48082221247\\\",)')\\n self.modelBuilder.doVar('expr::mZ(\\\"91.2\\\",)')\\n self.modelBuilder.doVar('expr::Lambda1(\\\"100.0\\\",)')\\n self.modelBuilder.doVar('expr::e2(\\\"0.0917\\\",)')\\n self.modelBuilder.doVar('expr::gs2(\\\"1.533\\\",)')\\n\\n # EFT Higgs basis couplings\\n\\n self.modelBuilder.doVar('cZ[0,-1,1]') \\n self.modelBuilder.doVar(\\\"cZZ[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZZt[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZB[0,-6,6]\\\") \\n\\n poi='cZ,cZZ,cZZt,cZB'\\n\\n # Amplitude couplings from EFT couplings \\n\\n self.modelBuilder.doVar('expr::a1(\\\"@0+1\\\",cZ)') # (\\\"2*(@0+1)\\\",cZ) in AN/Paper but a1 = 1 for signal model and width calculation\\n self.modelBuilder.doVar('expr::a2(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZ,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::a3(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZt,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::k1(\\\"@0*(@1*pow(@2,2)/(pow(@3,2)*pow(@4,2)))\\\",cZB,e2,Lambda1,sinW,mZ)')\\n self.modelBuilder.doVar('expr::k1L1(\\\"@0/pow(@1,2)\\\",k1,Lambda1)')\\n\\n ###### gamma_H ########\\n\\n # SMEFT relationships for VV couplings (Expressed using amplitude couplings)\\n\\n self.modelBuilder.doVar('expr::kappa(\\\"1.0\\\",)')\\n self.modelBuilder.doVar('expr::kappa_tilde(\\\"0.0\\\",)') \\n\\n self.modelBuilder.doVar('expr::a1_WW(\\\"@0\\\",a1)')\\n self.modelBuilder.doVar('expr::a2_WW(\\\"@0*@0*@1\\\",cosW,a2)')\\n self.modelBuilder.doVar('expr::a3_WW(\\\"@0*@0*@1\\\",cosW,a3)')\\n self.modelBuilder.doVar('expr::k1_WW(\\\"(@2 / (@0*@0 - @1*@1) - 2*@1*@1*@3*@4*@4 /(@5*@5*(@0*@0 - @1*@1)))\\\",cosW,sinW,k1,a2,Lambda1,mZ)')\\n self.modelBuilder.doVar('expr::k2_k1(\\\"2*@0*@1*@2/(@0*@0 - @1*@1)\\\",cosW,sinW,k1)')\\n self.modelBuilder.doVar('expr::k2_a2(\\\"-2*@0*@1*@3*@4*@4/((@2*@2)*(@0*@0 - @1*@1))\\\",cosW,sinW,mZ,a2,Lambda1)')\\n self.modelBuilder.doVar('expr::k2(\\\"@0 + @1\\\",k2_k1,k2_a2)')\\n\\n # Determine gamma_H from VV couplings\\n\\n zz_expr = '\\\"4*(@0*@0/4. + 0.1695*@3*@3 + 0.09076*@1*@1 + 0.03809*@2*@2 + 0.8095*@0*@3/2. + 0.5046*@0*@1/2. + 0.2092*@1*@3 + 0.1023*@4*@4 + 0.1901*@0*@4/2. + 0.07429*@3*@4 + 0.04710*@1*@4) \\\",a1,a2,a3,k1,k2'\\n ww_expr = '\\\"4*(@0*@0/4. + 0.1320*@3*@3 + 0.1944*@1*@1 + 0.08075*@2*@2 + 0.7204*@0*@3/2. + 0.7437*@0*@1/2. + 0.2774*@3*@1) \\\",a1_WW,a2_WW,a3_WW,k1_WW'\\n zgamma_expr = '\\\"4*(1.118600*@0*@0/4. +0.0035*@1*@1 - 0.125010*@0*@1/2. + 0.000003*@1*@1 - 0.00018*@1*@1 + 0.003100*@0*@1/2. +0.00126*@2*@2 + 0.000005*@2*@2 -0.00047*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n gg_expr = '\\\"(1.1068*@0*@0 + 0.0082*@0*@0 - 0.1150*@0*@0 + 2.5717*@1*@1 + 0.0091*@1*@1 - 0.1982*@1*@1)\\\",kappa,kappa_tilde'\\n bb_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n cc_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n tautau_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n mumu_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n gmgm_expr = '\\\"4*(1.6054*@0*@0/4. + 0.07312*@1*@1 - 0.6854*@0*@1/2. + 0.00002*@1*@1 - 0.0018*@1*@1 + 0.0085*@0*@1/2. + 0.1699*@2*@2 + 0.00002*@2*@2 - 0.0031*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n \\n self.modelBuilder.doVar('expr::R_WW('+str(ww_expr)+')')\\n self.modelBuilder.doVar('expr::R_ZZ('+str(zz_expr)+')')\\n self.modelBuilder.doVar('expr::R_Zgamma('+str(zgamma_expr)+')')\\n self.modelBuilder.doVar('expr::R_gg('+str(gg_expr)+')')\\n self.modelBuilder.doVar('expr::R_bb('+str(bb_expr)+')')\\n self.modelBuilder.doVar('expr::R_cc('+str(cc_expr)+')')\\n self.modelBuilder.doVar('expr::R_tautau('+str(tautau_expr)+')')\\n self.modelBuilder.doVar('expr::R_mumu('+str(mumu_expr)+')')\\n self.modelBuilder.doVar('expr:R_gammagamma('+str(gmgm_expr)+')')\\n\\n self.modelBuilder.doVar('expr::gammaH(\\\"(0.5824*@0 + 0.2137*@1 + 0.08187*@2 + 0.06272*@3 + 0.02891*@4 + 0.02619*@5 + 0.002270*@6 + 0.001533*@7 + 0.0002176*@8 )/0.9998\\\",R_bb,R_WW,R_gg,R_tautau,R_cc,R_ZZ,R_gammagamma,R_Zgamma,R_mumu)') \\n\\n ###########################\\n\\n self.g1V = GetCoupTerms(1,1,1,-0.0001,\\\"1V\\\") # Compensate for scaling of k1 templates \\n self.g2V = GetCoupTerms(1,1,1,-0.0001,\\\"2V\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g2V_1(\\\\\\\"\\\"+str(self.g2V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1(\\\\\\\"((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1_Neg(\\\\\\\"-1*((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_2(\\\\\\\"\\\"+str(self.g2V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2(\\\\\\\"((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2_Neg(\\\\\\\"-1*((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_3(\\\\\\\"\\\"+str(self.g2V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3(\\\\\\\"((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_4(\\\\\\\"\\\"+str(self.g2V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4(\\\\\\\"((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4_Neg(\\\\\\\"-1*((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_5(\\\\\\\"\\\"+str(self.g2V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5(\\\\\\\"((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5_Neg(\\\\\\\"-1*((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_6(\\\\\\\"\\\"+str(self.g2V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6(\\\\\\\"((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6_Neg(\\\\\\\"-1*((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_7(\\\\\\\"\\\"+str(self.g2V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7(\\\\\\\"((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_8(\\\\\\\"\\\"+str(self.g2V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8(\\\\\\\"((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8_Neg(\\\\\\\"-1*((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_9(\\\\\\\"\\\"+str(self.g2V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9(\\\\\\\"((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9_Neg(\\\\\\\"-1*((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_10(\\\\\\\"\\\"+str(self.g2V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10(\\\\\\\"((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10_Neg(\\\\\\\"-1*((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_11(\\\\\\\"\\\"+str(self.g2V[10])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11(\\\\\\\"((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_12(\\\\\\\"\\\"+str(self.g2V[11])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12(\\\\\\\"((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12_Neg(\\\\\\\"-1*((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_13(\\\\\\\"\\\"+str(self.g2V[12])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13(\\\\\\\"((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13_Neg(\\\\\\\"-1*((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_14(\\\\\\\"\\\"+str(self.g2V[13])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14(\\\\\\\"((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14_Neg(\\\\\\\"-1*((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_15(\\\\\\\"\\\"+str(self.g2V[14])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15(\\\\\\\"((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_16(\\\\\\\"\\\"+str(self.g2V[15])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16(\\\\\\\"((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16_Neg(\\\\\\\"-1*((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_17(\\\\\\\"\\\"+str(self.g2V[16])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17(\\\\\\\"((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17_Neg(\\\\\\\"-1*((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_18(\\\\\\\"\\\"+str(self.g2V[17])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18(\\\\\\\"((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_19(\\\\\\\"\\\"+str(self.g2V[18])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19(\\\\\\\"((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19_Neg(\\\\\\\"-1*((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_20(\\\\\\\"\\\"+str(self.g2V[19])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20(\\\\\\\"((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20_Neg(\\\\\\\"-1*((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_21(\\\\\\\"\\\"+str(self.g2V[20])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21(\\\\\\\"((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21_Neg(\\\\\\\"-1*((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_22(\\\\\\\"\\\"+str(self.g2V[21])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22(\\\\\\\"((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22_Neg(\\\\\\\"-1*((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_23(\\\\\\\"\\\"+str(self.g2V[22])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23(\\\\\\\"((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23_Neg(\\\\\\\"-1*((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_24(\\\\\\\"\\\"+str(self.g2V[23])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24(\\\\\\\"((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_25(\\\\\\\"\\\"+str(self.g2V[24])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25(\\\\\\\"((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_26(\\\\\\\"\\\"+str(self.g2V[25])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26(\\\\\\\"((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26_Neg(\\\\\\\"-1*((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_27(\\\\\\\"\\\"+str(self.g2V[26])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27(\\\\\\\"((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_28(\\\\\\\"\\\"+str(self.g2V[27])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28(\\\\\\\"((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_29(\\\\\\\"\\\"+str(self.g2V[28])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29(\\\\\\\"((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29_Neg(\\\\\\\"-1*((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_30(\\\\\\\"\\\"+str(self.g2V[29])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30(\\\\\\\"((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30_Neg(\\\\\\\"-1*((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_31(\\\\\\\"\\\"+str(self.g2V[30])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31(\\\\\\\"((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31_Neg(\\\\\\\"-1*((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_32(\\\\\\\"\\\"+str(self.g2V[31])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32(\\\\\\\"((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32_Neg(\\\\\\\"-1*((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_33(\\\\\\\"\\\"+str(self.g2V[32])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33(\\\\\\\"((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33_Neg(\\\\\\\"-1*((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_34(\\\\\\\"\\\"+str(self.g2V[33])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34(\\\\\\\"((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34_Neg(\\\\\\\"-1*((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_35(\\\\\\\"\\\"+str(self.g2V[34])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35(\\\\\\\"((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35_Neg(\\\\\\\"-1*((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g1V_1(\\\\\\\"\\\"+str(self.g1V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1(\\\\\\\"((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1_Neg(\\\\\\\"-1*((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_2(\\\\\\\"\\\"+str(self.g1V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2(\\\\\\\"((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2_Neg(\\\\\\\"-1*((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_3(\\\\\\\"\\\"+str(self.g1V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3(\\\\\\\"((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3_Neg(\\\\\\\"-1*((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_4(\\\\\\\"\\\"+str(self.g1V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4(\\\\\\\"((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4_Neg(\\\\\\\"-1*((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_5(\\\\\\\"\\\"+str(self.g1V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5(\\\\\\\"((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5_Neg(\\\\\\\"-1*((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_6(\\\\\\\"\\\"+str(self.g1V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6(\\\\\\\"((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6_Neg(\\\\\\\"-1*((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_7(\\\\\\\"\\\"+str(self.g1V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7(\\\\\\\"((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7_Neg(\\\\\\\"-1*((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_8(\\\\\\\"\\\"+str(self.g1V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8(\\\\\\\"((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8_Neg(\\\\\\\"-1*((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_9(\\\\\\\"\\\"+str(self.g1V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9(\\\\\\\"((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9_Neg(\\\\\\\"-1*((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_10(\\\\\\\"\\\"+str(self.g1V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10(\\\\\\\"((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10_Neg(\\\\\\\"-1*((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n \\n self.modelBuilder.doSet(\\\"POI\\\",poi)\",\n \"def __init__(self, folder):\\n print \\\"folder passed is \\\", folder\\n self.folder = folder\\n self.geometry = gf.geometry(self.folder)\\n self.elements = gf.dictionary_set()\\n self.area = np.zeros(shape = (8))\\n self.Vol = (self.geometry.properties['span_number']*(self.geometry.properties['span_width']*\\n self.geometry.properties['span_height'] + self.geometry.properties['cover_height']\\n *self.geometry.properties['span_width']/2))\\n self.F = np.zeros(shape = (8, 8))\\n of.view_factor(self.geometry, self.F, self.area, self.Vol)\\n tran = [self.geometry.properties['tra_cover_out'],0.0,0.0,\\n self.geometry.properties['tra_sidewall_out'],\\n self.geometry.properties['tra_cover_in'],\\n self.geometry.properties['tra_sidewall_in'],0.0,0.0]\\n emi = [self.geometry.properties['emi_cover_out'],1.0,1.0,\\n self.geometry.properties['emi_sidewall_out'],\\n self.geometry.properties['emi_cover_in'],\\n self.geometry.properties['emi_sidewall_in'],1.0,1.0] \\n self.tr, self.em, self.re = of.optictal_prop(tran,emi)\\n if ((self.tr + self.em).any() > 1.0):\\n print \\\"error in optical properties\\\"\\n self.T = np.zeros(shape = (2,10))\\n self.RH = np.zeros(shape = (2,10))\\n # 8 inside,9 outside \\n self.qcond = np.zeros(shape = (2,8))\\n self.qconv = np.zeros(shape = (2,8))\\n self.qrad = np.zeros(shape = (2,8))\\n self.j = np.zeros(shape = (2,8))\\n self.g = np.zeros(shape = (2,8))\\n self.alpha = np.zeros(shape = (2,8))\\n deltaT = 300\\n RH_in = 0.6\\n fg.set_initial_conditions(self.geometry.properties['t_air_inside'],\\n 278,\\n RH_in,self.T,self.RH , self.geometry.properties['t_air'],self.g,\\n self.geometry.properties['sky_temp'])\\n self.T, self.j, self.g, self.alpha, self.qrad, self.qconv = fg.solver_T(self.T,self.qrad,self.qconv,self.alpha,self.j,self.g,self.em,self.tr,\\n self.geometry.properties['wind_speed'],\\n self.F,self.geometry.properties['heat_flux'],1,1.0,self.area,\\n self.geometry.properties['rho'],self.geometry.properties['cp'],\\n self.Vol,self.geometry.properties['degree_window'],deltaT)\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"eAfb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"eA0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doVar(\\\"dAfb[0.,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"dA0[0.0, -1.0, 1.0]\\\");\\n #self.modelBuilder.doSet(\\\"POI\\\",\\\"dAfb,dA0\\\")\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"dAfb\\\")\\n self.modelBuilder.factory_('expr::mAfb(\\\"@0+@1\\\",eAfb,dAfb)')\\n self.modelBuilder.factory_('expr::mA0(\\\"(@0+@1)\\\",eA0,dA0)')\\n\\n \\n self.modelBuilder.factory_('expr::eAlph(\\\"2.0*@0/(2.0-@0)\\\",eA0)')\\n self.modelBuilder.factory_('expr::eNorm(\\\"3.0/4.0/(2.0+@0)\\\",eAlph)')\\n self.modelBuilder.factory_('expr::eRAlph(\\\"@0*@1\\\",eAlph,eNorm)')\\n self.modelBuilder.factory_('expr::eRpl(\\\"(@0+@1)\\\",eNorm,eAfb)')\\n self.modelBuilder.factory_('expr::eRmn(\\\"(@0-@1)\\\",eNorm,eAfb)')\\n\\n self.modelBuilder.factory_('expr::mAlph(\\\"2.0*@0/(2.0-@0)\\\",mA0)')\\n self.modelBuilder.factory_('expr::mNorm(\\\"3.0/4.0/(2.0+@0)\\\",mAlph)')\\n self.modelBuilder.factory_('expr::mRAlph(\\\"@0*@1\\\",mAlph,mNorm)')\\n self.modelBuilder.factory_('expr::mRpl(\\\"(@0+@1)\\\",mNorm,mAfb)')\\n self.modelBuilder.factory_('expr::mRmn(\\\"(@0-@1)\\\",mNorm,mAfb)')\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"eAfb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"eA0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doVar(\\\"rAfb[1.0,-5.0, 5.0]\\\");\\n self.modelBuilder.doVar(\\\"rA0[1.0, -5.0, 5.0]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"rAfb,rA0\\\")\\n self.modelBuilder.factory_('expr::mAfb(\\\"@0*@1\\\",eAfb,rAfb)')\\n self.modelBuilder.factory_('expr::mA0(\\\"(@0*@1)\\\",eA0,rA0)')\\n\\n \\n self.modelBuilder.factory_('expr::eAlph(\\\"2.0*@0/(2.0-@0)\\\",eA0)')\\n self.modelBuilder.factory_('expr::eNorm(\\\"3.0/4.0/(2.0+@0)\\\",eAlph)')\\n self.modelBuilder.factory_('expr::eRAlph(\\\"@0*@1\\\",eAlph,eNorm)')\\n self.modelBuilder.factory_('expr::eRpl(\\\"(@0+@1)\\\",eNorm,eAfb)')\\n self.modelBuilder.factory_('expr::eRmn(\\\"(@0-@1)\\\",eNorm,eAfb)')\\n\\n self.modelBuilder.factory_('expr::mAlph(\\\"2.0*@0/(2.0-@0)\\\",mA0)')\\n self.modelBuilder.factory_('expr::mNorm(\\\"3.0/4.0/(2.0+@0)\\\",mAlph)')\\n self.modelBuilder.factory_('expr::mRAlph(\\\"@0*@1\\\",mAlph,mNorm)')\\n self.modelBuilder.factory_('expr::mRpl(\\\"(@0+@1)\\\",mNorm,mAfb)')\\n self.modelBuilder.factory_('expr::mRmn(\\\"(@0-@1)\\\",mNorm,mAfb)')\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"eAfb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"eA0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doVar(\\\"mAfb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"mA0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"eAfb,mAfb\\\")\\n\\n \\n self.modelBuilder.factory_('expr::eAlph(\\\"2.0*@0/(2.0-@0)\\\",eA0)')\\n self.modelBuilder.factory_('expr::eNorm(\\\"3.0/4.0/(2.0+@0)\\\",eAlph)')\\n self.modelBuilder.factory_('expr::eRAlph(\\\"@0*@1\\\",eAlph,eNorm)')\\n self.modelBuilder.factory_('expr::eRpl(\\\"(@0+@1)\\\",eNorm,eAfb)')\\n self.modelBuilder.factory_('expr::eRmn(\\\"(@0-@1)\\\",eNorm,eAfb)')\\n\\n self.modelBuilder.factory_('expr::mAlph(\\\"2.0*@0/(2.0-@0)\\\",mA0)')\\n self.modelBuilder.factory_('expr::mNorm(\\\"3.0/4.0/(2.0+@0)\\\",mAlph)')\\n self.modelBuilder.factory_('expr::mRAlph(\\\"@0*@1\\\",mAlph,mNorm)')\\n self.modelBuilder.factory_('expr::mRpl(\\\"(@0+@1)\\\",mNorm,mAfb)')\\n self.modelBuilder.factory_('expr::mRmn(\\\"(@0-@1)\\\",mNorm,mAfb)')\",\n \"def new_param_energy(coords, params, topology, vecs, P=1.01, T=293.15,NPT=False,V=None,P_conv=1.e5,V_conv=1.e-6,Ener_conv=1.e-3,N_part=250.):\\n\\n #-------------------\\n # CONSTANTS\\n #-------------------\\n kB = 0.0083145 #Boltzmann constant (Gas constant) in kJ/(mol*K)\\n beta = 1/(kB*T)\\n\\n #-------------------\\n # PARAMETERS\\n #-------------------\\n params = params\\n\\n mol2files = []\\n for i in params:\\n mol2files.append('../monomers/'+i.rsplit(' ',1)[0]+'.mol2')\\n\\n flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield\\n mols = []\\n mol = oechem.OEMol()\\n for mol2file in mol2files:\\n ifs = oechem.oemolistream(mol2file)\\n ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)\\n mol = oechem.OEGraphMol()\\n while oechem.OEReadMolecule(ifs, mol):\\n oechem.OETriposAtomNames(mol)\\n mols.append(oechem.OEGraphMol(mol))\\n K = len(params['cyclohexane'].keys())\\n \\n # Load forcefield file\\n #ffxml = 'smirnoff99Frosst_with_AllConstraints.ffxml'#\\n #print('The forcefield being used is smirnoff99Frosst_with_AllConstraints.ffxml')\\n ffxml = get_data_filename('forcefield/smirnoff99Frosst.ffxml')\\n print('The forcefield being used is smirnoff99Frosst.ffxml')\\n\\n ff = ForceField(ffxml)\\n\\n # Generate a topology\\n top = topology#generateTopologyFromOEMol(mol)\\n\\n #-----------------\\n # MAIN\\n #-----------------\\n\\n # Calculate energies\\n\\n E_kn = np.zeros([K,len(coords)],np.float64)\\n u_kn = np.zeros([K,len(coords)],np.float64)\\n for i,j in enumerate(params):\\n AlkEthOH_id = j\\n for k,l in enumerate(params[AlkEthOH_id]):\\n print(\\\"Anotha one\\\")\\n for m,n in enumerate(params[AlkEthOH_id][l]):\\n newparams = ff.getParameter(smirks=n[0])\\n newparams[n[1]]=n[2]\\n ff.setParameter(newparams,smirks=n[0])\\n system = ff.createSystem(top,mols,nonbondedMethod=PME,nonbondedCutoff=1.125*nanometers,ewaldErrorTolerance=1.e-5)\\n barostat = MonteCarloBarostat(P*bar, T*kelvin, 10)\\n system.addForce(barostat)\\n for o,p in enumerate(coords):\\n e = get_energy(system,p,vecs[o])\\n \\n if not NPT:\\n E_kn[k,o] = e._value\\n u_kn[k,o] = e._value*beta\\n else:\\n E_kn[k,o] = e._value + P*P_conv*V[o]*V_conv*Ener_conv*N_part\\n u_kn[k,o] = (e._value + P*P_conv*V[o]*V_conv*Ener_conv*N_part)*beta\\n \\n return E_kn,u_kn\",\n \"def _init_projection(self):\\n radius = 6370e3\\n \\n # Spherical latlon used by WRF\\n self.latlon_sphere = pyproj.Proj(proj='latlong',\\n a=radius, b=radius, towgs84='0,0,0', no_defs=True)\\n\\n # Lambert Conformal Conic used by WRF\\n self.lambert_grid = pyproj.Proj(proj='lcc',\\n lat_1=self.truelats[0],\\n lat_2=self.truelats[1],\\n lat_0=self.ref_latlon[0],\\n lon_0=self.stand_lon,\\n a=radius, b=radius, towgs84='0,0,0', no_defs=True)\\n\\n grid_size_i = (self.domain_size[0] - 2) * self.cell_size[0]\\n grid_size_j = (self.domain_size[1] - 2) * self.cell_size[1]\\n\\n grid_center_i, grid_center_j = pyproj.transform(\\n self.latlon_sphere, self.lambert_grid,\\n self.ref_latlon[1], self.ref_latlon[0])\\n \\n self.offset_i = grid_center_i - grid_size_i * .5\\n self.offset_j = grid_center_j - grid_size_j * .5\",\n \"def find_eta_projection(self):\\r\\n \\r\\n # Get temporal range in terms of years\\r\\n timedelta = self.year_E_fore_gov[self.elms_E_fore_gov] - self.year_E_fore_gov[self.elms_E_fore_gov][0]\\r\\n # Number of years over time\\r\\n num_years = len(timedelta)\\r\\n \\r\\n self.t_eta_fit = np.zeros(num_years)\\r\\n \\r\\n for yr in range(0,num_years):\\r\\n \\r\\n self.t_eta_fit[yr] = timedelta[yr].days/365.25\\r\\n \\r\\n \\r\\n popt, _ = curve_fit(model_expected_eta,self.t_eta_fit,self.eta_gdp_fore[self.elms_E_fore_gov],p0=(0.7,0.1,0.01))\\r\\n \\r\\n self.eta_0 = popt[0]\\r\\n self.eta_b = popt[1]\\r\\n self.xi = popt[2]\\r\\n self.eta = model_expected_eta(self.t,self.eta_0,self.eta_b,self.xi)\\r\\n \\r\\n self.E_noncovid = model_emissions(self.eta,self.Y_noncovid)\\r\\n \\r\\n return\",\n \"def get_sol(self):\",\n \"def doParametersOfInterest(self):\\r\\n if self.fg4fixed:\\r\\n self.modelBuilder.doVar(\\\"CMS_zz4l_fg4[0]\\\")\\r\\n self.modelBuilder.doVar(\\\"r[1,0,4]\\\")\\r\\n print \\\"Fixing CMS_zz4l_fg4\\\"\\r\\n poi = \\\"r\\\"\\r\\n else:\\r\\n if self.modelBuilder.out.var(\\\"CMS_zz4l_fg4\\\"):\\r\\n print \\\"have fg4 inside\\\"\\r\\n else:\\r\\n self.modelBuilder.doVar(\\\"CMS_zz4l_fg4[0.,-1,1]\\\")\\r\\n poi = \\\"CMS_zz4l_fg4\\\"\\r\\n if self.cPOI:\\r\\n if self.modelBuilder.out.var(\\\"cww_zz\\\"):\\r\\n print \\\"have czz_ww inside\\\"\\r\\n else:\\r\\n self.modelBuilder.doVar(\\\"cww_zz[0.5,-10,10]\\\")\\r\\n poi += \\\",cww_zz\\\"\\r\\n\\r\\n if self.fg2POI:\\r\\n if self.modelBuilder.out.var(\\\"CMS_zz4l_fg2\\\"):\\r\\n print \\\"have fg2 inside\\\"\\r\\n else:\\r\\n self.modelBuilder.doVar(\\\"CMS_zz4l_fg2[0.,0,1]\\\")\\r\\n poi += \\\",CMS_zz4l_fg2\\\"\\r\\n if self.muFloating:\\r\\n self.modelBuilder.doVar(\\\"r[1,0,2000]\\\")\\r\\n if self.muAsPOI:\\r\\n print \\\"Treating r as a POI\\\"\\r\\n poi += \\\",r\\\"\\r\\n else:\\r\\n self.modelBuilder.out.var(\\\"r\\\").setAttribute(\\\"flatParam\\\")\\r\\n if self.phiFloating:\\r\\n if self.modelBuilder.out.var(\\\"CMS_zz4l_fg4phi\\\"):\\r\\n print \\\"have fg4phi inside\\\"\\r\\n else: \\r\\n self.modelBuilder.doVar(\\\"CMS_zz4l_fg4phi[0.,-3.1415926,3.1415926]\\\")\\r\\n if self.phiPOI:\\r\\n poi += \\\",CMS_zz4l_fg4phi\\\"\\r\\n else:\\r\\n self.modelBuilder.out.var(\\\"CMS_zz4l_fg4phi\\\").setAttribute(\\\"flatParam\\\")\\r\\n if self.phi2Floating:\\r\\n #self.modelBuilder.doVar(\\\"CMS_zz4l_fg4phi[0.,-math.pi,math.pi]\\\")\\r\\n if self.modelBuilder.out.var(\\\"CMS_zz4l_fg2phi\\\"):\\r\\n print \\\"have fg2phi inside\\\"\\r\\n else: \\r\\n self.modelBuilder.doVar(\\\"CMS_zz4l_fg2phi[0.,-3.1415926,3.1415926]\\\")\\r\\n self.modelBuilder.out.var(\\\"CMS_zz4l_fg2phi\\\").setAttribute(\\\"flatParam\\\")\\r\\n \\r\\n self.modelBuilder.doSet(\\\"POI\\\",poi)\",\n \"def SOM(args):\\n\\n # Obtain the normalized set of cities (w/ coord in [0,1])\\n cities = pd.read_csv(Path(args.data_dir) / 'data1.csv')\\n\\n iteration = args.iteration\\n learning_rate = args.learning_rate\\n decay = args.decay\\n\\n out_dir = Path(args.out_dir)\\n out_dir.mkdir_p()\\n\\n cities_nm = cities.copy()\\n\\n cities_nm[['x', 'y']] = normalize(cities_nm[['x', 'y']])\\n cities_nm.to_csv(out_dir/'cities_nm.csv')\\n cities.to_csv(out_dir/'cities.csv')\\n\\n\\n depot = cities_nm.query('city==0')[['x','y']].to_numpy()\\n # The population size is 8 times the number of cities\\n #n = cities_cp.shape[0] * 2# a single route's neurons\\n n=100\\n # Generate an adequate network of neurons:\\n #network = generate_network(n)\\n neuron_chains =init_neurons(size=n,depot=depot)\\n print('--> Network of {} neurons created. Starting the iterations:'.format(n))\\n best_routes=np.array([0])\\n\\n #save\\n losses_sum_log={}#每个循环losses_sum值\\n min_losses_sum_log = {}##保存最小值的路径losses\\n min_losses_log={}#存储最好情况下四条路径的距离值\\n min_routes_log={}\\n best_id=0\\n min_losses_sum=0\\n\\n for i in tqdm(range(iteration)):\\n if not i % args.neuro_plot_freq:\\n print('\\\\t> Iteration {}/{}'.format(i, iteration), end=\\\"\\\\r\\\")\\n # Choose a random city\\n sample = cities_nm.sample(1)\\n if int(sample['city']) in args.depot_idxs:\\n continue\\n city = sample[['x', 'y']].values#随机抽样 random sampling\\n group_idx,winner_idx = select_closest_gpid(neuron_chains, city)\\n\\n # Generate a filter that applies changes to the winner's gaussian\\n gaussian = get_neighborhood(center=winner_idx, radix=n//10, domain=neuron_chains[0].shape[0])\\n # Update the network's weights (closer to the city)\\n neuron_chains[group_idx] += gaussian[:,np.newaxis] * learning_rate * (city - neuron_chains[group_idx])\\n # Decay the variables\\n learning_rate = learning_rate * decay\\n n = n * decay\\n\\n\\n if i % args.evaluate_freq==0:\\n cities_od = rebuild_cities(cities_nm,neuron_chains,args.num_depots)\\n cities_od[['x','y']] =cities.reindex(cities_od['city'])[['x','y']]\\n losses = routes_distances(cities_od)\\n losses_sum = sum(losses)\\n losses_sum_log[i] = losses_sum\\n\\n if min_losses_sum == 0 or min_losses_sum > losses_sum:\\n min_losses_sum = losses_sum\\n best_id = i\\n routes = get_routes(cities_od)\\n routes = [list(item.astype(np.float64)) for item in routes]\\n min_routes_log[i] = routes\\n\\n min_losses_sum_log[i] = losses_sum\\n min_losses_log[i] = losses\\n cities_od.to_csv(out_dir/'data_out_{:04d}.csv'.format(i))\\n save_neuron_chains(neuron_chains,out_dir/\\\"neuron_chains_{:04d}.npy\\\".format(i))\\n\\n #end for\\n\\n # Check if any parameter has completely decayed.\\n if n < 1:\\n print('Radius has completely decayed, finishing execution',\\n 'at {} iterations'.format(i))\\n break\\n if learning_rate < 0.001:\\n print('Learning rate has completely decayed, finishing execution',\\n 'at {} iterations'.format(i))\\n break\\n\\n\\n print('Completed {} iterations.'.format(iteration))\\n\\n results = {}\\n\\n results['losses_sum_log']=losses_sum_log\\n results['best_id'] = best_id\\n\\n results['min_losses_sum_log']=min_losses_sum_log\\n results['min_losses_log']=min_losses_log\\n results['min_routes_log'] = min_routes_log\\n\\n\\n p = Path(out_dir/'results.json')\\n with open(p, 'w') as fp:\\n json.dump(results, fp)\\n print('ok')\\n\\n\\n return results\",\n \"def initializeParameters(self):\\n \\n # 0 - Output Workspace\\n # 1 - Output Feature Name\\n # 2 - X coordinate (longitude)\\n # 3 - Y coordinate (latitude)\\n # 4 - Z coordinate (elevation)\\n # 5 - Observer offset (OFFSETA)\\n # 6 - Terrain offset (OFFSETB)\\n # 7 - Near distance (RADIUS1)\\n # 8 - Far distance (RADIUS2\\n # 9 - Left Azimuth (AZIMUTH1)\\n # 10 - Right Azimuth (AZIMUTH2)\\n # 11 - Top vertical angle (VERT1)\\n # 12 - Bottom vertical angle (VERT2)\\n # 13 - Spatial Reference\\n # 14 - output point features\\n \\n \\n #GETTING ERROR HERE, DOESN'T VALIDATE CORRECTLY, BUG?????\\n #---------------------------\\n #Testing get_ParameterInfo\\n #---------------------------\\n #initializeParameters Execution Error: Runtime error <type 'exceptions.AttributeError'>: 'NoneType' object has no attribute 'Type'\\n #---------------------------\\n #OK \\n #---------------------------\\n #\\n #\\n #self.params[0].Filter.Type = \\\"Workspace\\\"\\n #self.params[0].Filter.List = [\\\"FileSystem\\\", \\\"LocalDatabase\\\", \\\"RemoteDatabase\\\"]\\n #\\n\\n \\n self.params[5].Value = 2.0 # OFFSETA\\n self.params[6].Value = 0.0 # OFFSETB\\n \\n self.params[7].Value = 0.0 # RADIUS1\\n self.params[8].Value = 1000.0 # RADIUS2\\n \\n self.params[9].Filter.Type = \\\"Range\\\" \\n self.params[9].Filter.List = [0.0,360.0]\\n self.params[9].Value = 0.0 # AZIMUTH1\\n \\n self.params[10].Filter.Type = \\\"Range\\\"\\n self.params[10].Filter.List = [0.0,360.0]\\n self.params[10].Value = 360.0 # AZIMUTH2\\n \\n self.params[11].Filter.Type = \\\"Range\\\"\\n self.params[11].Filter.List = [-90.0,90.0]\\n self.params[11].Value = 90.0 # VERT1\\n \\n self.params[12].Filter.Type = \\\"Range\\\"\\n self.params[12].Filter.List = [-90.0,90.0]\\n self.params[12].Value = -90.0 # VERT2\\n\\n # setting output parameter schema\\n self.params[14].Schema.ExtentRule = \\\"Union\\\"\\n self.params[14].Schema.FeatureTypeRule = \\\"AsSpecified\\\"\\n self.params[14].Schema.FeatureType = \\\"Simple\\\"\\n self.params[14].Schema.GeometryTypeRule = \\\"AsSpecified\\\"\\n self.params[14].Schema.GeometryType = \\\"Point\\\"\\n self.params[14].Schema.FieldsRule = \\\"All\\\" \\n #spot_field = self.makeField(\\\"SPOT\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n offseta_field = self.makeField(\\\"OFFSETA\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n offsetb_field = self.makeField(\\\"OFFSETB\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n vert1_field = self.makeField(\\\"VERT1\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n vert2_field = self.makeField(\\\"VERT2\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n azimuth1_field = self.makeField(\\\"AZIMUTH1\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n azimuth2_field = self.makeField(\\\"AZIMUTH2\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n radius1_field = self.makeField(\\\"RADIUS1\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n radius2_field = self.makeField(\\\"RADIUS2\\\", \\\"DOUBLE\\\", \\\"8\\\", \\\"4\\\", \\\"12\\\")\\n field_list = [offseta_field,offsetb_field,vert1_field,vert2_field,azimuth1_field,azimuth2_field,radius1_field,radius2_field]\\n self.params[14].Schema.AdditionalFields = field_list\\n\\n return\",\n \"def setup_method(self):\\n self.x0 = (1.0, [1.0, 1.0])\\n self.sol = (-0.195, np.array([-0.195, -0.1]))\\n\\n self.tol = 3 # number of decimal places\\n\\n self.niter = 100\\n self.disp = False\\n\\n # fix random seed\\n np.random.seed(1234)\\n\\n self.kwargs = {\\\"method\\\": \\\"L-BFGS-B\\\", \\\"jac\\\": True}\\n self.kwargs_nograd = {\\\"method\\\": \\\"L-BFGS-B\\\"}\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"Afb[0.6,-0.7,0.7]\\\");\\n self.modelBuilder.doVar(\\\"A0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"Afb,A0\\\")\\n\\n # ss templates\\n self.modelBuilder.doVar(\\\"R_ee_os_fakes[0.6,0.0,1.0]\\\");\\n self.modelBuilder.doVar(\\\"ee16_fakes_norm[1.0, 0.01, 10.]\\\");\\n self.modelBuilder.doVar(\\\"ee17_fakes_norm[1.0, 0.01, 10.]\\\");\\n self.modelBuilder.doVar(\\\"ee18_fakes_norm[1.0, 0.01, 10.]\\\");\\n #Remember, cant use spaces in these formulas!\\n #self.modelBuilder.options.verbose = 10\\n self.modelBuilder.factory_('expr::R_ee16_qcd_os(\\\"@0*@1\\\",ee16_fakes_norm,R_ee_os_fakes)')\\n self.modelBuilder.factory_('expr::R_ee17_qcd_os(\\\"@0*@1\\\",ee17_fakes_norm,R_ee_os_fakes)')\\n self.modelBuilder.factory_('expr::R_ee18_qcd_os(\\\"@0*@1\\\",ee18_fakes_norm,R_ee_os_fakes)')\\n self.modelBuilder.factory_('expr::R_ee16_qcd_ss(\\\"@0*(1.0-@1)\\\",ee16_fakes_norm,R_ee_os_fakes)')\\n self.modelBuilder.factory_('expr::R_ee17_qcd_ss(\\\"@0*(1.0-@1)\\\",ee17_fakes_norm,R_ee_os_fakes)')\\n self.modelBuilder.factory_('expr::R_ee18_qcd_ss(\\\"@0*(1.0-@1)\\\",ee18_fakes_norm,R_ee_os_fakes)')\\n \\n self.modelBuilder.factory_('expr::Alph(\\\"2.0*@0/(2.0-@0)\\\",A0)')\\n self.modelBuilder.factory_('expr::Norm(\\\"3.0/4.0/(2.0+@0)\\\",Alph)')\\n self.modelBuilder.factory_('expr::RAlph(\\\"@0*@1\\\",Alph,Norm)')\\n self.modelBuilder.factory_('expr::Rpl(\\\"(@0+@1)\\\",Norm,Afb)')\\n self.modelBuilder.factory_('expr::Rmn(\\\"(@0-@1)\\\",Norm,Afb)')\",\n \"def projection(self):\\n pass\",\n \"def main():\\n # start_time = time.time()\\n\\n # city: (latitude, longtitude) +/- 0.5 degree\\n # geocenter for EU: 50 9\\n cities = {\\n 'Vienna': (48, 16),\\n 'Brussels': (51, 4),\\n 'Sofia': (43, 23),\\n 'Zagreb': (46, 16),\\n 'Nicosia': (35, 33),\\n 'Prague': (50, 14),\\n 'Copenhagen': (55, 13),\\n 'Tallinn': (59, 25),\\n 'Helsinki': (60, 25),\\n 'Paris': (49, 2),\\n 'Berlin': (53, 13),\\n 'Athens': (38, 24),\\n 'Budapest': (48, 19),\\n 'Dublin': (53, -6),\\n 'Rome': (42, 13),\\n 'Riga': (57, 24),\\n 'Vilnius': (55, 25),\\n 'Luxembourg': (50, 6),\\n 'Valletta': (36, 15),\\n 'Amsterdam': (52, 5),\\n 'Warsaw': (52, 21),\\n 'Lisbon': (39, -9),\\n 'Bucharest': (44, 26),\\n 'Bratislava': (48, 17),\\n 'Ljubljana': (46, 15),\\n 'Madrid': (40, -4),\\n 'Stockholm': (59, 18),\\n 'London': (52, 0)\\n }\\n\\n cities = OrderedDict(sorted(cities.items(), key=lambda t: t[0]))\\n cities_indices = [x for x in range(len(cities))]\\n cities_names = [key for key in cities.keys()]\\n\\n for key, value in cities.items():\\n nu_v = hf.equirectangular_projection(\\n value[0], value[1], phi_0=50, l_0=9)\\n cities[key] = nu_v\\n\\n decoder = {value: key for (key, value) in cities.items()}\\n\\n ga.cities = cities\\n # ga.cities_names = cities_names\\n # ga.cities_indices = cities_indices\\n param_names = ['v1', 'v2', 't', 'n', 'pm', 'pc', 'tournsize', 'size']\\n f = open('params.txt', 'r')\\n param_values = [float(l) if '.' in l else int(l) for l in f]\\n f.close()\\n params = dict(zip(param_names, param_values))\\n\\n ga.Salesman.diploid = True\\n starters = ga.mfp(params['size'])\\n v1 = params['v1'] # velocity 1 in Poland\\n v2 = params['v2'] # velocity 2 in Poland\\n t = params['t'] # period of change of velocity in Poland\\n n = params['n'] # number of generations\\n pm = params['pm'] # probabilty of mutation (per gene)\\n pc = params['pc'] # probability of crossover\\n tournsize = params['tournsize']\\n\\n start_time = time.time()\\n salesmen = starters\\n ga.Salesman.velocity_pol = v1\\n path_s = ga.findbest(salesmen).fitness\\n print('first population best: ' + str(round(1 / path_s, 2)) + ' hours')\\n\\n results = [[0, path_s]]\\n counter = 0\\n for i in range(n):\\n if counter == t // 2 - 1:\\n ga.Salesman.velocity_pol = v1 if ga.Salesman.velocity_pol == v2 \\\\\\n else v2\\n counter = 0\\n counter += 1\\n salesmen = ga.evolution(salesmen, pm, pc, tournsize)\\n path = ga.findbest(salesmen).fitness\\n results.append([i + 1, path])\\n\\n path_d = ga.findbest(salesmen).fitness\\n path_d_seq = ga.findbest(salesmen).best_seq\\n print(str(n) + '-th population best (diploidal): ' +\\n str(round(1 / path_d, 2)) + ' hours')\\n print([decoder[x] for x in path_d_seq])\\n print(\\\"Time elapsed: \\\" + str(time.time() - start_time) + 's')\\n\\n start_time = time.time()\\n salesmen = starters\\n ga.Salesman.diploid = False\\n ga.Salesman.velocity_pol = v1\\n\\n results2 = [[0, path_s]]\\n counter = 0\\n for i in range(n):\\n if counter == t // 2 - 1:\\n ga.Salesman.velocity_pol = v1 if ga.Salesman.velocity_pol == v2 \\\\\\n else v2\\n counter = 0\\n counter += 1\\n salesmen = ga.evolution(salesmen, pm, pc, tournsize)\\n path = ga.findbest(salesmen).fitness\\n results2.append([i + 1, path])\\n\\n path_h = ga.findbest(salesmen).fitness\\n path_h_seq = ga.findbest(salesmen).city_seq\\n print(str(n) + '-th population best (haploidal): ' +\\n str(round(1 / path_h, 2)) + ' hours')\\n print([decoder[x] for x in path_h_seq])\\n print(\\\"Time elapsed: \\\" + str(time.time() - start_time) + 's')\\n\\n # plot fitnesses:\\n results = np.asarray(results)\\n results2 = np.asarray(results2)\\n plt.plot(results[:, 0], results[:, 1], 'b-', label='diploidal')\\n plt.plot(results2[:, 0], results2[:, 1], 'g-', label='haploidal')\\n plt.legend(loc=4)\\n plt.show()\\n\\n # plot paths:\\n fig, ax = plt.subplots(1)\\n\\n starters_best_seq = ga.findbest(starters).city_seq\\n starters_best_seq += [starters_best_seq[0]] # close the loop\\n starters_best_seq = np.asarray(starters_best_seq)\\n plt.plot(starters_best_seq[:, 0], starters_best_seq[:, 1], 'r-', alpha=0.2)\\n\\n labels = cities_indices\\n cities = np.asarray(list(ga.cities.values()))\\n\\n plt.scatter(cities[:, 0], cities[:, 1], color='r')\\n for label, x, y in zip(labels, cities[:, 0], cities[:, 1]):\\n plt.annotate(label, xy=(x, y), xytext=(-6, -12),\\n textcoords='offset points')\\n poland_c = hf.equirectangular_projection(52, 19, 50, 9)\\n poland = plt.Circle(poland_c, .047, color='r', alpha=0.3)\\n ax.add_artist(poland)\\n\\n path_d_seq = path_d_seq + [path_d_seq[0]]\\n path_d_seq = np.asarray(path_d_seq)\\n\\n path_h_seq = path_h_seq + [path_h_seq[0]]\\n path_h_seq = np.asarray(path_h_seq)\\n\\n plt.plot(path_h_seq[:, 0],\\n path_h_seq[:, 1], 'g-', label='haploidal')\\n plt.plot(path_d_seq[:, 0],\\n path_d_seq[:, 1], 'b-', label='diploidal')\\n\\n legend = \\\"Legend:\\\\n\\\"\\n legend += \\\"\\\\n\\\".join([str(ii) + ': ' + name\\n for ii, name in enumerate(cities_names)])\\n props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\\n ax.text(-0.15, 0.95, legend,\\n transform=ax.transAxes,\\n fontsize=14, verticalalignment='top', bbox=props)\\n\\n plt.axis('off')\\n plt.legend(loc=4)\\n plt.show()\",\n \"def __init__(self, nb):\\n\\n # Approximation parameters\\n self.o_min = -.1\\n self.o_max = .1\\n self.o_nb = nb\\n self.o_bw = (self.o_max - self.o_min) / self.o_nb\\n self.o_e = np.linspace(self.o_min, self.o_max, self.o_nb+1)\\n self.o = self.o_e[:-1] + (self.o_bw/2)\\n self.r_e = [0, 1]\\n self.r_nb = len(self.r_e)\\n self.mu_min = 0\\n self.mu_max = 1\\n self.mu_nb = nb\\n self.mu_bw = (self.mu_max - self.mu_min) / self.mu_nb\\n self.mu_e = np.linspace(self.mu_min, self.mu_max, self.mu_nb+1)\\n self.mu = self.mu_e[:-1] + (self.mu_bw/2)\\n self.p_s_giv_o_hat = np.nan\\n self.S = np.nan\\n self.p_mu_giv_r_o_hat = np.nan\",\n \"def __init__(self,x=0.1,E=10.0, mpar={}, topchem='He', topden=1.78e-4, botchem='Sr50Cl100H110493.721O55246.86', botden=1.0032, element='Sr', line='Ka1', vslit= 0.04, detlen=10.5, qoff=0.0, yscale=1,int_bg=0, Rc=0, sur_den=0,ion_depth=0):\\n if type(x)==list:\\n self.x=np.array(x)\\n else:\\n self.x=x\\n self.E=E\\n self.__mpar__ = mpar\\n self.topchem = topchem\\n self.topden = topden\\n self.botchem = botchem\\n self.botden = botden\\n self.element = element\\n self.line = line\\n self.vslit = vslit\\n self.detlen = detlen\\n self.qoff = qoff\\n self.yscale = yscale\\n self.int_bg = int_bg\\n self.Rc = Rc\\n self.sur_den = sur_den\\n self.ion_depth = ion_depth\\n elelist = xdb.atomic_symbols\\n linelist = list(xdb.xray_lines(98).keys())\\n self.choices={'element':elelist,'line': linelist} #If there are choices available for any fixed parameters\\n self.output_params = {}\\n self.init_params()\\n self.__fit__=False\\n self.__avoganum__ = scipy.constants.Avogadro\\n self.__eleradius__ = scipy.constants.physical_constants['classical electron radius'][0]*1e10 #classic electron radius in \\\\AA\",\n \"def getDefaultParams():\\n defpar = [\\n # coordinate system\\n ['crd_sys', \\\"'sph'\\\", 'Coordinate system'],\\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\\n ['ny', '[10,30, 30, 10]',\\n 'Number of grid points in the second dimension'],\\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\\n 'Number of radial grid points'],\\n ['nz', '[361]', 'Number of grid points in the third dimension'],\\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\\n # star related\\n ['tstar', '[3900.0]', 'Temperature of star'],\\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\\n ['rstar', '[2.5*rs]', 'Radius of star'],\\n # gas density \\n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \\n ['ring_r', '[50*au]', 'location of gaussian ring'], \\n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \\n ['cutgdens', '1e-30', 'cut for density'], \\n ['Rt', '100*au', 'radius for scale height'], \\n ['Ht', '10*au', 'scale height'], \\n ['qheight', '1.25', 'height power-law'], \\n # gas species\\n ['gasspec_mol_name', \\\"['12co']\\\", 'name of molecule'],\\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\\n ['gasspec_mol_dbase_type', \\\"['leiden']\\\", ''],\\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\\n # dust density\\n # flat power-law parts\\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\\n # Lynden-Bell parts\\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \\n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \\n ['dLB_sig0', '[1e2]', 'surface density'], \\n # ring parts\\n ['dring_r', '[50*au]', 'location of gaussian ring'],\\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\\n ['cutddens', '1e-30', 'cut for dust density'],\\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \\n ['dHt', '[10*au]', 'scale height for each grain size'], \\n ['dqheight', '[1.25]', 'scale height power-law for dust'], \\n # temperature\\n ['T0mid', '50', 'mid plane temperature at Rt'],\\n ['T0atm', '50', 'atmosphere temperature at Rt'],\\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\\n ['qmid', '-0.5', 'midplane temperature exponent'],\\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\\n ['hdel', '2', 'temperature transition exponent '],\\n ['cuttemp', '10', 'temperature cut'], \\n # alignment\\n ['altype', \\\"'toroidal'\\\", 'alignment type']\\n ]\\n\\n return defpar\",\n \"def doParametersOfInterest(self):\\n ''' ref : physicsmodel -> rvf\\n self.modelBuilder.out.var(\\\"MH\\\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\\n self.modelBuilder.out.var(\\\"MH\\\").setConstant(False)\\n '''\\n\\n self.modelBuilder.doVar(\\\"mu[0,0,1000]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doVar(\\\"Fvbf[0,0,1]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu,Fvbf\\\")\\n self.modelBuilder.doVar(\\\"\\\")\\n self.modelBuilder.factory_('expr::ggH_s_func(\\\"(@0-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_b_func(\\\"(1-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\\\"sqrt(@0)*(1.-@1)\\\", mu,Fvbf)')\\n\\n self.modelBuilder.factory_('expr::vbfH_s_func(\\\"(@0-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\\\"(1-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\\\"sqrt(@0)*(@1)\\\", mu,Fvbf)')\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def constant_2015():\\n\\n #Load the CMIP6 historical\\n cubes = iris.load(data_dir+'SO2DMS-em-anthro_input4MIPs_emissions_CMIP_CEDS-v2016-07-26-gr_200001-201412_n48.nc')\\n #Get low and high level emissions just in the last year (2014)\\n cubes = iris.cube.CubeList([cubes[2],cubes[1]])\\n final_cubes = iris.cube.CubeList()\\n for cube in cubes:\\n final_cube = cube[-12:]\\n final_cubes.append(final_cube)\\n \\n #Set the year-on-year proportional reductions to be nothing\\n yoy_rates = calc_perc_reducts()\\n yoy_rates = np.array(yoy_rates)\\n yoy_rates = np.ones_like(yoy_rates)\\n\\n #Create coordinates for new nc file between 2014 and 2100\\n lat_coord = cubes[0].coord('latitude')\\n lon_coord = cubes[0].coord('longitude')\\n time_coord = DimCoord(np.arange(95055.,95055.+(2100-2014+1)*360.,30.),standard_name=u'time', units=cf_units.Unit('days since 1750-1-1 00:00:00', calendar='360_day'), long_name=u'time', var_name='time')\\n\\n #Create the cube date\\n cube_data_surf = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n cube_data_high = np.zeros((len(time_coord.points),cubes[0].shape[1],cubes[0].shape[2]))\\n #Set first year equal to 2014 in CMIP6 historical\\n cube_data_surf[:12,...] = final_cubes[0].data\\n cube_data_high[:12,...] = final_cubes[1].data\\n #Apply equal emissions in all other years too\\n for i in range(12,cube_data_surf.shape[0]):\\n cube_data_surf[i,...] = cube_data_surf[(i-12),...] * yoy_rates[0,i]\\n cube_data_high[i,...] = cube_data_high[(i-12),...] * yoy_rates[1,i]\\n #Make the output cubes\\n fut_cube_surf = iris.cube.Cube(cube_data_surf,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[0].standard_name, long_name=final_cubes[0].long_name, var_name=final_cubes[0].var_name, units=final_cubes[0].units, attributes=final_cubes[0].attributes)\\n fut_cube_high = iris.cube.Cube(cube_data_high,dim_coords_and_dims=[(time_coord,0),(lat_coord, 1),(lon_coord, 2)],standard_name=final_cubes[1].standard_name, long_name=final_cubes[1].long_name, var_name=final_cubes[1].var_name, units=final_cubes[1].units, attributes=final_cubes[1].attributes)\\n\\n fut_cube_high.var_name = 'field569_1'\\n fut_cube_high.units='kg/m2/s'\\n fut_cube_high.long_name ='HIGH LEVEL SO2 EMISSIONS KG/M2/S'\\n fut_cube_surf.var_name = 'field569'\\n fut_cube_surf.units='kg/m2/s'\\n fut_cube_surf.long_name ='SULPHUR DIOXIDE EMISSIONS'\\n\\n #Load the DMS cube from standard RCP2.6\\n dms_cube = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')[0]\\n iris.coord_categorisation.add_year(dms_cube,'time',name='year')\\n dms_cube = dms_cube.extract(iris.Constraint(year = lambda y: y>=2014))\\n\\n dms_cube.var_name = 'field570'\\n dms_cube.attributes.pop('name')\\n dms_cube.coord('time').var_name = 'time'\\n dms_cube.coord('time').long_name = 'time'\\n\\n fut_cube_high = fut_cube_high[:-2]\\n fut_cube_surf = fut_cube_surf[:-2]\\n\\n fut_dms = iris.cube.Cube(dms_cube.data[:,0,::-1,:],dim_coords_and_dims=[(fut_cube_surf.coord('time'),0),(fut_cube_surf.coord('latitude'),1),(fut_cube_surf.coord('longitude'), 2)],standard_name=dms_cube.standard_name, long_name=dms_cube.long_name, var_name=dms_cube.var_name, units=dms_cube.units, attributes=dms_cube.attributes)\\n\\n #Save the final cubes as netcdf (cutting them to be the same length)\\n iris.save(iris.cube.CubeList([fut_dms,fut_cube_high,fut_cube_surf]),data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n os.system('ncatted -O -a calendar,time,m,c,\\\"360_day\\\" '+data_dir+ \\\"SO2DMS_const2014.nc\\\")\\n\\n return\",\n \"def __init__(self, size=60, n=2, gamma=10, limit=15):\\n self.n = n\\n self.gamma = gamma\\n self.limit = limit\\n self.a = (1 / gamma) / (gamma - 1)\\n\\n x = np.arange(size)\\n #endpoint=True breaks the plot of curve, \\n #but allows work with [0, 1], not [0, 1) \\n self.coord = []\\n for i in x:\\n for j in x:\\n result = psi.inner_function((i / size, j / size), gamma, n)[0] \\n self.coord.append((i, j, result))\\n self.coord.sort(key=lambda x: x[2])\\n self.x = np.array([i[0] for i in self.coord])\\n self.y = np.array([i[1] for i in self.coord])\",\n \"def _projections(self, nvar):\\n min_var = self.proje_var.argsort()[:nvar]\\n add_coeffs = 1 / self.proje_var[min_var]\\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\\\\n np.sum(add_coeffs)\\n\\n # consider covariance\\n coverr = []\\n try:\\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\\n coverr.append(1/np.sum(proje_cov_inv))\\n except:\\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\\n cov_est_proje[:] = np.nan\\n coverr.append(np.nan)\\n return np.array([indp_est_proje, cov_est_proje])\",\n \"def __init__(self, D, NP, nFES, nRuns, useAlgorithms, useBenchmarks, **kwargs):\\n\\t\\tself.D = D\\n\\t\\tself.NP = NP\\n\\t\\tself.nFES = nFES\\n\\t\\tself.nRuns = nRuns\\n\\t\\tself.useAlgorithms = useAlgorithms\\n\\t\\tself.useBenchmarks = useBenchmarks\\n\\t\\tself.A = kwargs.get('A', 0.5)\\n\\t\\tself.r = kwargs.get('r', 0.5)\\n\\t\\tself.Qmin = kwargs.get('Qmin', 0.0)\\n\\t\\tself.Qmax = kwargs.get('Qmax', 2.0)\\n\\t\\tself.Pa = kwargs.get('Pa', 0.25)\\n\\t\\tself.F = kwargs.get('F', 0.5)\\n\\t\\tself.CR = kwargs.get('CR', 0.9)\\n\\t\\tself.alpha = kwargs.get('alpha', 0.5)\\n\\t\\tself.betamin = kwargs.get('betamin', 0.2)\\n\\t\\tself.gamma = kwargs.get('gamma', 1.0)\\n\\t\\tself.p = kwargs.get('p', 0.5)\\n\\t\\tself.Ts = kwargs.get('Ts', 4)\\n\\t\\tself.Mr = kwargs.get('Mr', 0.05)\\n\\t\\tself.C1 = kwargs.get('C1', 2.0)\\n\\t\\tself.C2 = kwargs.get('C2', 2.0)\\n\\t\\tself.w = kwargs.get('w', 0.7)\\n\\t\\tself.vMin = kwargs.get('vMin', -4)\\n\\t\\tself.vMax = kwargs.get('vMax', 4)\\n\\t\\tself.Tao = kwargs.get('Tao', 0.1)\\n\\t\\tself.n = kwargs.get('n', 10)\\n\\t\\tself.omega = kwargs.get('omega', 0.25)\\n\\t\\tself.mu = kwargs.get('mu', 0.5)\\n\\t\\tself.E_init = kwargs.get('E_init', 10)\\n\\t\\tself.S_init = kwargs.get('S_init', 10)\\n\\t\\tself.T_min = kwargs.get('T_min', -10)\\n\\t\\tself.T_max = kwargs.get('T_max', 10)\\n\\t\\tself.C_a = kwargs.get('C_a', 2)\\n\\t\\tself.C_r = kwargs.get('C_r', 0.5)\\n\\t\\tself.results = {}\",\n \"def getcoor(im, win = \\\"get coordinates\\\", updatefunc=drawcoorpoints, prox=8, radius = 3, unique=True, col_out=black,col_in=red):\\n # functions\\n def getcoor_drawstats(self,points,col_out=black,col_in=green,radius=2):\\n \\\"\\\"\\\"\\n\\n :param self:\\n :param points:\\n :param col_out:\\n :param col_in:\\n :param radius:\\n :return:\\n \\\"\\\"\\\"\\n vis = self.rimg\\n p = imcoors(points)\\n self.data2 = np.zeros((vis.shape[0],vis.shape[1],1),dtype=np.uint8)\\n drawcooraxes(vis,[p.boxCenter],col_out,col_in,radius)\\n drawcooraxes(self.data2,[p.boxCenter],1,1,self.prox)\\n drawcooraxes(vis,[p.mean],col_in,col_out,radius)\\n drawcooraxes(self.data2,[p.mean],2,2,self.prox)\\n p1 = imcoors(self.coors)\\n self.mapdata2 = [None,\\\"center at \\\"+str(p1.boxCenter),\\\"mean at \\\"+str(p1.mean)]\\n\\n def getcoor_updatecoors(self):\\n \\\"\\\"\\\"\\n\\n :param self:\\n :return:\\n \\\"\\\"\\\"\\n self.coorlen = len(self.coors)\\n self.updaterenderer()\\n if self.coors != []:\\n self.rcoors = self.coors[:]\\n newc = self.coors[:]\\n for j,i in enumerate(self.coors):\\n newc[j] = self.real2render(i[0],i[1])\\n self.rcoors[j] = limitaxispoints(newc[j],10000,-10000)\\n if self.showstats:\\n getcoor_drawstats(self,newc,radius=self.radius)\\n self.rimg = self.updatefunc(self.rimg,newc,self.col_out,self.col_in,self.radius)\\n else:\\n self.data2[:] = 0\\n self.coordinateText = [[\\\"xy({self.x},{self.y})\\\"]]\\n\\n def getcoor_mouse(self):\\n \\\"\\\"\\\"\\n\\n :param self:\\n :return:\\n \\\"\\\"\\\"\\n # control system\\n controlled = self.builtincontrol()\\n drawed = False\\n\\n # get nearest coordinate to pointer\\n isnear = False\\n if self.coors != [] and self.rx is not None and self.ry is not None:\\n # vals = anorm(np.int32(self.coors) - (self.x, self.y)) # relative to real coordinates\\n vals = anorm(np.int32(self.rcoors) - (self.rx, self.ry)) # relative to rendered coordinates\\n near_point = np.logical_and(vals < self.prox, vals == np.min(vals))\\n if np.any(near_point): # if near point\\n idx = np.where(near_point)[0] # get index\\n isnear = True\\n val = self.coors[idx[0]]\\n count = self.coors.count(val)\\n self.coordinateText = [[\\\"point \\\"+str(idx[0])+\\\" at \\\"+str(val)+\\\"x\\\"+str(count)]]\\n else:\\n self.coordinateText = [[\\\"xy({self.x},{self.y})\\\"]]\\n\\n # coordinate system\\n if not controlled and bool(self.flags):\\n if self.event== cv2.EVENT_RBUTTONDBLCLK: # if middle button DELETE ALL COORDINATES\\n self.coors = []\\n self.img = self.data.copy()\\n drawed = True\\n elif isnear and self.event== cv2.EVENT_RBUTTONDOWN: # if right button DELETE NEAREST COORDINATE\\n self.coors.pop(idx[0]) # if more than one point delete first\\n drawed = True\\n elif self.event== cv2.EVENT_LBUTTONDOWN: # if left button ADD COORDINATE\\n val = (self.x,self.y)\\n if not self.coors.count(val) or not self.unique:\\n self.coors.append(val)\\n drawed = True\\n\\n # update renderer\\n if (controlled or drawed):\\n getcoor_updatecoors(self)\\n\\n if self.y is not None and self.x is not None:\\n if self.showstats:\\n data = self.mapdata2[self.data2[self.ry,self.rx]]\\n if not isnear and data is not None:\\n self.coordinateText = [[data]]\\n self.builtinplot(self.data[self.y,self.x])\\n\\n if type(im) is plotim:\\n self = im\\n else:\\n self = plotim(win,im)\\n # assign functions\\n self.mousefunc = getcoor_mouse\\n self.updatefunc = updatefunc\\n self.userupdatefunc = updatefunc\\n self.prox = prox # proximity to keypoint\\n # initialize user variables\\n self.radius = radius\\n self.unique = unique\\n self.col_out = col_out\\n self.col_in = col_in\\n # initialize control variables\\n self.interpolation=cv2.INTER_AREA\\n self.coors = []\\n self.rcoors = []\\n self.coorlen = 0\\n self.showstats = False\\n self.mapdata2 = [None,None,None]\\n self.data2 = np.zeros((self.rH,self.rW,1),dtype=np.uint8)\\n self.updatecoors = getcoor_updatecoors\\n self.drawcooraxes = drawcooraxes\\n self.drawcoorperspective = drawcoorperspective\\n self.drawcoorpolyline = drawcoorpolyline\\n self.drawcoorpoints = drawcoorpoints\\n self.controlText[0].extend([\\\" No. coordinates: {self.coorlen}. \\\"])\\n self.cmdeval.update({\\\"points\\\":\\\"self.updatefunc = self.drawcoorpoints\\\",\\n \\\"polyline\\\":\\\"self.updatefunc = self.drawcoorpolyline\\\",\\n \\\"perspective\\\":\\\"self.updatefunc = self.drawcoorperspective\\\",\\n \\\"axes\\\":\\\"self.updatefunc = self.drawcooraxes\\\",\\n \\\"user\\\":\\\"self.updatefunc = self.userupdatefunc\\\",\\n \\\"end\\\":[\\\"self.getcoor_updatecoors(self)\\\",\\\"self.mousefunc(self)\\\"]})\\n self.cmdlist.extend([\\\"unique\\\",\\\"showstats\\\",\\\"user\\\",\\\"points\\\",\\\"polyline\\\",\\\"perspective\\\",\\\"axes\\\"])\\n # show window\\n self.show()\\n return self.coors # return coordinates\",\n \"def problem3():\\n t = np.array([-27.1, -2.9, -3.2])\\n principal_point = np.array([8, -10])\\n focal_length = 8\\n\\n # model transformations\\n T = gettranslation(t)\\n Ry = getyrotation(135)\\n Rx = getxrotation(-30)\\n Rz = getzrotation(90)\\n print(T)\\n print(Ry)\\n print(Rx)\\n print(Rz)\\n\\n K = getcentralprojection(principal_point, focal_length)\\n\\n P,M = getfullprojection(T, Rx, Ry, Rz, K)\\n print(P)\\n print(M)\\n\\n points = loadpoints()\\n displaypoints2d(points)\\n\\n z = loadz()\\n Xt = invertprojection(K, points, z)\\n\\n Xh = inverttransformation(M, Xt)\\n\\n worldpoints = hom2cart(Xh)\\n displaypoints3d(worldpoints)\\n\\n points2 = projectpoints(P, worldpoints)\\n displaypoints2d(points2)\\n\\n plt.show()\",\n \"def GEEnasaNEXGDDP(ptsFile,metric,timeStep,startYear,endYear,scenarios,buf,poly,username,folderOut,models = ['ACCESS1-0', 'bcc-csm1-1', 'BNU-ESM',\\n 'CanESM2', 'CCSM4', 'CESM1-BGC', 'CNRM-CM5', 'CSIRO-Mk3-6-0',\\n 'GFDL-CM3', 'GFDL-ESM2G', 'GFDL-ESM2M', 'inmcm4', 'IPSL-CM5A-LR',\\n 'IPSL-CM5A-MR', 'MIROC-ESM', 'MIROC-ESM-CHEM', 'MIROC5', 'MPI-ESM-LR',\\n 'MPI-ESM-MR', 'MRI-CGCM3', 'NorESM1-M'], scalePix = 25000):\\n \\n # load required libraries\\n import ee\\n\\n # Initialize the Earth Engine object, using the authentication credentials.\\n ee.Initialize()\\n\\n ID_field = \\\"geeID\\\"\\n\\n #load pts or poly file\\n pts1 = ee.FeatureCollection('users/' + username + '/' + str(ptsFile))\\n\\n time_d = {}\\n time_d['day'] = 'projd'\\n time_d['month'] = 'projm'\\n time_d['year'] = 'projy'\\n \\n for met in metric:\\n\\n for scenario in scenarios:\\n\\n for model in models:\\n\\n NEX = (ee.ImageCollection('NASA/NEX-GDDP')\\n .select(met)\\n .filterMetadata('model', 'equals', model)\\n .filterMetadata('scenario', 'equals', scenario))\\n\\n metL = [met]\\n \\n years = list(range(startYear, endYear + 1))\\n monthsEE = ee.List(list(range(0,(12*len(years)))))\\n yearsEE = ee.List(years)\\n\\n######Turned off unit conversion, because it fails when there are too many pts\\n## if (met == 'pr'):\\n##\\n## def Scale1(img):\\n## return (img.float()\\n## .multiply(86400)\\n## .copyProperties(img,['system:time_start','system:time_end']))\\n##\\n## NEX = NEX0.map(Scale1)\\n## \\n## elif any([(met == 'tasmin'),(met == 'tasmax')]):\\n##\\n## def KtoC(img):\\n## return (img.float()\\n## .subtract(273.15)\\n## .copyProperties(img,['system:time_start','system:time_end']))\\n##\\n## NEX = NEX0.map(KtoC)\\n \\n if all([(timeStep == 'year'),any([(met == 'tasmin'),(met == 'tasmax')])]):\\n\\n def map_m(i):\\n i = ee.Number(i).int()\\n image2 = (NEX\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .first())\\n filtered = (NEX\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .mean()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(yearsEE.map(map_m).flatten())\\n\\n elif all([(timeStep == 'month'),any([(met == 'tasmin'),(met == 'tasmax')])]):\\n \\n def map_m(i):\\n i = ee.Number(i)\\n y = i.divide(12).add(years[0]).int()\\n m = i.mod(12).add(1)\\n image2 = (NEX\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .first())\\n filtered = (NEX\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .mean()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(monthsEE.map(map_m).flatten())\\n\\n elif all([(timeStep == 'year'),(met == 'pr')]):\\n\\n def map_m(i):\\n i = ee.Number(i).int()\\n image2 = (NEX\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .first())\\n filtered = (NEX\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .sum()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(yearsEE.map(map_m).flatten())\\n\\n elif all([(timeStep == 'month'),(met == 'pr')]):\\n \\n def map_m(i):\\n i = ee.Number(i)\\n y = i.divide(12).add(years[0]).int()\\n m = i.mod(12).add(1)\\n image2 = (NEX\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .first())\\n filtered = (NEX\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .sum()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(monthsEE.map(map_m).flatten())\\n\\n elif timeStep == 'day':\\n\\n img_col = NEX.filter(ee.Filter.calendarRange(startYear, endYear, 'year'))\\n\\n #else:\\n #print(\\\"incorrect time step specified\\\")\\n \\n if buf > 0:\\n bufL = [buf]\\n def bufferPoly(feature):\\n return feature.buffer(bufL[0])\\n\\n ptsB = pts1.map(bufferPoly)\\n def table_m(image):\\n table = (image\\n .select(metL[0])\\n .reduceRegions(collection = ptsB.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_ptsB',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n \\n #print ('buffered pts by:' + str(buf) + ' for NEX: ' + met + ' ' + scenario + ' ' + model)\\n\\n elif poly > 0:\\n \\n def table_m(image):\\n table = (image\\n .select(metL[0])\\n .reduceRegions(collection = pts1.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_poly1',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n \\n #print ('spatial mean in poly: no buffer for NEX: ' + met + ' ' + scenario + ' ' + model)\\n\\n else:\\n def table_m(image):\\n table = (image\\n .select(metL[0])\\n .reduceRegions(collection = pts1.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_NEX_'+str(met)+'_'+scenario+'_'+model+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_pts1',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n #print('value at point: no buffer for NEX: ' + met + ' ' + scenario + ' ' + model)\",\n \"def __init__(self, Rect0=(0,0),Rect1=(1,1),Qw=1000,Qe=(250,250,250,250),h=10,phi=0.2):\\n #Cornor Points\\n self.Pts=[(Rect0[0],Rect0[1]),(Rect0[0],Rect1[1]),(Rect1[0],Rect1[1]),(Rect1[0],Rect0[1])]\\n \\n #Center Well\\n self.Pts.append(((Rect0[0]+Rect1[0])/2,(Rect0[1]+Rect1[1])/2) )\\n \\n self.Qw=Qw\\n self.Qe=Qe\\n self.Qe_int=np.zeros(4)\\n self.h=h\\n self.phi=phi\\n self.theta=[np.pi/2,np.pi/2,np.pi/2,np.pi/2]\\n \\n #Subgrid\\n self.SubGrids=[]\\n self.NeighborID=[(1,3),(2,0),(3,1),(0,2)]\\n \\n #Streamline\\n self.SL=[]\\n self.TOF=[]\",\n \"def __setup_parameters__(self):\\r\\n self.M=self.N+1\\r\\n self.u=1+self.pu\\r\\n self.d=1-self.pd\\r\\n self.qu=(math.exp((self.r-self.div)*self.dt)-self.d)/(self.u-self.d)\\r\\n self.qd=1-self.qu\",\n \"def sol549(design_parameters, phi_0, N):\\r\\n prt('Design governing by this mantras (in oder of importance): \\\\nsize, stall margin, cost, off-design', 'blue')\\r\\n n = 0\\r\\n m = 0\\r\\n phi_f = phi_0*1.2\\r\\n N_lineal_phi = int(0.4 * N)\\r\\n step = (phi_f-phi_0)/(N_lineal_phi-1)\\r\\n phi_dist = [float_f(phi_0+i*step, 4) for i in range(N_lineal_phi)] + [float_f(phi_f, 4) for i in range(N_lineal_phi, N)]\\r\\n phi_dist = Distribution(phi_dist)\\r\\n N_lineal_R = int(0.3 * N)\\r\\n R_0 = 0.7\\r\\n R_f = 0.65\\r\\n step = (R_f - R_0) / (N_lineal_R - 1)\\r\\n R_dist = [float_f(R_0+i*step, 4) for i in range(N_lineal_R)] + [float_f(R_f, 4) for i in range(N_lineal_R, N)]\\r\\n R_dist = Distribution(R_dist)\\r\\n\\r\\n Kc = 1-0.5*design_parameters[1]\\r\\n psi_dist = Distribution(psi_limit(phi_dist, R_dist, Kc))\\r\\n if inlet_angle_flow(phi_dist,psi_dist,R_dist):\\r\\n pass\\r\\n\\r\\n return phi_dist, psi_dist, R_dist, n,m\",\n \"def observables(p0,pl0,e0,rho0,nb0,derivatives,E,Pl,Rho,Nb):\\r\\n global g , pmin\\r\\n y = array([p0,0,0,0,0,0,0])\\r\\n r = 0 ; dr = rk_step\\r\\n\\r\\n while not isinstance(y[0],complex):\\r\\n l = y[6]\\r\\n dy = derivatives(r,y,E,Pl,Rho,Nb)\\r\\n if y[0] + dy[0]*rk_max_step <= pmin or Pl(y[0]) <= 0 : break\\r\\n if r >= max_radius :\\r\\n print(\\\"Too many iterations\\\")\\r\\n return None\\r\\n y , r , dr = rk(derivatives,r,y,dr,atol,rtol,rk_max_step,rk_min_step,E,Pl,Rho,Nb)\\r\\n \\r\\n return [p0/g , pl0/g, e0 /g, rho0 , r , l, nb0 ]\",\n \"def set_parameters(self, par):\\n try:\\n for l in self.cell.layers:\\n r_curve = cmf.VanGenuchtenMualem(\\n Ksat=10**par.pKsat, phi=par.porosity, alpha=par.alpha, n=par.n\\n )\\n r_curve.w0 = r_curve.fit_w0()\\n l.soil = r_curve\\n self.cell.saturated_depth = 0.5\\n self.gw.potential = self.cell.z - 0.5\\n except RuntimeError as e:\\n sys.stderr.write(\\\"Set parameters failed with:\\\\n\\\" + str(par) + \\\"\\\\n\\\" + str(e))\\n raise\",\n \"def call_odeint(particle_object,dt,omega):\\n \\n# print \\n# print '##########################'\\n# \\n r = particle_object.position\\n v = particle_object.velocity \\n beta = particle_object.beta \\n# \\n# print 'Initial parameters'\\n# print 'r', r\\n# print 'v', v\\n# print 'beta',beta\\n# print \\n# beta = 0.15\\n #particle_radius = particle_object.radius\\n \\n# ### updating the acceleration due to planet history with the position value before it is moved so that it is the acceleration due to the planet at the position that led to this nett acceleration. \\n# particle_object.update_planet_acceleration_history(AccelerationDueToPlanet(r))\\n \\n u0 = np.array([r[0],r[1],r[2],v[0],v[1],v[2]])\\n \\n \\n sol = odeint(acceleration_for_odeint, u0, np.array([0,dt]), args=(beta, omega,planet_pos)) ## The solution in the from [rx,ry,rz,vx,vy,vz]\\n \\n r_new = np.array([sol[1,0],sol[1,1],sol[1,2]])\\n v_new = np.array([sol[1,3],sol[1,4],sol[1,5]]) \\n \\n# print 'New parameters'\\n# print 'r', r_new\\n# print 'v', v_new\\n#\\n# print \\n \\n #particle_object.update_position(r_new) \\n #particle_object.update_velocity(v_new)\\n \\n ### add one to the particle's age \\n particle_object.update_age() \\n particle_object.update_timestep_history(timestep)\\n \\n #last_uvect = sol[1,:]\\n \\n #return last_uvect\\n \\n #return 0,0\\n return r_new,v_new\",\n \"def OrbitCom(galaxy, start, end, n=5):\\n \\n # compose the filename for output\\n fileout = \\\"Orbit_\\\"+galaxy+\\\".txt\\\"\\n \\n # set tolerance and VolDec for calculating COM_P in CenterOfMass\\n # for M33 that is stripped more, use different values for VolDec\\n \\n if (galaxy == 'M33'):\\n delta = 0.1\\n VolDec=4\\n \\n else:\\n delta = 0.1\\n VolDec = 2\\n\\n \\n # generate the snapshot id sequence \\n # it is always a good idea to also check if the input is eligible (not required)\\n snap_ids = np.arange(start, end+1, step=n)\\n \\n \\n # initialize the array for orbital info: t, x, y, z, vx, vy, vz of COM\\n \\n orbit = np.zeros((snap_ids.size, 7))\\n \\n # a for loop \\n for i, snap_id in enumerate(snap_ids):\\n \\n # compose the data filename (be careful about the folder)\\n # inputs to recontruct the filenumber to the value \\\"000\\\"\\n ilbl = '000' + str(snap_id)\\n # remove all but the last 3 digits\\n ilbl = ilbl[-3:]\\n filename = \\\"%s_\\\"%(galaxy) + ilbl + '.txt'\\n \\n # Initialize an instance of CenterOfMass class, using disk particles\\n \\n COM = CenterOfMass(filename, 2)\\n\\n # Store the COM pos and vel. Remember that now COM_P required VolDec\\n COM_P = COM.COM_P(delta, VolDec)\\n COM_V = COM.COM_V(COM_P[0],COM_P[1],COM_P[2])\\n\\n \\n # store the time, pos, vel in ith element of the orbit array, without units (.value) \\n # note that you can store \\n # a[i] = var1, *tuple(array1)\\n \\n orbit[i] = COM.time.value/1000, *tuple(COM_P.value), *tuple(COM_V.value)\\n \\n # print snap_id to see the progress\\n print(snap_id)\\n \\n # write the data to a 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 per galaxy.\\n np.savetxt(fileout, orbit, fmt = \\\"%11.3f\\\"*7, comments='#',\\n header=\\\"{:>10s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}{:>11s}\\\"\\\\\\n .format('t', 'x', 'y', 'z', 'vx', 'vy', 'vz'))\",\n \"def __call__(self):\\n #Check source type and sensor type, then call appripriate methods to \\n #generate intermediate data, cascading all the way back to geometry \\n #calculation if it wasn't already done.\\n #Then return a projection matrix...\\n\\n # NOTE: returned projection_matrix is a numpy.ndarray\\n if isinstance(self.sensors, sensors_module.SensorsEEG):\\n projection_matrix = self.eeg_gain()\\n elif isinstance(self.sensors, sensors_module.SensorsMEG):\\n projection_matrix = self.meg_gain()\\n\\n return projection_matrix\",\n \"def set_params_proj(ima, p, xform = \\\"xform.projection\\\"):\\n\\tfrom EMAN2 import Vec2f\\n\\tt = Transform({\\\"type\\\":\\\"spider\\\",\\\"phi\\\":p[0],\\\"theta\\\":p[1],\\\"psi\\\":p[2]})\\n\\tt.set_trans(Vec2f(-p[3], -p[4]))\\n\\tima.set_attr(xform, t)\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"Afb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doVar(\\\"A0[0.05, -1.0, 1.0]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"Afb,A0\\\")\\n\\n \\n self.modelBuilder.factory_('expr::Alph(\\\"2.0*@0/(2.0-@0)\\\",A0)')\\n self.modelBuilder.factory_('expr::Norm(\\\"3.0/4.0/(2.0+@0)\\\",Alph)')\\n self.modelBuilder.factory_('expr::RAlph(\\\"@0*@1\\\",Alph,Norm)')\\n self.modelBuilder.factory_('expr::Rpl(\\\"(@0+@1)\\\",Norm,Afb)')\\n self.modelBuilder.factory_('expr::Rmn(\\\"(@0-@1)\\\",Norm,Afb)')\",\n \"def test_project(self):\\n import itertools\\n from numpy import array, dot\\n from numpy.linalg import det\\n\\n # our little magic constant\\n magic = 0.33377777373737737777\\n\\n # test for all kinds of curvatures K\\n for k in (0, 1, -1, 1/11, -1/11, 1 + magic, -1 - magic):\\n \\n s = space(curvature=k)\\n\\n # test line preserving projection\\n # 3 points are colinear when\\n # | x1 y1 1 |\\n # | x2 y2 1 | = 0\\n # | x3 y3 1 |\\n # let's test this!\\n\\n for p, q in itertools.permutations((\\n (1, 0),\\n (3/5, 4/5),\\n (-5/13, 12/13),\\n (-8/17, -15/17),\\n ), 2):\\n p = s.make_point(p, magic)\\n q = s.make_point(q, magic)\\n u = p.project(projection_types.preserve_lines)\\n v = (p+q).project(projection_types.preserve_lines)\\n w = (p+(-magic)*q).project(projection_types.preserve_lines)\\n d = det([[*u, 1],[*v, 1],[*w, 1]])\\n self.assertTrue(abs(d) < 1e-9)\\n\\n # test angle preserving projection\\n # map will be conformal, so we do like a secant test\\n\\n delta = 1e-9\\n vi = s.make_point((1, 0, 0), delta)\\n vj = s.make_point((0, 1, 0), delta)\\n vk = s.make_point((0, 0, 1), delta)\\n for p in (\\n (1, 0, 0),\\n (0, 3/5, 4/5),\\n (-5/13, 12/13, 0),\\n (2/11, 6/11, 9/11),\\n (3/7, 6/7, 2/7)\\n ):\\n p = s.make_point(p, magic)\\n pp = p.project(projection_types.preserve_angles)\\n pi, pj, pk = (array((p+v).project(projection_types.preserve_angles)) - pp for v in (vi, vj, vk))\\n # should stay orthogonal and same size\\n # note that we're doing a secant thing so it's only approximate\\n # thus we set a relatively high tolerance\\n self.assertTrue(isclose(\\n dot(pi, pi),\\n dot(pj, pj),\\n rel_tol = 1e-6\\n ))\\n self.assertTrue(isclose(\\n dot(pi, pi),\\n dot(pk, pk),\\n rel_tol = 1e-6\\n ))\\n self.assertTrue(isclose(\\n dot(pi, pj),\\n 0,\\n abs_tol = 1e-6\\n ))\\n self.assertTrue(isclose(\\n dot(pi, pk),\\n 0,\\n abs_tol = 1e-6\\n ))\\n self.assertTrue(isclose(\\n dot(pj, pk),\\n 0,\\n abs_tol = 1e-6\\n ))\",\n \"def awGrid(vis,HA,uvw,image_params,obs_params,Mterms,Mterms_ij):\\t\\n\\tStokes = image_params['Stokes']\\n\\t\\n\\n\\n\\tprint '--------------Gridding X pol--------------------'\\n\\txgrid_wt, xgrid_uv = gridOnePolAWproj(vis[0],HA,uvw,image_params,obs_params,Mterms[0],Mterms_ij[0])\\n\\tprint '--------------Gridding Y pol--------------------'\\n\\tygrid_wt, ygrid_uv = gridOnePolAWproj(vis[1],HA,uvw,image_params,obs_params,Mterms[1],Mterms_ij[1])\\n\\n\\tN = np.shape(xgrid_wt)[0]\\n\\tgrid_uv = np.zeros([N, N], dtype=complex)\\n\\tgrid_wt = np.zeros([N, N], dtype=complex)\\n\\t\\n\\tif Stokes == 'I':\\n\\t\\t#combine X and Y gridded vis to create the I pol gridded vis\\n\\t\\t# I = (XX+YY)/2\\n\\t\\tgrid_uv.real = (ygrid_uv.real + xgrid_uv.real)/2\\n\\t\\tgrid_uv.imag = (ygrid_uv.imag + xgrid_uv.imag)/2\\n\\n\\t\\t#combine X and Y gridded wt to create the I pol gridded wt\\n\\t\\tgrid_wt.real = (ygrid_wt.real + xgrid_wt.real)/2\\n\\t\\tgrid_wt.imag = (ygrid_wt.imag + xgrid_wt.imag)/2\\n\\n\\telif Stokes == 'Q':\\n\\t\\t#combine X and Y gridded vis to create the I pol gridded vis\\n\\t\\t# Q = (XX-YY)/2\\n\\t\\tgrid_uv.real = (ygrid_uv.real - xgrid_uv.real)/2\\n\\t\\tgrid_uv.imag = (ygrid_uv.imag - xgrid_uv.imag)/2\\n\\n\\t\\t#combine X and Y gridded wt to create the I pol gridded wt\\n\\t\\tgrid_wt.real = (ygrid_wt.real - xgrid_wt.real)/2\\n\\t\\tgrid_wt.imag = (ygrid_wt.imag - xgrid_wt.imag)/2\\n\\n\\n\\tdty_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_uv)))\\n\\tpsf_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_wt)))\\n\\n\\treturn dty_image, psf_image\",\n \"def exo2():\",\n \"def __init__(self, gridname=None, verbose=False):\\n self.gridname = gridname\\n g = re.match(r'(EASE2_[NST])([0-9\\\\.]+)km', gridname)\\n if g is None:\\n print(\\\"%s : error parsing gridname %s\\\" % (__name__, gridname),\\n file=sys.stderr,\\n flush=True)\\n raise ValueError\\n projection = g.group(1)\\n resolution = g.group(2)\\n\\n # Check for typos in resolution\\n if resolution not in resolutions:\\n print(\\\"%s : unrecognized resolution %s\\\" % (__name__, resolution),\\n file=sys.stderr,\\n flush=True)\\n raise ValueError\\n\\n # The geotransform information\\n # is the set of GDAL affine transform parameters:\\n # (map_UL_x, scale_x, b, map_UL_y, d, scale_y)\\n if projection == \\\"EASE2_N\\\":\\n # The geotransform is the set of GDAL affine transform parameters:\\n # (map_UL_x, scale_x, b, map_UL_y, d, scale_y)\\n self.proj4text = \\\"+proj=laea +lat_0=90 +lon_0=0 \\\" + \\\\\\n \\\"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\\\"\\n self.map_UL_x = -9000000.\\n self.map_UL_y = 9000000.\\n self.b = 0.\\n self.d = 0.\\n self.scale_x = float(resolution) * m_per_km\\n self.scale_y = -1 * float(resolution) * m_per_km\\n\\n elif projection == \\\"EASE2_S\\\":\\n self.proj4text = \\\"+proj=laea +lat_0=-90 +lon_0=0 \\\" + \\\\\\n \\\"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\\\"\\n self.map_UL_x = -9000000.\\n self.map_UL_y = 9000000.\\n self.b = 0.\\n self.d = 0.\\n self.scale_x = float(resolution) * m_per_km\\n self.scale_y = -1 * float(resolution) * m_per_km\\n\\n elif projection == \\\"EASE2_T\\\":\\n self.proj4text = \\\"+proj=cea +lat_0=0 +lon_0=0 +lat_ts=30 \\\" \\\\\\n \\\"+x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m\\\"\\n self.map_UL_x = -17367530.44\\n self.map_UL_y = 6756820.20000\\n self.b = 0.\\n self.d = 0.\\n base_resolution_m = 25025.26000\\n factor = resolutions.index(resolution)\\n self.scale_x = base_resolution_m / (2. ** factor)\\n self.scale_y = -1 * base_resolution_m / (2. ** factor)\\n\\n else:\\n print(\\\"%s : unrecognized projection %s\\\" % (__name__, projection),\\n file=sys.stderr,\\n flush=True)\\n raise ValueError\\n\\n # Thanks to affine help pages at\\n # https://github.com/sgillies/affine/blob/master/README.rst\\n # http://www.perrygeo.com/python-affine-transforms.html\\n geotransform = (self.map_UL_x + self.scale_x / 2.,\\n self.scale_x,\\n self.b,\\n self.map_UL_y + self.scale_y / 2.,\\n self.d,\\n self.scale_y)\\n self.fwd = Affine.from_gdal(*geotransform)\\n\\n # Initialize and save coordinate transformation\\n # for this projection\\n self.gridSpatialRef = osr.SpatialReference()\\n self.gridSpatialRef.SetFromUserInput(self.proj4text)\\n\\n # Initialize and save coordinate transformation\\n # for EPSG4326 (lat/lon)\\n self.epsg4326SpatialRef = osr.SpatialReference()\\n self.epsg4326SpatialRef.SetFromUserInput(self.epsg4326Proj4text)\\n\\n # Initialize and save the forward and reverse transformations\\n self.projToGeog = osr.CoordinateTransformation(\\n self.gridSpatialRef, self.epsg4326SpatialRef)\\n self.geogToProj = osr.CoordinateTransformation(\\n self.epsg4326SpatialRef, self.gridSpatialRef)\\n\\n if verbose:\\n print(\\\"%s : initialized new Ease2Transform object\\\" % (__name__),\\n file=sys.stderr,\\n flush=True)\",\n \"def gen_plan_params(self, n):\\r\\n n = self.gen_input_check(n)\\r\\n # generate samples of semi-major axis\\r\\n ar = self.arange.to(\\\"AU\\\").value\\r\\n # check if constrainOrbits == True for eccentricity\\r\\n if self.constrainOrbits:\\r\\n # restrict semi-major axis limits\\r\\n arcon = np.array(\\r\\n [ar[0] / (1.0 - self.erange[0]), ar[1] / (1.0 + self.erange[0])]\\r\\n )\\r\\n a = (\\r\\n np.exp(\\r\\n np.random.uniform(\\r\\n low=np.log(arcon[0]), high=np.log(arcon[1]), size=n\\r\\n )\\r\\n )\\r\\n * u.AU\\r\\n )\\r\\n tmpa = a.to(\\\"AU\\\").value\\r\\n # upper limit for eccentricity given sma\\r\\n elim = np.zeros(len(a))\\r\\n amean = np.mean(ar)\\r\\n elim[tmpa <= amean] = 1.0 - ar[0] / tmpa[tmpa <= amean]\\r\\n elim[tmpa > amean] = ar[1] / tmpa[tmpa > amean] - 1.0\\r\\n elim[elim > self.erange[1]] = self.erange[1]\\r\\n elim[elim < self.erange[0]] = self.erange[0]\\r\\n\\r\\n # uniform distribution\\r\\n e = np.random.uniform(low=self.erange[0], high=elim, size=n)\\r\\n else:\\r\\n a = (\\r\\n np.exp(np.random.uniform(low=np.log(ar[0]), high=np.log(ar[1]), size=n))\\r\\n * u.AU\\r\\n )\\r\\n e = np.random.uniform(low=self.erange[0], high=self.erange[1], size=n)\\r\\n\\r\\n # generate geometric albedo\\r\\n pr = self.prange\\r\\n p = np.random.uniform(low=pr[0], high=pr[1], size=n)\\r\\n # generate planetary radius\\r\\n Rpr = self.Rprange.to(\\\"earthRad\\\").value\\r\\n Rp = (\\r\\n np.exp(np.random.uniform(low=np.log(Rpr[0]), high=np.log(Rpr[1]), size=n))\\r\\n * u.earthRad\\r\\n )\\r\\n\\r\\n return a, e, p, Rp\",\n \"def __init__(self, random_org_parameters, composition_space, constraints):\\n\\n self.name = 'random organism creator'\\n\\n # defaults\\n #\\n # number of random organisms to make (only used for epa searches)\\n self.default_number = 28\\n # max number of atoms\\n if composition_space.objective_function == 'epa':\\n # make sure we can sample cells with two formula units\\n target_number = constraints.min_num_atoms + 6\\n num_formulas = target_number/composition_space.endpoints[\\n 0].num_atoms\\n if num_formulas < 2:\\n min_of_max = int(2*composition_space.endpoints[0].num_atoms)\\n else:\\n min_of_max = int(round(\\n num_formulas)*composition_space.endpoints[0].num_atoms)\\n else:\\n min_of_max = constraints.min_num_atoms + 6\\n self.default_max_num_atoms = min(min_of_max, constraints.max_num_atoms)\\n # allow structure with compositions at the endpoints (for pd searches)\\n self.default_allow_endpoints = True\\n # volume scaling behavior\\n # default volumes per atom of elemental ground state structures\\n # computed from structures on materials project (materialsproject.org)\\n self.all_default_vpas = {'H': 13.89, 'He': 15.79, 'Li': 20.12,\\n 'Be': 7.94, 'B': 7.25, 'C': 10.58,\\n 'N': 42.73, 'O': 13.46, 'F': 16.00,\\n 'Ne': 19.93, 'Na': 37.12, 'Mg': 23.04,\\n 'Al': 16.47, 'Si': 20.44, 'P': 23.93,\\n 'S': 36.03, 'Cl': 34.90, 'Ar': 44.87,\\n 'K': 73.51, 'Ca': 42.42, 'Sc': 24.64,\\n 'Ti': 17.11, 'V': 13.41, 'Cr': 11.57,\\n 'Mn': 11.04, 'Fe': 11.55, 'Co': 10.92,\\n 'Ni': 10.79, 'Cu': 11.82, 'Zn': 15.56,\\n 'Ga': 20.34, 'Ge': 23.92, 'As': 22.45,\\n 'Se': 38.13, 'Br': 37.53, 'Kr': 65.09,\\n 'Rb': 90.44, 'Sr': 54.88, 'Y': 32.85,\\n 'Zr': 23.50, 'Nb': 18.31, 'Mo': 15.89,\\n 'Tc': 14.59, 'Ru': 13.94, 'Rh': 14.25,\\n 'Pd': 15.45, 'Ag': 18.00, 'Cd': 23.28,\\n 'In': 27.56, 'Sn': 36.70, 'Sb': 31.78,\\n 'Te': 35.03, 'I': 50.34, 'Xe': 83.51,\\n 'Cs': 116.17, 'Ba': 63.64, 'Hf': 22.50,\\n 'Ta': 18.25, 'W': 16.19, 'Re': 15.06,\\n 'Os': 14.36, 'Ir': 14.55, 'Pt': 15.72,\\n 'Au': 18.14, 'Hg': 31.45, 'Tl': 31.13,\\n 'Pb': 32.30, 'Bi': 36.60, 'La': 37.15,\\n 'Ce': 26.30, 'Pr': 36.47, 'Nd': 35.44,\\n 'Pm': 34.58, 'Sm': 33.88, 'Eu': 46.28,\\n 'Gd': 33.33, 'Tb': 32.09, 'Dy': 31.57,\\n 'Ho': 31.45, 'Er': 30.90, 'Tm': 30.30,\\n 'Yb': 40.45, 'Lu': 29.43, 'Ac': 45.52,\\n 'Th': 32.03, 'Pa': 25.21, 'U': 19.98,\\n 'Np': 18.43, 'Pu': 18.34}\\n\\n self.default_vpas = self.get_default_vpas(composition_space)\\n\\n # set to defaults\\n if random_org_parameters in (None, 'default'):\\n self.number = self.default_number\\n self.max_num_atoms = self.default_max_num_atoms\\n self.allow_endpoints = self.default_allow_endpoints\\n self.vpas = self.default_vpas\\n # parse the parameters and set to defaults if necessary\\n else:\\n # the number to make\\n if 'number' not in random_org_parameters:\\n self.number = self.default_number\\n elif random_org_parameters['number'] in (None, 'default'):\\n self.number = self.default_number\\n else:\\n self.number = random_org_parameters['number']\\n\\n # the max number of atoms\\n if 'max_num_atoms' not in random_org_parameters:\\n self.max_num_atoms = self.default_max_num_atoms\\n elif random_org_parameters['max_num_atoms'] in (None, 'default'):\\n self.max_num_atoms = self.default_max_num_atoms\\n elif random_org_parameters['max_num_atoms'] > \\\\\\n constraints.max_num_atoms:\\n print('The value passed to the \\\"max_num_atoms\\\" keyword in the '\\n 'InitialPopulation block may not exceed the value passed'\\n ' to the \\\"max_num_atoms\\\" keyword in the Constraints '\\n 'block.')\\n print('Quitting...')\\n quit()\\n elif random_org_parameters['max_num_atoms'] < \\\\\\n constraints.min_num_atoms:\\n print('The value passed to the \\\"max_num_atoms\\\" keyword in the '\\n 'InitialPopulation block may not be smaller than the '\\n 'value passed to the \\\"min_num_atoms\\\" keyword in the '\\n 'Constraints block.')\\n print('Quitting...')\\n quit()\\n else:\\n self.max_num_atoms = random_org_parameters['max_num_atoms']\\n\\n # allowing composition space endpoints (only used for pd searches)\\n if 'allow_endpoints' not in random_org_parameters:\\n self.allow_endpoints = self.default_allow_endpoints\\n elif random_org_parameters['allow_endpoints'] in (None, 'default'):\\n self.allow_endpoints = self.default_allow_endpoints\\n else:\\n self.allow_endpoints = random_org_parameters['allow_endpoints']\\n\\n # volume scaling\\n self.vpas = self.default_vpas\\n if 'volumes_per_atom' not in random_org_parameters:\\n pass\\n elif random_org_parameters['volumes_per_atom'] in (None,\\n 'default'):\\n pass\\n else:\\n # replace the specified volumes per atom with the given values\\n for symbol in random_org_parameters['volumes_per_atom']:\\n self.vpas[symbol] = random_org_parameters[\\n 'volumes_per_atom'][symbol]\\n\\n self.num_made = 0 # number added to initial population\\n self.is_successes_based = True # it's based on number added\\n self.is_finished = False\",\n \"def ParameterFitness(self,planet_params):\\n\\t\\t\\n\\t\\ttFinal = self.Observations.tFinal() + np.max(self.Observations.PeriodEstimates)\\n\\t\\n\\t\\t# Full 3-D input\\n\\t\\tif len(planet_params.reshape(-1))== 7 * self.Observations.nplanets:\\n\\t\\t\\ttransits,success = self.MCMC_Param_TransitTimes(planet_params,tFinal)\\n\\t\\n\\t\\t# Nodes relative to inner planet node inputs\\n\\t\\telif len(planet_params.reshape(-1)) == 7 * self.Observations.nplanets - 1:\\n\\t\\t\\ttransits,success = self.MCMC_RelativeNodeParam_TransitTimes(planet_params,tFinal)\\n\\t\\n\\t\\t# All inclinations = 90 deg. only nodes of non-first planet vary\\n\\t\\telif len(planet_params.reshape(-1)) == 6 * self.Observations.nplanets:\\n\\t\\t\\ttransits,success = self.MCMC_NodeOnlyParam_TransitTimes(planet_params,tFinal)\\n\\n\\t\\t# All coplanar\\n\\t\\telif len(planet_params.reshape(-1)) == 5 * self.Observations.nplanets :\\n\\t\\t\\ttransits,success = self.MCMC_CoplanarParam_TransitTimes(planet_params,tFinal)\\n\\t\\telse:\\n\\t\\t\\traise ValueError(\\\"Bad input dimensions: %d \\\"%(len(planet_params.reshape(-1))))\\n\\t\\t\\n\\t\\tif not success:\\n\\t\\t\\treturn -np.inf\\n\\t\\ttry:\\n\\t\\t\\ttransit_list = [ transits[i][nums] for i,nums in enumerate(self.Observations.transit_numbers) ]\\n\\t\\texcept:\\n\\t\\t\\t# If the number of computed transits is less than the number of observed transits\\n\\t\\t\\t#\\tthen -infinity should be returned\\n\\t\\t\\treturn -np.inf\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\tchi2 = self.Observations.get_chi2(transit_list)\\n\\t\\treturn - 0.5 * chi2\",\n \"def get_params_proj(ima, xform = \\\"xform.projection\\\"):\\n\\tt = ima.get_attr(xform)\\n\\td = t.get_params(\\\"spider\\\")\\n\\treturn d[\\\"phi\\\"],d[\\\"theta\\\"],d[\\\"psi\\\"],-d[\\\"tx\\\"],-d[\\\"ty\\\"]\",\n \"def runSimulation(self, R=5000, N=1,s=1000, method='RL'):\\n global n_ec\\n import numpy as np\\n import matplotlib.pyplot as plt\\n import matplotlib\\n matplotlib.use('Agg')\\n matplotlib.pyplot.switch_backend('agg')\\n\\n plt.rcParams.update({'font.size':20})\\n plt.rc('xtick', labelsize=20)\\n plt.rc('ytick', labelsize=20)\\n # step = 2 fs\\n # each round is 2 fs * 1000 = 2 ps\\n\\n init = 'ala2_1stFrame.pdb' #pdb name\\n inits = init\\n n_ec = 2 # angles\\n count = 1\\n newPoints_name = 'start_r_'+str(count)+'.pdb'\\n \\n #W_0 = [1/n_ec for i in range(n_ec)] # no direction\\n #W_0 = [[0.25, 0.25], [0.25, 0.25]]\\n W_0 = [[1/(2*n_ec), 1/(2*n_ec)] for i in range(n_ec)] # directional\\n print(W_0)\\n\\n Ws = []\\n Ws.append(W_0)\\n \\n trj1 = self.run(production_steps = s, start=inits, production='trj_R_0.pdb') # return mdtraj object\\n comb_trj1 = trj1 # single trajectory\\n trjs = comb_trj1\\n trj1_theta = self.map_angles(trj1) # changed for angles to display\\n print('trj1_theta', len(trj1_theta), len(trj1_theta[0]))\\n trj1_Ps_theta, index = self.PreSamp(trj1_theta, myn_clusters = 10) # pre analysis (least count)\\n trj1_Ps_w_theta, index_w = self.PreSamp(trj1_theta, myn_clusters = 100) # for updating the weights\\n print('trj1_Ps_theta', len(trj1_Ps_theta), len(trj1_Ps_theta[0]))\\n\\n newPoints_index_orig = self.findStarting(trj1_Ps_theta, index, W_0, starting_n = N , method = 'RL') #need change\\n newPoints = trj1[newPoints_index_orig[0]]\\n newPoints.save_pdb(newPoints_name)\\n \\n \\n print('trj1_theta[0]',trj1_theta[0])\\n plt.scatter(trj1_theta[0], trj1_theta[1], color='dodgerblue', s=5, alpha=0.2)\\n plt.xlim([-180, 180])\\n plt.ylim([-180, 180])\\n newPoints_theta_x = trj1_theta[0][newPoints_index_orig[0]]\\n newPoints_theta_y = trj1_theta[1][newPoints_index_orig[0]]\\n plt.scatter(newPoints_theta_x, newPoints_theta_y, color='red', s=50)\\n plt.xlabel(r'$\\\\phi$')\\n plt.ylabel(r'$\\\\psi$')\\n plt.savefig('fig_'+str(count))\\n plt.close()\\n trjs_theta = trj1_theta\\n trjs_Ps_theta = trj1_Ps_theta\\n trjs_Ps_w_theta = trj1_Ps_w_theta \\n for round in range(R):\\n self.updateStat(trjs_theta) # based on all trajectories\\n #W_1 = self.updateW(trjs_Ps_theta, W_0) \\n W_1 = self.updateW(trjs_Ps_w_theta, W_0) \\n W_0 = W_1\\n W_1 = W_0\\n Ws.append(W_0)\\n s = 1000\\n trj1 = self.run(production_steps = s, start=newPoints_name, production='trj_R_'+str(count)+'.pdb') # return mdtraj object\\n com_trjs = trjs.join(trj1) \\n trjs = com_trjs\\n trjs_theta = np.array(self.map_angles(trjs)) \\n trjs_Ps_theta, index = self.PreSamp(trjs_theta, myn_clusters = 100)\\n myn_clusters1 = 100 #int(10*(round)+1)\\n trjs_Ps_w_theta = trjs_Ps_theta\\n #trjs_Ps_w_theta, index_w = self.PreSamp(trjs_theta, myn_clusters = myn_clusters1)\\n newPoints_index_orig = self.findStarting(trjs_Ps_theta, index, W_1, starting_n = N , method = 'RL')\\n newPoints = trjs[newPoints_index_orig[0]] \\n \\n count = count + 1\\n newPoints_name = 'start_r_'+str(count)+'.pdb'\\n newPoints.save_pdb(newPoints_name)\\n\\n print( myn_clusters1, W_1, self.theta_mean)\\n plt.scatter(trjs_theta[0], trjs_theta[1], color='dodgerblue', s=5, alpha=0.2)\\n plt.xlim([-np.pi, np.pi])\\n plt.ylim([-np.pi, np.pi])\\n newPoints_theta_x = trjs_theta[0][newPoints_index_orig[0]]\\n newPoints_theta_y = trjs_theta[1][newPoints_index_orig[0]]\\n plt.scatter(newPoints_theta_x, newPoints_theta_y, color='red', s=50)\\n plt.scatter(trjs_Ps_w_theta[0], trjs_Ps_w_theta[1], color='green', s=5)\\n plt.xlabel(r'$\\\\phi$')\\n plt.ylabel(r'$\\\\psi$')\\n plt.savefig('fig_'+str(count))\\n plt.close()\\n \\n np.save('w_'+'r'+str(int(R))+'N'+str(N)+'s'+str(s), Ws)\\n np.save('trjs_theta', trjs_theta)\\n return\",\n \"def __init__(self,SO,d_dimp,rd_dimp,N_e,N_a):\\n self.sphere = SO;\\n self.d_dimp = d_dimp;\\n self.rd_dimp = rd_dimp;\\n self.N_e = N_e;\\n self.N_a = N_a;\",\n \"def __init__(self, espectro, Npicos):\\r\\n self.Npicos = Npicos\\r\\n self.spec = espectro.real\\r\\n self.ppmGridDir = espectro.ppmGridDir\\r\\n self.ppmGridInd = espectro.ppmGridInd \\r\\n self.regiones = self.crear_regiones(Npicos)\\r\\n self.integrales = None\",\n \"def get_problem():\\n\\n #User Defined Terrain Elevation\\n #def terr( x_pos, y_pos ):\\n #Defines terrain elevation [m] as a function of x and y positions [m]\\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\\n # return elev\\n\\n #User Defined Tunnel Cost\\n #def tunnel(depth):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #depth below the ground.\\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\\n # return TunnelCost\\n\\n #def bridge(height):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #heigh above the ground.\\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\\n # return BridgeCost\\n\\n # Rename this and/or move to optim package?\\n problem = beluga.optim.Problem('surftest_noinc')\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','m') \\\\\\n .state('y','V*sin(hdg)','m') \\\\\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\\\\n .state('hdg','cmax/V*sin(hdgA)','rad')\\n\\n # Define controls\\n #problem.control('thrA','rad') \\\\\\n # .control('hdgA','rad')\\n problem.control('hdgA','rad')\\n\\n # Define Cost Functional\\n problem.cost['path'] = Expression('1','s')\\n\\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\\n\\n #+ \\\\\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\\\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','m') \\\\\\n .initial('y-y_0','m') \\\\\\n .initial('V-V_0','m/s') \\\\\\n .initial('hdg-hdg_0','rad') \\\\\\n .terminal('x-x_f','m') \\\\\\n .terminal('y-y_f','m')\\n #.terminal('V-V_f','m/s')\\n #.initial('hdg-hdg_0','rad') \\\\\\n\\n #Define constants\\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\\n problem.constant('eps',10,'m/s^2') #Error constant\\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\\n problem.constant('thrA',0,'rad')\\n\\n #Unit scaling\\n problem.scale.unit('m','x') \\\\\\n .unit('s','x/V') \\\\\\n .unit('rad',1) \\\\\\n .unit('USD',1)\\n\\n #Configure solver\\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\\n\\n #Initial Guess\\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\\n\\n #Add Continuation Steps\\n problem.steps.add_step().num_cases(10) \\\\\\n .terminal('x', 10) \\\\\\n .terminal('y', 0)\\n\\n problem.steps.add_step().num_cases(10) \\\\\\n .const('eps', 0.2)\\n\\n #problem.steps.add_step().num_cases(10) \\\\\\n # .terminal('y', 2*pi*1000) \\\\\\n # .terminal('z', 0.0) \\\\\\n # .terminal('inc', 0.0)\\n #^ City B\\n return problem\",\n \"def __init__(self,):\\r\\n self.g = 9.81\\r\\n self.l = 0.5\\r\\n self.m1 = 1.0\\r\\n self.m2 = 1.0\\r\\n self.m3 = 1.0\\r\\n self.r1 = 1.0\\r\\n self.r2 = 1.0\\r\\n self.tau = 0.001\\r\\n self.theta1 = 1.0\\r\\n self.theta2 = 1.0\\r\\n self.theta3 = 1.0\",\n \"def prj(self,method):\\n valid_methods={\\\"max\\\",\\\"sum\\\",\\\"mean\\\"}\\n if method not in valid_methods:\\n warnings.warn(\\\"Projection method is not valid, pick from following valid methods: {valid_methods}\\\", UserWarning)\\n elif method==\\\"max\\\":\\n self.maxprj=(np.amax(self.pixels,axis=0))\\n elif method==\\\"sum\\\":\\n self.sumprj=(np.sum(self.pixels,axis=0))\\n elif method==\\\"mean\\\":\\n self.meanprj=(np.mean(self.pixels,axis=0))\",\n \"def project(self, X):\",\n \"def project(self, X):\",\n \"def solar_model():\\n \\n latitude, longitude, timezone, elevation = location_input()\\n year, time = time_input()\\n\\n lat_r = latitude/180*np.pi\\n lon_r = longitude/180*np.pi \\n n = 0\\n for i in range(1900,year):\\n if i%4 == 0:\\n n += 366\\n else:\\n n+=365\\n JulD = n + time + 2415018.5 - (timezone)/24\\n LT = time - int(time)\\n JC = (JulD - 2451545) / 36525\\n x = 46.815 + JC * (0.00059 - JC * 0.001813)\\n M_OE = 23 + (26 + (21.448 - JC * x) / 60) / 60\\n EEO = 0.016708634 - JC * (0.000042037 + 0.0000001267 * JC)\\n GMAS = 357.52911 + JC * (35999.05029 - 0.0001537 * JC)\\n GMAS_r = m.radians(GMAS)\\n GMLS = (280.46646 + JC * (36000.76983 + JC * 0.0003032))%360\\n GMLS_r = m.radians(GMLS)\\n Obliq_C = M_OE + 0.00256 * np.cos((125.04 - 1934.136 * JC) / 180 * np.pi)\\n Obliq_C_r = m.radians(Obliq_C)\\n SEC = np.sin(GMAS_r) * (1.914602 - JC * (0.004817 + 0.000014 * JC)) + np.sin(2 * GMAS_r) * (0.019993 - 0.000101 * JC) + np.sin(3 * GMAS_r) * 0.000289\\n STL = GMLS + SEC\\n SAL = STL - 0.00569 - 0.00478 * np.sin((125.04 - 1934.136 * JC) / 180 * np.pi)\\n SAL_r = m.radians(SAL)\\n sin_Delta = np.sin(Obliq_C_r) * np.sin(SAL_r)\\n Delta_r = np.arcsin(sin_Delta) #in radians \\n Var_y = np.tan((Obliq_C / 2) / 180 * np.pi) * np.tan((Obliq_C / 2) / 180 * np.pi)\\n EOT_prime = Var_y * np.sin(2 * GMLS_r) - 2 * EEO * np.sin(GMAS_r) + 4 * EEO * Var_y * np.sin(GMAS_r) * np.cos(2 * GMLS_r) - 0.5 * Var_y * Var_y * np.sin(4 * GMLS_r) - 1.25 * EEO * EEO * np.sin(2 * GMAS_r)\\n EOT = 4 * EOT_prime / np.pi * 180 \\n TST = (LT * 1440 + EOT + 4 * longitude - 60 * timezone)%1440\\n if TST / 4 < 0:\\n Omega = TST/4+180\\n else:\\n Omega = TST/4 - 180 \\n Omega_r = m.radians(Omega)\\n \\n cos_Zenith = np.sin(lat_r) * np.sin(Delta_r) + np.cos(lat_r) * np.cos(Delta_r) * np.cos(Omega_r)\\n Zenith_r = np.arccos(cos_Zenith) #in radians\\n Aprime_r = np.arccos((np.sin(lat_r) * np.cos(Zenith_r) - np.sin(Delta_r)) / (np.cos(lat_r) * np.sin(Zenith_r)))\\n Aprime = Aprime_r / np.pi * 180\\n if Omega > 0:\\n Azimuth = (Aprime + 180) % 360 #in degrees\\n else:\\n Azimuth = (540 - Aprime) % 360 #in degrees \\n Azimuth_r = Azimuth / 180 * np.pi\\n Elev_angle = (np.pi)/2 - Zenith_r\\n\\n \\n # calculate incidence angle\\n # Beta is equal to angle of tilted surface to horizontal (in radians)\\n Beta = 45 # in degrees\\n Beta_r = m.radians(Beta)\\n \\n cos_incidence = np.sin(Delta_r)* np.sin(lat_r) * np.cos(Beta_r) - np.sin(Delta_r) * np.cos(lat_r) * np.sin(Beta_r) * np.cos(Azimuth_r) + np.cos(Delta_r) * np.cos(lat_r) * np.cos(Beta_r) * np.cos(Omega_r) + np.cos(Delta_r) * np.sin(lat_r) * np.sin(Beta_r) * np.cos(Azimuth_r) * np.cos(Omega_r) + np.cos(Delta_r) * np.sin(Beta_r) * np.sin(Azimuth_r) * np.sin(Omega_r) \\n incidence_ang_r = np.arccos(cos_incidence)\\n \\n return Delta_r, lat_r, Omega_r, Zenith_r, Azimuth_r, Elev_angle\",\n \"def __init__(self, rp_dim:int,gamma,rp_method='Classical',rp_mode='Gaussian',solve_method='Exact'):\\n self.rp_dim = rp_dim\\n self.rp_method = rp_method\\n self.rp_mode = rp_mode\\n self.solve_method = solve_method\\n if self.rp_method not in ['Classical', 'Hessian']:\\n raise NotImplementedError('Only Classical and Hessian methods are supported.')\\n if self.rp_mode not in ['Gaussian', 'SJLT']:\\n raise NotImplementedError('Only Gaussian and SJLT modes are supported.')\\n if self.solve_method not in ['Exact','ShiWoodbury']:\\n raise NotImplementedError('Only Exact and ShiWoodbury methods are implemented')\\n if not isinstance(gamma,list):\\n self.gamma = [gamma]\\n else:\\n self.gamma = gamma\",\n \"def __init__(self, ni, nj, nk):\\n \\n self.ni = ni\\n self.nj = nj\\n self.nk = nk\\n \\n self.nn = np.zeros(3)\\n \\n self.nn[0] = self.ni\\n self.nn[1] = self.nj\\n self.nn[2] = self.nk\\n \\n self.x0 = np.zeros(3)\\n self.dh = np.zeros(3)\\n self.xm = np.zeros(3)\\n self.xc = np.zeros(3)\\n \\n self.EPS_0 = 8.85418782e-12\\n self.QE = 1.602176565e-19;\\n self.AMU = 1.660538921e-27\\n self.ME = 9.10938215e-31;\\n self.K = 1.380648e-23;\\n self.EvToK = self.QE/self.K;\\n \\n self.phi = np.zeros((self.ni, self.nj, self.nk))\\n self.phi_new = np.zeros((self.ni, self.nj, self.nk))\\n self.R = np.zeros((self.ni, self.nj, self.nk))\\n self.rho = np.zeros((self.ni, self.nj, self.nk))\\n self.node_vol = np.zeros((self.ni, self.nj, self.nk))\\n self.ef = np.zeros((self.ni, self.nj, self.nk, 3))\",\n \"def new_param_energy_vac(coords, params, T=293.15):\\n\\n #-------------------\\n # CONSTANTS\\n #-------------------\\n kB = 0.0083145 #Boltzmann constant (Gas constant) in kJ/(mol*K)\\n beta = 1/(kB*T)\\n\\n #-------------------\\n # PARAMETERS\\n #-------------------\\n params = params\\n \\n # Determine number of states we wish to estimate potential energies for\\n mols = []\\n for i in params:\\n mols.append(i)\\n mol = '../monomers/'+mols[0]+'.mol2'\\n K = len(params[mols[0]].keys())\\n\\n\\n #-------------\\n # SYSTEM SETUP\\n #-------------\\n verbose = False # suppress echos from OEtoolkit functions\\n ifs = oechem.oemolistream(mol)\\n mol = oechem.OEMol()\\n # This uses parm@frosst atom types, so make sure to use the forcefield-flavor reader\\n flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield\\n ifs.SetFlavor( oechem.OEFormat_MOL2, flavor)\\n oechem.OEReadMolecule(ifs, mol )\\n # Perceive tripos types\\n oechem.OETriposAtomNames(mol)\\n\\n # Load forcefield file\\n #ffxml = 'smirnoff99Frosst_with_AllConstraints.ffxml'#\\n #print('The forcefield being used is smirnoff99Frosst_with_AllConstraints.ffxml')\\n ffxml = get_data_filename('forcefield/smirnoff99Frosst.ffxml')\\n print('The forcefield being used is smirnoff99Frosst.ffxml')\\n\\n ff = ForceField(ffxml)\\n\\n # Generate a topology\\n topology = generateTopologyFromOEMol(mol)\\n\\n #-----------------\\n # MAIN\\n #-----------------\\n\\n # Calculate energies\\n\\n E_kn = np.zeros([K,len(coords)],np.float64)\\n u_kn = np.zeros([K,len(coords)],np.float64)\\n for i,j in enumerate(params):\\n AlkEthOH_id = j\\n for k,l in enumerate(params[AlkEthOH_id]):\\n print(\\\"Anotha one\\\")\\n for m,n in enumerate(params[AlkEthOH_id][l]):\\n newparams = ff.getParameter(smirks=n[0]) \\n newparams[n[1]]=n[2]\\n ff.setParameter(newparams,smirks=n[0])\\n system = ff.createSystem(topology, [mol])\\n #print(newparams)\\n for o,p in enumerate(coords):\\n e = get_energy_vac(system,p)\\n E_kn[k,o] = e._value\\n u_kn[k,o] = e._value*beta\\n\\n\\n return E_kn,u_kn\",\n \"def setup(self, method='dist', w=None, p=0.20, lamb=1e-2, n=32, s=20., ratio=0.1):\\n # parameters for GREIT projection\\n if w is None:\\n w = np.ones_like(self.alpha)\\n self.params = {\\n 'w': w,\\n 'p': p,\\n 'lamb': lamb,\\n 'n': n,\\n 's': s,\\n 'ratio': ratio\\n }\\n # action (currently only support 'dist')\\n if method is 'dist':\\n self.H = self._build_dist()\\n else:\\n raise ValueError('method ' + method + ' not supported yet')\",\n \"def updateParameters(self, parameters):\\r\\n if parameters[0].altered:\\r\\n in_nc_file = parameters[0].valueAsText\\r\\n\\r\\n # Establish an object for reading the input NetCDF file\\r\\n ncFP = arcpy.NetCDFFileProperties(in_nc_file)\\r\\n\\r\\n # Loop through global variables in NetCDF file to gather projection information\\r\\n ncVarNames = ncFP.getVariablesByDimension('west_east')\\r\\n ncMassgridNames = []\\r\\n for x in ncVarNames:\\r\\n mgridvar = ncFP.getAttributeValue(x, 'stagger') # Only use variables on Massgrid for now ('M')\\r\\n if mgridvar == 'M':\\r\\n ncMassgridNames.append(x)\\r\\n parameters[1].filter.list = ncMassgridNames\\r\\n return\",\n \"def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \\\"north\\\"):\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n\\n mlatA = self.mlatA[inds]\\n mlatB = self.mlatB[inds]\\n mlatC = self.mlatC[inds]\\n\\n mean_range = 5\\n NeA = self.meanie(NeA, mean_range)\\n NeB = self.meanie(NeB, mean_range)\\n NeC = self.meanie(NeC, mean_range)\\n \\n \\n N = int((len(NeA)/n*2) - 1) #nr of windows\\n \\n dx = (secondsB[1]-secondsB[0])*self.velB[0]\\n \\n nBAs = []\\n nBCs = []\\n nACs = []\\n \\n for i in range(N):\\n startind = int(i/2*n)\\n stopind = int((i/2+1)*n)\\n temp_NeA = NeA[startind:stopind]\\n temp_NeB = NeB[startind:stopind]\\n temp_NeC = NeC[startind:stopind]\\n \\n temp_secondsA = secondsA[startind:stopind]\\n temp_secondsB = secondsB[startind:stopind]\\n temp_secondsC = secondsC[startind:stopind]\\n \\n \\n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\\n if np.sum(curr_timediff) > 2:\\n continue\\n \\n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\\n \\n if np.max(gradA) < 0.9:\\n continue\\n \\n stdA = np.std(gradA)\\n stdB = np.std(gradB)\\n stdC = np.std(gradC)\\n \\n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\\n \\n p0A = [1, meanA, stdA]\\n p0B = [1, meanB, stdB]\\n p0C = [1, meanB, stdB]\\n \\n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\\n \\n nBA = poptB[1] - poptA[1]\\n nBC = poptB[1] - poptC[1]\\n nAC = poptA[1] - poptC[1]\\n \\n nBAs.append(nBA)\\n nBCs.append(nBC)\\n nACs.append(nAC)\\n \\n \\n sBA = self.BA_shift/2 #time delay BA\\n sBC = self.BC_shift/2 #time delay BC\\n sAC = (self.BC_shift - self.BA_shift)/2\\n V = self.velA[0]\\n for i in range(len(nBAs)):\\n VBA = self.along_track_velo(V, sBA, nBAs[i])\\n VBC = self.along_track_velo(V, sBC, nBCs[i])\\n VAC = self.along_track_velo(V, sAC, nACs[i])\\n \\n print(VBA)\\n print(VBC)\\n print(VAC)\\n print(\\\"________________________________________\\\")\",\n \"def solve(self):\",\n \"def __init__(self, f, N_elements, C, D, analytical, grid_points):\\n\\n\\n\\n self.Ne = N_elements\\n self.gp = grid_points\\n self.C = C\\n self.D = D\\n self.f = lambda x: f(x)\\n self.tol = 10e-4\\n self.x = sym.Symbol(\\\"x\\\")\\n\\n self.h = 1/(2*self.Ne)\\n self.global_matrix = np.zeros([2*self.Ne, 2*self.Ne])\\n self.global_vector = np.zeros([2*self.Ne])\\n self.psi = sym.zeros(3*self.Ne,1)\\n\\n self.analytical = lambda x,C,D: analytical(x,C,D)\\n\\n self.x_values = np.linspace(0,1,self.gp)\",\n \"def projectionManip(*args, fitBBox: bool=True, projType: int=0, switchType: bool=True, q=True,\\n query=True, **kwargs)->Union[None, Any]:\\n pass\",\n \"def __SetSFParams(self):\\n\\n # If radial structure functions are in output\\n if self.__containsRadial:\\n # Defines radial attributes\\n self.__nc_RSoft_O.radial_error_tolerance = self.etol_radial\\n\\n # Defines radial dimensions\\n self.__nc_RSoft_O.createDimension('radial_structure_functions',\\\\\\n len(self.mus))\\n\\n # Defines radial variables\\n mus_var_id_O = self.__nc_RSoft_O.createVariable('mus', \\\\\\n 'f4', ('radial_structure_functions'))\\n Ls_var_id_O = self.__nc_RSoft_O.createVariable('Ls', \\\\\\n 'f4', ('radial_structure_functions'))\\n radial_Xs_var_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'radial_Xs', 'i4', ('radial_structure_functions'))\\n radial_Ys_var_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'radial_Ys', 'i4', ('radial_structure_functions'))\\n\\n # Sets radial structure function variables\\n mus_var_id_O[:] = self.mus\\n Ls_var_id_O[:] = self.Ls\\n radial_Xs_var_id_O[:] = self.radial_Xs\\n radial_Ys_var_id_O[:] = self.radial_Ys\\n\\n # If angular structure functions are in output\\n if self.__containsAngular:\\n # Defines angular attributes\\n self.__nc_RSoft_O.angular_error_tolerance = self.etol_angular\\n\\n # Defines angular dimensions\\n self.__nc_RSoft_O.createDimension('angular_structure_functions',\\\\\\n len(self.xis))\\n\\n # Defines angular variables\\n xis_var_id_O = self.__nc_RSoft_O.createVariable('xis', \\\\\\n 'f4', ('angular_structure_functions'))\\n zetas_var_id_O = self.__nc_RSoft_O.createVariable('zetas', \\\\\\n 'i4', ('angular_structure_functions'))\\n lambdas_var_id_O = self.__nc_RSoft_O.createVariable('lambdas', \\\\\\n 'i4', ('angular_structure_functions'))\\n angular_Xs_var_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'angular_Xs', 'i4', ('angular_structure_functions'))\\n angular_Ys_var_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'angular_Ys', 'i4', ('angular_structure_functions'))\\n angular_Zs_var_id_O = self.__nc_RSoft_O.createVariable(\\\\\\n 'angular_Zs', 'i4', ('angular_structure_functions')) \\n\\n # Sets angular structure function variables\\n xis_var_id_O[:] = self.xis\\n zetas_var_id_O[:] = self.zetas\\n lambdas_var_id_O[:] = self.lambdas\\n angular_Xs_var_id_O[:] = self.angular_Xs\\n angular_Ys_var_id_O[:] = self.angular_Ys\\n angular_Zs_var_id_O[:] = self.angular_Zs\",\n \"def doParametersOfInterest(self):\\n self.modelBuilder.doVar(\\\"kappa_W[1,0.0,2.0]\\\") \\n self.modelBuilder.doVar(\\\"kappa_Z[1,0.0,2.0]\\\") \\n self.modelBuilder.doVar(\\\"kappa_tau[1,0.0,3.0]\\\")\\n self.modelBuilder.doVar(\\\"kappa_mu[1,0.0,5.0]\\\") \\n self.modelBuilder.factory_(\\\"expr::kappa_mu_expr(\\\\\\\"@0*@1+(1-@0)*@2\\\\\\\", CMS_use_kmu[0], kappa_mu, kappa_tau)\\\")\\n self.modelBuilder.doVar(\\\"kappa_t[1,0.0,4.0]\\\")\\n # additional kappa for the anomalous coupling\\n self.modelBuilder.doVar(\\\"kappa_tilde_t[0.0,0.0,4.0]\\\")\\n self.modelBuilder.doVar(\\\"kappa_b[1,0.0,3.0]\\\")\\n if not self.resolved:\\n self.modelBuilder.doVar(\\\"kappa_g[1,0.0,2.0]\\\")\\n self.modelBuilder.doVar(\\\"kappa_gam[1,0.0,2.5]\\\")\\n\\tself.modelBuilder.doVar(\\\"BRinv[0,0,1]\\\")\\n self.modelBuilder.out.var(\\\"BRinv\\\").setConstant(True)\\n # adding additional kappa to list of parameters of interest\\n pois = 'kappa_W,kappa_Z,kappa_tau,kappa_t,kappa_tilde_t,kappa_b'\\n if not self.resolved:\\n pois += ',kappa_g,kappa_gam'\\n self.doMH()\\n self.modelBuilder.doSet(\\\"POI\\\",pois)\\n # use modified Higgs Builder\\n self.SMH = AnomalousTopHiggsBuilder(self.modelBuilder)\\n self.setup()\",\n \"def geocube():\",\n \"def parameters(self):\",\n \"def iter_fun(self):\\n\\n run_id = self._run_id\\n etopo_dir = driver_home\\n topodir = driver_home\\n\\n # load input info\\n if self._input_info == None:\\n scn_fname = os.path.join(self._run_home,'scenario_pts.txt') \\n scn = np.loadtxt(scn_fname)\\n scn_list = scn.tolist()\\n else:\\n scn_list = self._input_info\\n \\n # total number of runs\\n M = len(scn_list)\\n N = 8*M + 2 # 8*M runs plus two empty bathymetry runs\\n\\n if run_id == N:\\n raise StopIteration()\\n\\n else:\\n \\n #=========================\\n # set coarse and fine grids\\n #\\n t_shelf = 0. # time approaching continental slope\\n t_harbor = 0. # time approaching harbor\\n\\n if ((run_id >= 0) and (run_id < 4*M)) or (run_id == 8*M):\\n #------------------\\n # setrun for coarse\\n #\\n grid = 'coarse'\\n \\n self._rundata.amrdata.amr_levels_max = 4\\n # coarse grid run = 10\\\"\\n # dx = 30', 5', 1', 10\\\"\\n self._rundata.amrdata.refinement_ratios_x = [6, 5, 6]\\n self._rundata.amrdata.refinement_ratios_y = [6, 5, 6]\\n self._rundata.amrdata.refinement_ratios_t = [6, 5, 6]\\n\\n\\n # add topography (coarse)\\n topofiles = self._rundata.topo_data.topofiles\\n # for topography, append lines of the form\\n # [topotype, minlevel, maxlevel, t1, t2, fname]\\n topofiles = []\\n\\n topofiles.append([3, 1, 4, 0., 1.e10, \\\\\\n os.path.join(etopo_dir, 'etopo1_-130_-124_38_45_1min.asc')])\\n topofiles.append([-3, 3, 4, 0., 1.e10, \\\\\\n os.path.join(topodir, 'cc-1sec.asc')])\\n\\n # add regions\\n regions = self._rundata.regiondata.regions \\n # between shelf and CC \\n regions = []\\n regions.append(\\\\\\n [2, 3, t_shelf, 1e9, -125, -124.05, 40.5, 43]) \\n regions.append(\\\\\\n [3, 4, t_harbor, 1e9, -124.26, -124.14, 41.67, 41.79])\\n regions.append(\\\\\\n [4, 4, t_harbor, 1e9, -124.218,-124.17, 41.7345, 41.77])\\n\\n # == fgmax.data values ==\\n fgmax_files = self._rundata.fgmax_data.fgmax_files\\n fgmax_files = []\\n \\n # for fixed grids append to this list names of any fgmax input files\\n fgmax1_fname = os.path.join(driver_home,'fgmax1_coarse.txt')\\n fgmax2_fname = os.path.join(driver_home,'fgmax2_coarse.txt')\\n fgmax3_fname = os.path.join(driver_home,'fgmax3_coarse.txt')\\n\\n fgmax_files.append(fgmax1_fname) \\n fgmax_files.append(fgmax2_fname) \\n fgmax_files.append(fgmax3_fname) \\n \\n self._rundata.fgmax_data.num_fgmax_val = 2\\n \\n \\n elif ((run_id >= 4*M) and (run_id < 8*M)) or (run_id == 8*M+1):\\n #----------------\\n # setrun for fine\\n #\\n grid = 'fine'\\n \\n self._rundata.amrdata.amr_levels_max = 6\\n\\n ## fine grid run = 2/3\\\"\\n ## dx = 30', 5', 1', 10\\\", 2\\\", 2/3\\\"\\n self._rundata.amrdata.refinement_ratios_x = [6, 5, 6, 5, 3]\\n self._rundata.amrdata.refinement_ratios_y = [6, 5, 6, 5, 3]\\n self._rundata.amrdata.refinement_ratios_t = [6, 5, 6, 5, 3]\\n\\n regions = self._rundata.regiondata.regions \\n regions = []\\n # between shelf and CC\\n regions.append(\\\\\\n [2, 4, t_shelf, 1e9, -125, -124.05, 40.5, 43]) \\n regions.append(\\\\\\n [4, 5, t_harbor, 1e9, -124.26, -124.14, 41.67, 41.79])\\n regions.append(\\\\\\n [6, 6, t_harbor, 1e9, -124.218,-124.17, 41.7345, 41.77])\\n\\n # add topography (fine)\\n topofiles = self._rundata.topo_data.topofiles\\n # for topography, append lines of the form\\n # [topotype, minlevel, maxlevel, t1, t2, fname]\\n topofiles = []\\n\\n topofiles.append([3, 1, 6, 0., 1.e10, \\\\\\n os.path.join(etopo_dir, 'etopo1_-130_-124_38_45_1min.asc')])\\n topofiles.append([-3, 4, 6, 0., 1.e10, \\\\\\n os.path.join(topodir, 'cc-1sec.asc')])\\n topofiles.append([3, 6, 6, 0., 1.e10, \\\\\\n os.path.join(topodir,'cc-1_3sec-c_pierless.asc')])\\n \\n # == fgmax.data values ==\\n fgmax_files = self._rundata.fgmax_data.fgmax_files\\n fgmax_files = []\\n \\n # for fixed grids append to this list names of any fgmax input files\\n fgmax1_fname = os.path.join(driver_home,'fgmax1_fine.txt')\\n fgmax2_fname = os.path.join(driver_home,'fgmax2_fine.txt')\\n fgmax3_fname = os.path.join(driver_home,'fgmax3_fine.txt')\\n\\n fgmax_files.append(fgmax1_fname) \\n fgmax_files.append(fgmax2_fname) \\n fgmax_files.append(fgmax3_fname) \\n \\n self._rundata.fgmax_data.num_fgmax_val = 2\\n \\n\\n\\n #\\n # set desired magnitude\\n #\\n if ((run_id >= 0) and (run_id < M)) \\\\\\n or ((run_id >= 4*M) and (run_id < 5*M)):\\n self.KL_Mw_desired = 8.6\\n elif ((run_id >= M) and (run_id < 2*M)) \\\\\\n or ((run_id >= 5*M) and (run_id < 6*M)):\\n self.KL_Mw_desired = 8.8\\n elif ((run_id >= 2*M) and (run_id < 3*M)) \\\\\\n or ((run_id >= 6*M) and (run_id < 7*M)):\\n self.KL_Mw_desired = 9.0\\n elif ((run_id >= 3*M) and (run_id < 4*M)) \\\\\\n or ((run_id >= 7*M) and (run_id < 8*M)):\\n self.KL_Mw_desired = 9.2\\n \\n #\\n # set slip distribution\\n #\\n run_id_mod = run_id - 100*(run_id/100)\\n m = scn_list[run_id_mod]\\n self.set_KL_slip(m)\\n \\n if run_id < 8*M:\\n dir_grid_Mw = '../geoclaw_output/' + str(grid) + '_' + str(self.KL_Mw_desired)\\n self._rundir = os.path.join(dir_grid_Mw, 'run_' + str(run_id_mod))\\n else:\\n # empty runs to obtain bathymetry\\n \\n dir_grid_Mw = '../geoclaw_output/' + str(grid) + '_B0'\\n self._rundir = dir_grid_Mw\\n self.KL_Mw_desired = 0.0\\n self.set_KL_slip([0.]*len(m)) # set output\\n self._rundata.clawdata.output_times = [1.0, 3.0]\\n \\n self._run_id += 1\\n \\n return self\",\n \"def __init__(self, mesh, bndry, interface, dt, theta, v_max, lambda_s, mu_s, rho_s, \\n mu_f, rho_f, result, *args, **kwargs):\\n\\n self.mesh = mesh\\n self.dt = Constant(dt)\\n self.theta = theta\\n self.t = 0.0\\n self.v_max = v_max\\n\\n self.mu_f = mu_f\\n self.rho_f = rho_f\\n self.lambda_s = lambda_s\\n self.mu_s = mu_s\\n self.rho_s = rho_s\\n \\n self.bndry = bndry\\n self.interface = interface\\n\\n # bounding box tree\\n self.bb = BoundingBoxTree()\\n self.bb.build(self.mesh)\\n\\n # Define finite elements\\n eV = VectorElement(\\\"CG\\\", mesh.ufl_cell(), 2)\\t\\t# velocity element\\n eB = VectorElement(\\\"Bubble\\\", mesh.ufl_cell(), mesh.geometry().dim()+1) # Bubble element\\n eU = VectorElement(\\\"CG\\\", mesh.ufl_cell(), 2)\\t\\t# displacement element\\n eP = FiniteElement(\\\"DG\\\", mesh.ufl_cell(), 1)\\t\\t# pressure element\\n\\n eW = MixedElement([eV, eB, eU, eB, eP]) # final mixed element\\n W = FunctionSpace(self.mesh, eW) # mixed space\\n self.W = W\\n self.V = FunctionSpace(self.mesh, eV)\\n\\n # Set boundary conditions\\n self.v_in = Expression((\\\"t<2.0? 0.5*(1.0 - cos(0.5*pi*t))*v_max*4/(gW*gW)*(x[1]*(gW - x[1])): \\\\\\n v_max*4/(gW*gW)*(x[1]*(gW - x[1]))\\\", \\\"0.0\\\"),\\n degree = 2, v_max = Constant(self.v_max), gW = Constant(gW), t = self.t)\\n\\n #info(\\\"Expression set.\\\")\\n bc_v_in = DirichletBC(self.W.sub(0), self.v_in, bndry, _INFLOW)\\n bc_v_walls = DirichletBC(self.W.sub(0), Constant((0.0, 0.0)), bndry, _WALLS)\\n bc_v_circle = DirichletBC(self.W.sub(0), Constant((0.0, 0.0)), bndry, _CIRCLE)\\n bc_u_in = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _INFLOW)\\n bc_u_circle = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _CIRCLE)\\n bc_u_walls = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _WALLS)\\n bc_u_out = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), bndry, _OUTFLOW)\\n self.bcs = [bc_v_in, bc_v_walls, bc_v_circle, bc_u_in, bc_u_walls, bc_u_circle, bc_u_out]\\n\\n #info(\\\"Mesh BC.\\\")\\n bc_mesh = DirichletBC(self.W.sub(2), Constant((0.0, 0.0)), interface, _FSI)\\n self.bcs_mesh = [bc_mesh]\\n\\n\\n #info(\\\"Normal and Circumradius.\\\")\\n self.n = FacetNormal(self.mesh)\\n self.h = Circumradius(self.mesh)\\n I = Identity(self.W.mesh().geometry().dim())\\n\\n # Define functions\\n self.w = Function(self.W) # solution to current time step\\n self.w0 = Function(self.W) # solution from previous time step\\n\\n (v__, bv_, u__, bu_, p_) = TestFunctions(self.W)\\n\\n # sum bubble elements with corresponding Lagrange elements\\n v_ = v__ + bv_\\n u_ = u__ + bu_\\n (v, bv, u, bu, self.p) = split(self.w)\\n self.v = v + bv\\n self.u = u + bu\\n (v0, bv0, u0, bu0, self.p0) = split(self.w0)\\n self.v0 = v0 + bv0\\n self.u0 = u0 + bu0\\n\\n\\n # define deformation gradient, Jacobian\\n self.FF = I + grad(self.u)\\n self.FF0 = I + grad(self.u0)\\n self.JJ = det(self.FF)\\n self.JJ0 = det(self.FF0)\\n\\n # write ALE mesh movement \\n self.gamma = 9.0/8.0\\n h = CellVolume(self.mesh)**(self.gamma)\\n E = Constant(1.0)\\n\\n E_mesh = E/h\\n nu_mesh = Constant(-0.02)\\n\\n mu_mesh = E_mesh/(2*(1.0+nu_mesh))\\n lambda_mesh = (nu_mesh*E_mesh)/((1+nu_mesh)*(1-2*nu_mesh))\\n\\n F_mesh = inner(mu_mesh*2*sym(grad(self.u)), grad(u_))*dx(0) \\\\\\n + lambda_mesh*inner(div(self.u), div(u_))*dx(0)\\n\\n\\n # define referential Grad and Div shortcuts\\n def Grad(f, F): return dot( grad(f), inv(F) )\\n def Div(f, F): return tr( Grad(f, F) )\\n\\n # approximate time derivatives\\n du = (1.0/self.dt)*(self.u - self.u0)\\n dv = (1.0/self.dt)*(self.v - self.v0)\\n\\n # compute velocuty part of Cauchy stress tensor for fluid\\n self.T_f = -self.p*I + 2*self.mu_f*sym(Grad(self.v, self.FF))\\n self.T_f0 = -self.p*I + 2*self.mu_f*sym(Grad(self.v0, self.FF0))\\n\\n # Compute 1st Piola-Kirhhoff tensro for fluid \\n # - for computing surface integrals for forces in postprocessing \\n self.S_f = self.JJ *self.T_f*inv(self.FF).T\\n \\n # write equations for fluid\\n a_fluid = inner(self.T_f , Grad(v_, self.FF))*self.JJ*dx(0) \\\\\\n - inner(self.p, Div(v_, self.FF))*self.JJ*dx(0) \\\\\\n + inner(self.rho_f*Grad(self.v, self.FF )*(self.v - du), v_)*self.JJ*dx(0)\\n a_fluid0 = inner(self.T_f0, Grad(v_, self.FF0))*self.JJ0*dx(0) \\\\\\n - inner(self.p, Div(v_, self.FF))*self.JJ*dx(0) \\\\\\n + inner(self.rho_f*Grad(self.v0, self.FF0)*(self.v0 - du), v_)*self.JJ0*dx(0)\\n\\n b_fluid = inner(Div( self.v, self.FF ), p_)*self.JJ*dx(0)\\n b_fluid0 = inner(Div( self.v, self.FF ), p_)*self.JJ*dx(0)\\n\\n self.F_fluid = (self.theta*self.JJ+(1.0 - self.theta)*self.JJ0)*self.rho_f*inner(dv, v_)*dx(0)\\\\\\n + self.theta*(a_fluid + b_fluid) + (1.0 - self.theta)*(a_fluid0 + b_fluid0) \\\\\\n + F_mesh\\n\\n # compute 1st Piola-Kirchhoff tensor for solid (St. Vennant - Kirchhoff model)\\n B_s = self.FF.T *self.FF\\n B_s0 = self.FF0.T*self.FF0\\n S_s = self.FF *(0.5*self.lambda_s*tr(B_s - I)*I + self.mu_s*(B_s - I))\\n S_s0 = self.FF0*(0.5*self.lambda_s*tr(B_s0 - I)*I + self.mu_s*(B_s0 - I))\\n\\n # write equation for solid\\n alpha = Constant(1.0) # Constant(1e10) #\\n self.F_solid = rho_s*inner(dv, v_)*dx(1) \\\\\\n + self.theta*inner(S_s , grad(v_))*dx(1) + (1.0 - self.theta)*inner(S_s0, grad(v_))*dx(1) \\\\\\n + alpha*inner(du - (self.theta*self.v + (1.0 - self.theta)*self.v0), u_)*dx(1)\\n\\n\\n dF_solid = derivative(self.F_solid, self.w)\\n dF_fluid = derivative(self.F_fluid, self.w)\\n\\n self.problem = Problem(self.F_fluid, self.F_solid, dF_fluid, dF_solid, self.bcs_mesh, self.bcs)\\n self.solver = NewtonSolver()\\n\\n # configure solver parameters\\n self.solver.parameters['relative_tolerance'] = 1e-6\\n self.solver.parameters['maximum_iterations'] = 15\\n self.solver.parameters['linear_solver'] = 'mumps'\\n\\n # create files for saving\\n if my_rank == 0:\\n if not os.path.exists(result):\\n os.makedirs(result)\\n self.vfile = XDMFFile(\\\"%s/velocity.xdmf\\\" % result)\\n self.ufile = XDMFFile(\\\"%s/displacement.xdmf\\\" % result)\\n self.pfile = XDMFFile(\\\"%s/pressure.xdmf\\\" % result)\\n self.sfile = XDMFFile(\\\"%s/stress.xdmf\\\" % result)\\n self.vfile.parameters[\\\"flush_output\\\"] = True\\n self.ufile.parameters[\\\"flush_output\\\"] = True\\n self.pfile.parameters[\\\"flush_output\\\"] = True\\n self.sfile.parameters[\\\"flush_output\\\"] = True\\n with open(result+'/data.csv', 'w') as data_file:\\n writer = csv.writer(data_file, delimiter=';', lineterminator='\\\\n')\\n writer.writerow(['time', 'mean pressure on outflow', 'pressure_jump', \\n 'x-coordinate of end of beam', 'y-coordinate of end of beam',\\n 'pressure difference', \\n 'drag_circle', 'drag_fluid', 'drag_solid', 'drag_fullfluid',\\n 'lift_circle', 'lift_fluid', 'lift_solid', 'lift_fullfluid'])\",\n \"def get_proj(self):\\n relev, razim = np.pi * self.elev/180, np.pi * self.azim/180\\n\\n xmin, xmax = self.get_xlim3d()/self.pbaspect[0]\\n ymin, ymax = self.get_ylim3d()/self.pbaspect[1]\\n zmin, zmax = self.get_zlim3d()/self.pbaspect[2]\\n\\n # transform to uniform world coordinates 0-1.0,0-1.0,0-1.0 \\n worldM = proj3d.world_transformation(xmin, xmax,\\n ymin, ymax,\\n zmin, zmax)\\n\\n # look into the middle of the new coordinates \\n R = np.array([0.5, 0.5, 0.5])\\n\\n xp = R[0] + np.cos(razim) * np.cos(relev) * self.dist\\n yp = R[1] + np.sin(razim) * np.cos(relev) * self.dist\\n zp = R[2] + np.sin(relev) * self.dist\\n E = np.array((xp, yp, zp))\\n\\n self.eye = E\\n self.vvec = R - E\\n self.vvec = self.vvec / proj3d.mod(self.vvec)\\n\\n if abs(relev) > np.pi/2:\\n # upside down \\n V = np.array((0, 0, -1))\\n else:\\n V = np.array((0, 0, 1))\\n\\n zfront, zback = -self.dist, self.dist\\n\\n viewM = proj3d.view_transformation(E, R, V)\\n perspM = proj3d.persp_transformation(zfront, zback)\\n M0 = np.dot(viewM, worldM)\\n M = np.dot(perspM, M0)\\n return M\",\n \"def elaboratedCurve(radius = 10, resolution = 22, robotHeight = -90,distx = 10,disty = 10, lines = 20):\\n \\n if resolution%4 != 0:\\n while resolution%4 != 0:\\n resolution += 1\\n \\n t = np.linspace(0, m.pi/2, int(resolution/4))\\n elaboratedCurvePos = []\\n for num in t:\\n x = m.cos(num)*radius - distx\\n y = -m.sin(num)*radius + disty\\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\\n\\n t = np.linspace(0, 2*m.pi, resolution)\\n for num in t:\\n x = -m.sin(num)*radius - distx\\n y = m.cos(num)*radius - disty\\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\\n\\n t = np.linspace(0, 3*m.pi/2, int(3*resolution/4))\\n for num in t:\\n x = -m.sin(num)*radius - distx\\n y = -m.cos(num)*radius + disty\\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\\n\\n \\n elaboratedCurvePos.append([lines, disty, robotHeight, 0, 0, 0, 'lin'])\\n\\n z = np.linspace(0, m.pi, int(resolution/2))\\n for num in z:\\n x = m.sin(num)*radius + lines\\n y = m.cos(num)*radius\\n elaboratedCurvePos.append([x, y, robotHeight, 0, 0, 0, 'mov'])\\n\\n elaboratedCurvePos.append([0, -disty, robotHeight, 0, 0, 0, 'lin'])\\n time.sleep(2) #TODO: Sleep wegmachen\\n\\n elaboratedCurvePos.append([0,0,-127,0,0,0,'mov'])\\n #return elaboratedCurvePos\\n return elaboratedCurvePos\",\n \"def doParametersOfInterest(self):\\n self.modelBuilder.doVar(\\\"mu[1,0,100]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu\\\")\\n self.modelBuilder.factory_('expr::ggH_s_func(\\\"@0-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::ggH_b_func(\\\"1-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\\\"sqrt(@0)\\\", mu)')\",\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 pv2ssh(lon, lat, q, hg, c, nitr=1, name_grd=''):\\n def compute_avec(vec,aaa,bbb,grd):\\n\\n avec=np.empty(grd.np0,)\\n avec[grd.vp2] = aaa[grd.vp2]*((vec[grd.vp2e]+vec[grd.vp2w]-2*vec[grd.vp2])/(grd.dx1d[grd.vp2]**2)+(vec[grd.vp2n]+vec[grd.vp2s]-2*vec[grd.vp2])/(grd.dy1d[grd.vp2]**2)) + bbb[grd.vp2]*vec[grd.vp2]\\n avec[grd.vp1] = vec[grd.vp1]\\n\\n return avec,\\n if name_grd is not None:\\n if os.path.isfile(name_grd):\\n with open(name_grd, 'rb') as f:\\n grd = pickle.load(f)\\n else:\\n grd = Grid(lon,lat)\\n with open(name_grd, 'wb') as f:\\n pickle.dump(grd, f)\\n f.close()\\n else:\\n grd = Grid(lon,lat)\\n\\n ny,nx,=np.shape(hg)\\n g=grd.g\\n\\n\\n x=hg[grd.indi,grd.indj]\\n q1d=q[grd.indi,grd.indj]\\n\\n aaa=g/grd.f01d\\n bbb=-g*grd.f01d/c**2\\n ccc=+q1d\\n\\n aaa[grd.vp1]=0\\n bbb[grd.vp1]=1\\n ccc[grd.vp1]=x[grd.vp1] ##boundary condition\\n\\n vec=+x\\n\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n p=-gg\\n\\n for itr in range(nitr-1):\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n tmp=np.dot(p,avec)\\n\\n if tmp!=0. : s=-np.dot(p,gg)/tmp\\n else: s=1.\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n vec=+x\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n gg=avec-ccc\\n a2=np.dot(gg,gg)\\n\\n if a1!=0: beta=a2/a1\\n else: beta=1.\\n\\n p=-gg+beta*p\\n\\n vec=+p\\n avec,=compute_avec(vec,aaa,bbb,grd)\\n val1=-np.dot(p,gg)\\n val2=np.dot(p,avec)\\n if (val2==0.):\\n s=1.\\n else:\\n s=val1/val2\\n\\n a1=np.dot(gg,gg)\\n x=x+s*p\\n\\n # back to 2D\\n h=np.empty((ny,nx))\\n h[:,:]=np.NAN\\n h[grd.indi,grd.indj]=x[:]\\n\\n\\n return h\",\n \"def potential_energy_per_mode(proj_displ,eigvals): #,hess=None,check=False): \\n return 0.5 * ( np.square(proj_displ).T * eigvals ).T #, 0.5 * proj_displ * omega_sqr @ proj_displ\",\n \"def eui_modesign():\\n\\n # setup design space\\n # N ds ws wc lc g\\n GAP = Struct()\\n GAP.gd_min = np.array([1, 1e-3, 1e-3, 1e-3, 1e-3, 1e-5])\\n GAP.gd_max = np.array([1e3, 1e-1, 1e-1, 1e-1, 1e-1, 1e-2])\\n\\n\\n # setup genetic algorithm parameters--------------------------------------\\n nobj=2 # number of objectives\\n ngen=100 # number of generations\\n npop = 100 # population size\\n \\n problem = MyProblem()\\n problem.n_var = len(GAP.gd_min)\\n problem.n_obj = nobj\\n problem.n_constr = 2\\n problem.xl = GAP.gd_min\\n problem.xu = GAP.gd_max\\n problem.elementwise_evaluation = True\\n\\n algorithm = NSGA2(\\n pop_size=npop,\\n eliminate_duplicates=True\\n )\\n \\n # conduct the optimization-------------------------------------------------\\n res = minimize(problem, algorithm, (\\\"n_gen\\\", ngen), verbose=True)\\n\\n # save results-------------------------------------------------------------\\n return res\",\n \"def gpt2_1w (station, dmjd,dlat,dlon,hell,it):\\n\\n# need to find diffpod and difflon\\n if (dlon < 0):\\n plon = (dlon + 2*np.pi)*180/np.pi;\\n else:\\n plon = dlon*180/np.pi;\\n# transform to polar distance in degrees\\n ppod = (-dlat + np.pi/2)*180/np.pi; \\n\\n# % find the index (line in the grid file) of the nearest point\\n# \\t % changed for the 1 degree grid (GP)\\n ipod = np.floor(ppod+1); \\n ilon = np.floor(plon+1);\\n \\n# normalized (to one) differences, can be positive or negative\\n#\\t% changed for the 1 degree grid (GP)\\n diffpod = (ppod - (ipod - 0.5));\\n difflon = (plon - (ilon - 0.5));\\n\\n\\n# change the reference epoch to January 1 2000\\n print('Modified Julian Day', dmjd)\\n dmjd1 = dmjd-51544.5 \\n\\n pi2 = 2*np.pi\\n pi4 = 4*np.pi\\n\\n# mean gravity in m/s**2\\n gm = 9.80665;\\n# molar mass of dry air in kg/mol\\n dMtr = 28.965E-3 \\n# dMtr = 28.965*10^-3 \\n# universal gas constant in J/K/mol\\n Rg = 8.3143 \\n\\n# factors for amplitudes, i.e. whether you want time varying\\n if (it==1):\\n print('>>>> no refraction time variation ')\\n cosfy = 0; coshy = 0; sinfy = 0; sinhy = 0;\\n else: \\n cosfy = np.cos(pi2*dmjd1/365.25)\\n coshy = np.cos(pi4*dmjd1/365.25) \\n sinfy = np.sin(pi2*dmjd1/365.25) \\n sinhy = np.sin(pi4*dmjd1/365.25) \\n cossin = np.matrix([1, cosfy, sinfy, coshy, sinhy])\\n# initialization of new vectors\\n p = 0; T = 0; dT = 0; Tm = 0; e = 0; ah = 0; aw = 0; la = 0; undu = 0;\\n undul = np.zeros(4)\\n Ql = np.zeros(4)\\n dTl = np.zeros(4)\\n Tl = np.zeros(4)\\n pl = np.zeros(4)\\n ahl = np.zeros(4)\\n awl = np.zeros(4)\\n lal = np.zeros(4)\\n Tml = np.zeros(4)\\n el = np.zeros(4)\\n#\\n pgrid, Tgrid, Qgrid, dTgrid, u, Hs, ahgrid, awgrid, lagrid, Tmgrid = read_4by5(station,dlat,dlon,hell)\\n#\\n for l in [0,1,2,3]:\\n KL = l #silly to have this as a variable like this \\n# transforming ellipsoidal height to orthometric height:\\n# Hortho = -N + Hell\\n undul[l] = u[KL] \\n hgt = hell-undul[l] \\n# pressure, temperature at the height of the grid\\n T0 = Tgrid[KL,0] + Tgrid[KL,1]*cosfy + Tgrid[KL,2]*sinfy + Tgrid[KL,3]*coshy + Tgrid[KL,4]*sinhy;\\n tg = float(Tgrid[KL,:] *cossin.T)\\n# print(T0,tg)\\n\\n p0 = pgrid[KL,0] + pgrid[KL,1]*cosfy + pgrid[KL,2]*sinfy + pgrid[KL,3]*coshy + pgrid[KL,4]*sinhy;\\n \\n# humidity \\n Ql[l] = Qgrid[KL,0] + Qgrid[KL,1]*cosfy + Qgrid[KL,2]*sinfy + Qgrid[KL,3]*coshy + Qgrid[KL,4]*sinhy;\\n \\n# reduction = stationheight - gridheight\\n Hs1 = Hs[KL]\\n redh = hgt - Hs1;\\n\\n# lapse rate of the temperature in degree / m\\n dTl[l] = dTgrid[KL,0] + dTgrid[KL,1]*cosfy + dTgrid[KL,2]*sinfy + dTgrid[KL,3]*coshy + dTgrid[KL,4]*sinhy;\\n \\n# temperature reduction to station height\\n Tl[l] = T0 + dTl[l]*redh - 273.15;\\n\\n# virtual temperature\\n Tv = T0*(1+0.6077*Ql[l]) \\n c = gm*dMtr/(Rg*Tv) \\n \\n# pressure in hPa\\n pl[l] = (p0*np.exp(-c*redh))/100 \\n \\n# hydrostatic coefficient ah\\n ahl[l] = ahgrid[KL,0] + ahgrid[KL,1]*cosfy + ahgrid[KL,2]*sinfy + ahgrid[KL,3]*coshy + ahgrid[KL,4]*sinhy;\\n \\n# wet coefficient aw\\n awl[l] = awgrid[KL,0] + awgrid[KL,1]*cosfy + awgrid[KL,2]*sinfy + awgrid[KL,3]*coshy + awgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# water vapor decrease factor la - added by GP\\n lal[l] = lagrid[KL,0] + lagrid[KL,1]*cosfy + lagrid[KL,2]*sinfy + lagrid[KL,3]*coshy + lagrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# mean temperature of the water vapor Tm - added by GP\\n Tml[l] = Tmgrid[KL,0] + Tmgrid[KL,1]*cosfy + Tmgrid[KL,2]*sinfy + Tmgrid[KL,3]*coshy + Tmgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\t\\t \\n# water vapor pressure in hPa - changed by GP\\n e0 = Ql[l]*p0/(0.622+0.378*Ql[l])/100; # % on the grid\\n aa = (100*pl[l]/p0)\\n bb = lal[l]+1\\n el[l] = e0*np.power(aa,bb) # % on the station height - (14) Askne and Nordius, 1987\\n \\n dnpod1 = np.abs(diffpod); # % distance nearer point\\n dnpod2 = 1 - dnpod1; # % distance to distant point\\n dnlon1 = np.abs(difflon);\\n dnlon2 = 1 - dnlon1;\\n \\n# pressure\\n R1 = dnpod2*pl[0]+dnpod1*pl[1];\\n R2 = dnpod2*pl[2]+dnpod1*pl[3];\\n p = dnlon2*R1+dnlon1*R2;\\n \\n# temperature\\n R1 = dnpod2*Tl[0]+dnpod1*Tl[1];\\n R2 = dnpod2*Tl[2]+dnpod1*Tl[3];\\n T = dnlon2*R1+dnlon1*R2;\\n \\n# temperature in degree per km\\n R1 = dnpod2*dTl[0]+dnpod1*dTl[1];\\n R2 = dnpod2*dTl[2]+dnpod1*dTl[3];\\n dT = (dnlon2*R1+dnlon1*R2)*1000;\\n \\n# water vapor pressure in hPa - changed by GP\\n R1 = dnpod2*el[0]+dnpod1*el[1];\\n R2 = dnpod2*el[2]+dnpod1*el[3];\\n e = dnlon2*R1+dnlon1*R2;\\n \\n# hydrostatic\\n R1 = dnpod2*ahl[0]+dnpod1*ahl[1];\\n R2 = dnpod2*ahl[2]+dnpod1*ahl[3];\\n ah = dnlon2*R1+dnlon1*R2;\\n \\n# wet\\n R1 = dnpod2*awl[0]+dnpod1*awl[1];\\n R2 = dnpod2*awl[2]+dnpod1*awl[3];\\n aw = dnlon2*R1+dnlon1*R2;\\n \\n# undulation\\n R1 = dnpod2*undul[0]+dnpod1*undul[1];\\n R2 = dnpod2*undul[2]+dnpod1*undul[3];\\n undu = dnlon2*R1+dnlon1*R2;\\n\\n# water vapor decrease factor la - added by GP\\n R1 = dnpod2*lal[0]+dnpod1*lal[1];\\n R2 = dnpod2*lal[2]+dnpod1*lal[3];\\n la = dnlon2*R1+dnlon1*R2;\\n\\t\\t\\n# mean temperature of the water vapor Tm - added by GP\\n R1 = dnpod2*Tml[0]+dnpod1*Tml[1];\\n R2 = dnpod2*Tml[2]+dnpod1*Tml[3];\\n Tm = dnlon2*R1+dnlon1*R2; \\n\\n return p, T, dT,Tm,e,ah,aw,la,undu\",\n \"def test_born_newton(self):\\n\\n n0 = 3.4\\n omega = 2*np.pi*200e12\\n dl = 0.01\\n chi3 = 2.8E-18\\n\\n width = 1\\n L = 5\\n L_chi3 = 4\\n\\n width_voxels = int(width/dl)\\n L_chi3_voxels = int(L_chi3/dl)\\n\\n Nx = int(L/dl)\\n Ny = int(3.5*width/dl)\\n\\n eps_r = np.ones((Nx, Ny))\\n eps_r[:, int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = np.square(n0)\\n\\n nl_region = np.zeros(eps_r.shape)\\n nl_region[int(Nx/2-L_chi3_voxels/2):int(Nx/2+L_chi3_voxels/2), int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = 1\\n\\n simulation = Simulation(omega, eps_r, dl, [15, 15], 'Ez')\\n simulation.add_mode(n0, 'x', [17, int(Ny/2)], width_voxels*3)\\n simulation.setup_modes()\\n simulation.add_nl(chi3, nl_region, eps_scale=True, eps_max=np.max(eps_r))\\n\\n srcval_vec = np.logspace(1, 3, 3)\\n pwr_vec = np.array([])\\n T_vec = np.array([])\\n for srcval in srcval_vec:\\n simulation.setup_modes()\\n simulation.src *= srcval\\n\\n # Newton\\n simulation.solve_fields_nl(solver_nl='newton')\\n E_newton = simulation.fields[\\\"Ez\\\"]\\n\\n # Born\\n simulation.solve_fields_nl(solver_nl='born')\\n E_born = simulation.fields[\\\"Ez\\\"]\\n\\n # More solvers (if any) should be added here with corresponding calls to assert_allclose() below\\n\\n assert_allclose(E_newton, E_born, rtol=1e-3)\",\n \"def doParametersOfInterest(self):\\n self.modelBuilder.doVar(\\\"mu[0,0,1000]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu\\\")\\n self.modelBuilder.factory_('expr::vbfH_s_func(\\\"@0-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\\\"1-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\\\"sqrt(@0)\\\", mu)')\",\n \"def spatial(self):\",\n \"def construct_param_dict(params,K_RC,K_CP,m_P):\\n ###scaling constants\\n w=params['w']\\n pd=params['pd'] # in 3D and 0.21 in 2D\\n pv=params['pv']\\n Er=params['Er'] ;Ek=params['Ek']\\n ER=params['ER'];EC=params['EC'];EP=params['EP'];\\n Eq1=params['Eq1'];Eq2=params['Eq2']\\n\\n\\n #capture success function\\n a = params['a']\\n b = params['b']\\n c = params['c']\\n formC = params['formC']\\n formPC = params['formPC']\\n formPR = params['formPR']\\n \\n ###variables\\n TR= params['TR'] ;TC= params['TC'];TP=params['TP'];D_R= params['D_R']; D_C= params['D_C']\\n K_RP=K_RC*K_CP\\n fmC=params['fmC'];thermyR=params['thermyR']\\n thermyC=params['thermyC'];thermyP=params['thermyP']\\n fmPR=params['fmPR']\\n fmPC=params['fmPC']\\n m_C = K_CP*m_P;m_R = K_RP*m_P\\n ###normalization constants and boltzmann constant\\n r0 = params['r0']\\n k0 = params['k0'] # will depend on the productivity of the habitat\\n a01 = a02 = params['a012'] # will depedend on the dimension of the habitat \\n a03 = params['a03']\\n d0= params['d0']\\n q10 = params['q10'];q20 = params['q20'];\\n v0R = params['v0R'];v0C =params['v0C'];v0P =params['v0P'];k = b_k\\n hC0 = params['hC0'];hP0 = params['hP0'] \\n \\n #intrapopulation parameters\\n q1=set_q1(q10,m_C,w,Eq1,TR,k)\\n q2=set_q2(q20,m_P,w,Eq2,TC,k)\\n K=set_K(k0,m_R,w,Ek,TR,k)\\n r=set_r(r0,m_R,w,Er,TR,k)\\n\\n #interpopulation parameters\\n a1=set_alfa(m_C,a01,K_RC,pv,pd,TR,TC,ER,EC,D_R,v0R,v0C,g,alfa,fmC,thermyR,thermyC,k,a,b,c,formC)\\n a2=set_alfa(m_P,a02,K_RP,pv,pd,TR,TP,ER,EP,D_R,v0R,v0P,g,alfa,fmPR,thermyR,thermyP,k,a,b,c,formPR)\\n a3=set_alfa(m_P,a03,K_CP,pv,pd,TC,TP,EC,EP,D_C,v0C,v0P,g,alfa,fmPC,thermyC,thermyP,k,a,b,c,formPC)\\n\\n t_hp = set_th(hP0,m_P,w,EP,k,TP)\\n t_hc = set_th(hC0,m_C,w,EC,k,TC)\\n param_dict={'q1':q1,'q2':q2,'K':K,'r':r,'a1':a1,'a2':a2,'a3':a3,'t_hp':t_hp,'t_hc':t_hc}\\n \\n return param_dict\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"Rdy[1.,0.0,10.0]\\\");\\n self.modelBuilder.doVar(\\\"Rqcd[1,0.0,10.0]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"Rdy,Rqcd\\\")\",\n \"def _init_parameters(self,diameterInd):\\n\\n\\t\\t# topological parameters\\n\\t\\tself.nNodes = 21\\n\\t\\tself._axonNodes=self.nNodes\\n\\t\\tself._paraNodes1=40\\n\\t\\tself._paraNodes2=40\\n\\t\\tself._axonInter=120\\n\\t\\tself._axonTotal=221\\n\\t\\t# morphological parameters\\n\\t\\tpossibleDiameters = [5.7, 7.3, 8.7, 10.0, 11.5, 12.8, 14.0, 15.0, 16.0]\\n\\t\\tself._fiberD=possibleDiameters[diameterInd]\\n\\t\\tself._paraLength1=3 \\n\\t\\tself._nodeLength=1.0\\n\\t\\tself._spaceP1=0.002 \\n\\t\\tself._spaceP2=0.004\\n\\t\\tself._spaceI=0.004\\n\\t\\t# electrical parameters\\n\\t\\tself._rhoa=0.7e6 #Ohm-um\\n\\t\\tself._mycm=0.1 #uF/cm2/lamella membrane\\n\\t\\tself._mygm=0.001 #S/cm2/lamella membrane\\n\\n\\t\\tif self._fiberD==5.7:\\n\\t\\t\\tself._g=0.605 \\n\\t\\t\\tself._axonD=3.4\\n\\t\\t\\tself._nodeD=1.9\\n\\t\\t\\tself._paraD1=1.9\\n\\t\\t\\tself._paraD2=3.4\\n\\t\\t\\tself._deltax=500\\n\\t\\t\\tself._paraLength2=35\\n\\t\\t\\tself._nl=80\\n\\t\\tif self._fiberD==8.7:\\n\\t\\t\\tself._g=0.661\\n\\t\\t\\tself._axonD=5.8\\n\\t\\t\\tself._nodeD=2.8\\n\\t\\t\\tself._paraD1=2.8\\n\\t\\t\\tself._paraD2=5.8\\n\\t\\t\\tself._deltax=1000\\n\\t\\t\\tself._paraLength2=40\\n\\t\\t\\tself._nl=110\\n\\t\\tif self._fiberD==10.0:\\n\\t\\t\\tself._g=0.690\\n\\t\\t\\tself._axonD=6.9\\n\\t\\t\\tself._nodeD=3.3\\n\\t\\t\\tself._paraD1=3.3\\n\\t\\t\\tself._paraD2=6.9\\n\\t\\t\\tself._deltax=1150\\n\\t\\t\\tself._paraLength2=46\\n\\t\\t\\tself._nl=120\\n\\t\\tif self._fiberD==11.5:\\n\\t\\t\\tself._g=0.700\\n\\t\\t\\tself._axonD=8.1\\n\\t\\t\\tself._nodeD=3.7\\n\\t\\t\\tself._paraD1=3.7\\n\\t\\t\\tself._paraD2=8.1\\n\\t\\t\\tself._deltax=1250\\n\\t\\t\\tself._paraLength2=50\\n\\t\\t\\tself._nl=130\\n\\t\\tif self._fiberD==12.8:\\n\\t\\t\\tself._g=0.719\\n\\t\\t\\tself._axonD=9.2\\n\\t\\t\\tself._nodeD=4.2\\n\\t\\t\\tself._paraD1=4.2\\n\\t\\t\\tself._paraD2=9.2\\n\\t\\t\\tself._deltax=1350\\n\\t\\t\\tself._paraLength2=54\\n\\t\\t\\tself._nl=135\\n\\t\\tif self._fiberD==14.0:\\n\\t\\t\\tself._g=0.739\\n\\t\\t\\tself._axonD=10.4\\n\\t\\t\\tself._nodeD=4.7\\n\\t\\t\\tself._paraD1=4.7\\n\\t\\t\\tself._paraD2=10.4\\n\\t\\t\\tself._deltax=1400\\n\\t\\t\\tself._paraLength2=56\\n\\t\\t\\tself._nl=140\\n\\t\\tif self._fiberD==15.0:\\n\\t\\t\\tself._g=0.767\\n\\t\\t\\tself._axonD=11.5\\n\\t\\t\\tself._nodeD=5.0\\n\\t\\t\\tself._paraD1=5.0\\n\\t\\t\\tself._paraD2=11.5\\n\\t\\t\\tself._deltax=1450\\n\\t\\t\\tself._paraLength2=58\\n\\t\\t\\tself._nl=145\\n\\t\\tif self._fiberD==16.0:\\n\\t\\t\\tself._g=0.791\\n\\t\\t\\tself._axonD=12.7\\n\\t\\t\\tself._nodeD=5.5\\n\\t\\t\\tself._paraD1=5.5\\n\\t\\t\\tself._paraD2=12.7\\n\\t\\t\\tself._deltax=1500\\n\\t\\t\\tself._paraLength2=60\\n\\t\\t\\tself._nl=150\\n\\n\\t\\tself._Rpn0=(self._rhoa*.01)/(np.pi*((((self._nodeD/2)+self._spaceP1)**2)-((self._nodeD/2)**2)))\\n\\t\\tself._Rpn1=(self._rhoa*.01)/(np.pi*((((self._paraD1/2)+self._spaceP1)**2)-((self._paraD1/2)**2)))\\n\\t\\tself._Rpn2=(self._rhoa*.01)/(np.pi*((((self._paraD2/2)+self._spaceP2)**2)-((self._paraD2/2)**2)))\\n\\t\\tself._Rpx=(self._rhoa*.01)/(np.pi*((((self._axonD/2)+self._spaceI)**2)-((self._axonD/2)**2)))\\n\\t\\tself._interLength=(self._deltax-self._nodeLength-(2*self._paraLength1)-(2*self._paraLength2))/6\",\n \"def objective(rp,n=5000,C=-2*10**11,a=300,b=1):\\n l = log(rp)/n\\n r = exp(l)\\n rm1 = r-1\\n return (rp-1)*((a-b*n)*rm1 + 1) - C*(rm1)*(rm1)\\n #return rm1\",\n \"def simulateUpTo2016FullPop3params(params, extraParams):\\n beta, betaW, mu = params\\n\\n aseason, delta, gamma, gammaA, gammaE, k, m, nInfected, pseason, Pop, red_beta, red_mu, rlen, rep, \\\\\\n sigma, tau, tspan_length, V, vrate, waterMat, wRate = extraParams\\n\\n beta_A = red_beta*beta\\n mu_A = red_mu*mu\\n\\n repMat = [rep]*10\\n\\n numDep = 10\\n\\n travelMat = formTravelMat1(numDep, rlen, tau, vrate, Pop)\\n #set initial conditions:\\n S0 = np.copy(Pop) - nInfected\\n E0 = np.zeros(np.size(Pop))\\n I0 = map(lambda x: x / reporting_rate, nInfected)#nInfected/rep # np.zeros(np.size(Pop))\\n A0 = np.zeros(np.size(Pop))\\n R0 = np.zeros(np.size(Pop))\\n RA0 = np.zeros(np.size(Pop))\\n W0 = np.zeros(np.size(Pop)) # 15*Pop*365\\n C0 = I0\\n\\n\\n\\n initCond = np.array([S0, E0, I0, A0, R0, RA0, W0, C0]).reshape((8 * numDep))\\n # print initCond\\n tspan = range(tspan_length)\\n\\n paramsODE = [aseason, beta, beta_A, betaW, delta, gamma, gammaA, gammaE, k, m, mu, mu_A, numDep, \\\\\\n pseason, sigma, travelMat, V, wRate, waterMat]\\n\\n\\n sol, info = odeint(choleraEqs10WithoutVaccinationNetwork, initCond, tspan,\\n args=(paramsODE,), full_output=True)\\n\\n\\n if info['message'] == 'Integration successful.':\\n temp = sol[:, 70:]\\n newcases = np.zeros((np.size(sol[:, 0]), 10))\\n\\n newcases[0, :] = sol[0, 70:80]\\n\\n for jvals in range(10):\\n for t in range(1, len(tspan)):\\n newcases[t, jvals] = (np.sum(temp[t, jvals]) - np.sum(temp[t - 1, jvals]))\\n\\n # newcases[:, jvals] = repMat[jvals] * newcases[:, jvals]\\n\\n\\n # print np.shape(newcases)\\n return [sol, newcases]\\n else:\\n # print 'hola'\\n return [0, np.ones((tspan_length, 10))*10**8]\",\n \"def run(self, event, Collection):\\n ret = {}\\n inputVars = []\\n score_ = -99 \\n cat_ = -99 \\n\\n \\\"\\\"\\\" Get lepton and jet objects \\\"\\\"\\\"\\n # Get the list of leptons\\n all_leps = [j for j in Collection(event,\\\"LepGood\\\")]\\n nFO = getattr(event,\\\"nLepFO_Recl\\\")\\n chosen = getattr(event,\\\"iLepFO_Recl\\\")\\n \\n # These are the objects we have to use\\n leps = [all_leps[chosen[i]] for i in range(nFO)]\\n alljets = [j for j in Collection(event,\\\"JetSel_Recl\\\")]\\n year = event.year\\n\\n\\n \\\"\\\"\\\" A partir de aqui hay que modificar en funcion del modelo !!!!\\\"\\\"\\\"\\n bjets = []\\n nonbjets = []\\n for jet in alljets:\\n wp = jet.btagDeepFlavB\\n is_btagged = (((wp >= 0.3093) and (year == 2016)) or \\n ((wp >= 0.3033) and (year == 2017)) or \\n ((wp >= 0.2770) and (year == 2018)))\\n if is_btagged:\\n bjets.append(jet)\\n else:\\n nonbjets.append(jet)\\n\\n\\n htjet25 = event.htJet25j_Recl\\n jet3_pt = nonbjets[2].pt\\n jet2_pt = nonbjets[1].pt\\n jet2_mass = nonbjets[2].mass\\n nJet25_Recl = event.nJet25_Recl\\n jet4_pt = nonbjets[3].pt\\n combipt = leps[0].pt + leps[1].pt\\n lep1_charge = np.sign(leps[0].pdgId)\\n lep2_mass = leps[1].mass\\n mlj12 = self.moo(\\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\\n (nonbjets[1].pt, nonbjets[1].eta, nonbjets[1].eta, nonbjets[1].mass)\\n )\\n lep2_elec = (np.abs(leps[1].pdgId) == 11)\\n lep2_pt = leps[1].pt\\n Flav_muon = (np.abs(leps[0].pdgId) == np.abs(leps[1].pdgId)) and (np.abs(leps[0].pdgId) == 13)\\n B2_pt = -99\\n mlj11 = self.moo(\\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\\n (nonbjets[0].pt, nonbjets[0].eta, nonbjets[0].eta, nonbjets[0].mass)\\n )\\n mlj21 = self.moo(\\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass),\\n (nonbjets[0].pt, nonbjets[0].eta, nonbjets[0].eta, nonbjets[0].mass)\\n )\\n mlj22 = self.moo(\\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass),\\n (nonbjets[1].pt, nonbjets[1].eta, nonbjets[1].eta, nonbjets[1].mass)\\n )\\n mll = self.moo(\\n (leps[0].pt, leps[0].eta, leps[0].eta, leps[0].mass),\\n (leps[1].pt, leps[1].eta, leps[1].eta, leps[1].mass)\\n )\\n Flav_elec = (np.abs(leps[0].pdgId) == np.abs(leps[1].pdgId)) and (np.abs(leps[0].pdgId) == 11)\\n nBJetMedium25_Recl = event.nBJetMedium25_Recl\\n deltarjb11 = deltaR(nonbjets[0].phi, nonbjets[0].eta, bjets[0].phi, bjets[0].eta)\\n jet3_eta = nonbjets[2].eta\\n deltarjet = deltaR(nonbjets[0].phi, nonbjets[0].eta, nonbjets[1].phi, nonbjets[1].eta)\\n jet5_pt = nonbjets[4]\\n\\n\\n # El orden de las variables es importante!!!\\n inputVars = [\\n year, \\n htjet25,\\n jet2_pt,\\n jet3_pt,\\n jet2_mass,\\n nJet25_Recl,\\n leps[1].pt,\\n mlj11,\\n nonbjets[2].mass,\\n nonbjets[1].pt,\\n nonbjets[3].mass,\\n lep1_charge, \\n leps[1].mass,\\n jet4_pt, \\n jet3_eta,\\n nonbjets[2].phi,\\n nonbjets[0].pt,\\n Flav_muon,\\n nonbjets[3].phi,\\n mll,\\n abs(leps[1].pdgId) == 11,\\n nonbjets[3].eta,\\n mlj12,\\n nonbjets[4].eta,\\n Flav_elec,\\n mlj21,\\n mlj22,\\n combipt,\\n np.sign(leps[1].pdgId),\\n ]\\n \\n # Esto te permite evaluar el modelo usando las inputVariables que nos hemos cocinado previamente\\n score_, cat_ = self.model.predict(inputVars)\\n ret[\\\"ttwmva_prob\\\"] = score_ \\n ret[\\\"ttwmva_cat\\\"] = cat_\\n return ret\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"Afb[0.6,-0.75,0.75]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"Afb\\\")\\n\\n # ss templates\\n self.modelBuilder.doVar(\\\"Dilu_ratio[1.0,0.0,10.0]\\\");\\n self.modelBuilder.doVar(\\\"Rdy_mumu_ss[1.0,0.0,10.0]\\\");\\n self.modelBuilder.doVar(\\\"Rdy_ee_ss[1.0,0.0,10.0]\\\");\\n \\n self.modelBuilder.factory_('expr::Rpl(\\\"0.5*(1.+@0*@1)\\\",Afb, Dilu_ratio)')\\n self.modelBuilder.factory_('expr::Rmn(\\\"0.5*(1.-@0*@1)\\\",Afb, Dilu_ratio)')\",\n \"def project(self, latitude, longitude):\\n longitude = longitude if longitude > 0 else 360 + longitude\\n\\n lon_array = self.ecmwf_data.longitude\\n lat_array = self.ecmwf_data.latitude\\n\\n # Find in the lon_array / lat_array the index interval\\n # Including lon_ul and lat_ul\\n a_lon = np.where((lon_array < longitude))[0][-1]\\n if longitude > lon_array.max():\\n # lon is between 359.6 and 0 ...\\n b_lon = 0\\n else:\\n b_lon = np.where((lon_array >= longitude))[0][0]\\n\\n a_lat = np.where((lat_array < latitude))[0][0]\\n b_lat = np.where((lat_array >= latitude))[0][-1]\\n\\n # Compute geo extent around the point :\\n # => extent definition : LR,LL,UL,UR\\n extent = [lon_array[a_lon], lat_array[a_lat],\\n lon_array[b_lon], lat_array[a_lat],\\n lon_array[b_lon], lat_array[b_lat],\\n lon_array[a_lon], lat_array[b_lat]]\\n\\n extent_index = [a_lon, a_lat,\\n b_lon, a_lat,\\n b_lon, b_lat,\\n a_lon, b_lat]\\n\\n log.info(' - Selected vertex : ')\\n log.info('LL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[0]), str(extent_index[1]), str(extent[0]), str(extent[1])))\\n log.info('LR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[2]), str(extent_index[3]), str(extent[2]), str(extent[3])))\\n log.info('UR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[4]), str(extent_index[5]), str(extent[4]), str(extent[5])))\\n log.info('UL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[6]), str(extent_index[7]), str(extent[6]), str(extent[7])))\\n\\n # TIE Point grid defined - compute linear transformation\\n # to estimate value at the lat/lon location\\n # origin : extent_ul[0], extent_ul[1]\\n delta_lon = 0.4 # extent[4] - extent[6] # UR - UL\\n delta_lat = -0.4 # extent[1] - extent[7] # LL - UL\\n\\n lambda_lat = latitude - extent[7]\\n lambda_lon = longitude - extent[6]\\n\\n beta_longitude = lambda_lon / delta_lon\\n beta_latitude = lambda_lat / delta_lat\\n\\n # Processing of all keys\\n for key in self.ecmwf_data.mandatory_attributes:\\n M = getattr(self.ecmwf_data, key)\\n v = self.linear_estimate(M,\\n beta_latitude,\\n beta_longitude,\\n extent_index)\\n setattr(self, key, v)\",\n \"def calc_visible( observatory, date_start, date_end, sigtype='transits', \\\\\\n ofilename_byplanet='default', ofilename_chronolog='default',\\n sun_alt_max=-6, sun_alt_twil=-12, sun_alt_dark=-18, \\\\\\n moon_alt_set=-6, target_elev_min=25, oot_deltdur=0.5, \\\\\\n tr_signals='signals_transits.txt', ec_signals='signals_eclipses.txt', \\\\\\n exclude_unranked=False, max_rank=None ):\\n\\n # Convert the minimum target altitude to a maximum zenith angle:\\n zenith_max = 90 - target_elev_min\\n\\n # Read in the basic target information for all transiting exoplanets:\\n targets, vmags, ras, decs, ttrs, pers, durs = read_eph( EPH_FILE )\\n\\n # Read in the rankings for transit and eclipse signals:\\n targets_ec, ranks_ec = eclipse_ranks( ec_signals )\\n targets_tr, ranks_tr = transit_ranks( tr_signals ) \\n\\n # Create the databases that will be used by pyephem for calculating\\n # ephemerides for each object:\\n ntargets = len( targets )\\n dbs = []\\n for i in range( ntargets ):\\n db_str = '{targ},f|S,{ra},{dec},{vmag}'.format( targ=targets[i], \\\\\\n ra=ras[i], \\\\\\n dec=decs[i], \\\\\\n vmag=vmags[i] )\\n dbs += [ db_str ]\\n\\n # Open the output file and write a header:\\n if ofilename_byplanet=='default':\\n if sigtype=='transits':\\n ofilename_byplanet = '{0}_transits_byplanet.txt'.format( observatory )\\n ofilename_chronolog = '{0}_transits_chronolog.txt'.format( observatory )\\n elif sigtype=='eclipses':\\n ofilename_byplanet = '{0}_eclipses_byplanet.txt'.format( observatory )\\n ofilename_chronolog = '{0}_eclipses_chronolog.txt'.format( observatory ) \\n else:\\n pdb.set_trace() #this shouldn't happen\\n\\n # Create the strings that will be used for column headers:\\n colheadingsa_bp, colheadingsb_bp = make_colheadings( 'byplanet' )\\n colheadingsa_ch, colheadingsb_ch = make_colheadings( 'chronolog' )\\n nchar_bp = np.max( [ len( colheadingsa_bp ), len( colheadingsb_bp ) ] )\\n nchar_ch = np.max( [ len( colheadingsa_ch ), len( colheadingsb_ch ) ] )\\n\\n ofile_bp = open( ofilename_byplanet, 'w' )\\n ofile_bp.write( '{0}\\\\n#\\\\n'.format( '#'*nchar_bp ) )\\n\\n ofile_ch = open( ofilename_chronolog, 'w' )\\n ofile_ch.write( '{0}\\\\n#\\\\n#'.format( '#'*nchar_ch ) )\\n \\n if sigtype=='transits':\\n sigtype_lower_singular = 'transit'\\n sigtype_upper_singular = 'Transit'\\n else:\\n sigtype_lower_singular = 'eclipse'\\n sigtype_upper_singular = 'Eclipse'\\n\\n ofile_bp.write( '# Visible primary {0}s from {1} between {2} and {3}, arranged by planet\\\\n#\\\\n'\\\\\\n .format( sigtype_lower_singular, observatory, date_start, date_end ) )\\n ofile_ch.write( '# Visible primary {0}s from {1} between {2} and {3}, arranged in chronological order\\\\n#\\\\n'\\\\\\n .format( sigtype_lower_singular, observatory, date_start, date_end ) )\\n if max_rank!=None:\\n header_str = '# Only considered the top {0} ranked signals and of these only those with {1}s\\\\n'\\\\\\n .format( max_rank, sigtype_lower_singular )\\n header_str += '# where the mid-time occurs at a zenith angle <{0}deg\\\\n#\\\\n'\\\\\\n .format( zenith_max )\\n else:\\n header_str = '# Considered all published transiting planets but output only printed where the\\\\n'\\n header_str += '# {0} mid-time occurs at a zenith angle <{0}deg\\\\n#\\\\n'.format( zenith_max )\\n if oot_deltdur>0:\\n header_str += '# Accounts for {0:.2f} transit durations before and after the transit to sample\\\\n'.format( oot_deltdur )\\n header_str += '# the out-of-transit baseline flux level\\\\n#\\\\n'\\n else:\\n header_str += '# No allowance made for time required to sample the out-of-transit baseline flux\\\\n'\\n header_str += '# before and after the transit\\\\n#\\\\n'\\n header_str += '# The sun elevation angle has been divided into the following ranges:\\\\n#\\\\n'\\n header_str += '# 1. Maximum acceptable = {0}deg\\\\n'.format( sun_alt_max )\\n header_str += '# 2. Dawn/Dusk = [ {0}deg to {1}deg ]\\\\n'.format( sun_alt_twil, sun_alt_max )\\n header_str += '# 3. Twilight = [ {0}deg to {1}deg ]\\\\n'.format( sun_alt_dark, sun_alt_twil )\\n header_str += '# 4. Dark < {0}deg\\\\n#\\\\n'.format( sun_alt_dark )\\n header_str += '# {0}s are described by a string with format {{type}}-{{details}}, where:\\\\n#\\\\n'\\\\\\n .format( sigtype_upper_singular )\\n header_str += '# {{type}} refers to whether or not we get all of the {0} with the sun below its\\\\n'.format( sigtype_lower_singular )\\n header_str += '# maximum acceptable value:\\\\n'\\n header_str += '# - \\\\'full\\\\' if the sun elevation is less than the maximum acceptable value for the\\\\n'\\n header_str += '# entire duration of the {0}\\\\n'.format( sigtype_lower_singular )\\n header_str += '# - \\\\'partial\\\\' if the sun elevation is less than the maximum acceptable value at\\\\n'\\n header_str += '# the {0} mid-time, but not for the entire duration of the {0}\\\\n#\\\\n'\\\\\\n .format( sigtype_lower_singular )\\n if oot_deltdur==0:\\n header_str += '# {details} can have the following values:\\\\n'\\n else:\\n header_str += '# {{details}} refer to the full span of the observations including the {0:.2f} transit\\\\n'.format( oot_deltdur )\\n header_str += '# durations before and after the {0} itself for sampling the baseline flux:\\\\n'.format( sigtype_lower_singular )\\n header_str += '# - \\\\'all_in_darktime\\\\' if the sun elevation is within the dark range for the entire\\\\n'\\n header_str += '# duration of the observations\\\\n'\\n header_str += '# - \\\\'dark_to_twilight\\\\' if the sun elevation is within the dark range at the start\\\\n'\\n header_str += '# of the observations and within the twilight range at the end of the observations\\\\n'\\n header_str += '# - \\\\'twilight_to_dark\\\\' if the sun elevation is within the twilight range at the \\\\n'\\n header_str += '# start of the observations and within the dark range at the end of the observations\\\\n'\\n header_str += '# - \\\\'start_at_dusk\\\\' if the sun elevation is within the twilight range at the start\\\\n'\\n header_str += '# of the observations\\\\n'\\n header_str += '# - \\\\'end_at_dawn\\\\' if the sun elevation is within the twilight range at the end of\\\\n'\\n header_str += '# the observations\\\\n'\\n if oot_deltdur>0:\\n header_str += '# - \\\\'partial_oot\\\\' if the sun elevation is above the maximum acceptable value at some\\\\n'\\n header_str += '# time during either the pre- or post-{0} baseline flux observations\\\\n'.format( sigtype_lower_singular )\\n header_str += '# - \\\\'miss_ingress\\\\' if the sun elevation is above the maximum acceptable value at\\\\n'\\n header_str += '# ingress but below this value at egress\\\\n'\\n header_str += '# - \\\\'miss_ingress\\\\' if the sun elevation is below the maximum acceptable value at\\\\n'\\n header_str += '# ingress but above this value at egress\\\\n'\\n header_str += '# - \\\\'only_middle\\\\' if the sun elevation is above the maximum acceptable value at\\\\n'\\n header_str += '# value at both ingress and egress, but descends below this value at some point\\\\n'\\n header_str += '# during the {0}\\\\n#\\\\n'.format( sigtype_lower_singular )\\n ofile_bp.write( header_str )\\n ofile_ch.write( header_str )\\n\\n # Create the observatory and timezone objects:\\n obs, tz = setup_observatory( observatory )\\n if ( obs==None ) and ( tz==None ):\\n ofile_bp.close()\\n os.remove( ofilename_byplanet )\\n return None\\n\\n # Generate instances of the Sun and Moon:\\n sun = ephem.Sun()\\n moon = ephem.Moon()\\n\\n # Convert start and end dates of observing period\\n # to pyephem float objects:\\n date_start = ephem.Date( date_start )\\n date_end = ephem.Date( date_end )\\n\\n # Go through the targets one-at-a-time, checking for visible transits:\\n mjds = []\\n date_floats = []\\n outstrs_ch = []\\n print '\\\\nCalculating visible transits for:'\\n for i in range( ntargets ):\\n\\n print ' ... target {0:d} of {1:d} --> {2} '\\\\\\n .format( i+1, ntargets, targets[i] )\\n first_i = True\\n per_i = pers[i]\\n dur_i = durs[i] / 24.\\n \\n # Initiate the ephem object for the target:\\n target_i = ephem.readdb( dbs[i] )\\n\\n # Check to see if the current target's signal has been ranked,\\n # and if it has, make sure that it was ranked highly enough,\\n # otherwise we skip to the next target straight away:\\n if sigtype=='transits':\\n nranked = len( targets_tr )\\n for j in range( nranked ):\\n if targets_tr[j]==target_i.name:\\n rank_i = int( ranks_tr[j] )\\n if ( max_rank!=None ):\\n if ( max_rank != -1 ) * ( rank_i>max_rank ):\\n include = False\\n else:\\n include = True\\n unranked = False\\n break\\n else:\\n if j==nranked-1:\\n unranked = True\\n elif sigtype=='eclipses':\\n nranked = len( targets_ec )\\n for j in range( nranked ):\\n if targets_ec[j]==target_i.name:\\n rank_i = int( ranks_ec[j] )\\n if ( max_rank!=None ):\\n if ( max_rank!=-1 ) * ( rank_i>max_rank ):\\n include = False\\n else:\\n include = True\\n unranked = False\\n break\\n else:\\n if j==nranked-1:\\n unranked = True\\n # See if we want to skip the current target for some reason:\\n if unranked==True:\\n if exclude_unranked==True:\\n continue\\n else:\\n if include==False:\\n continue\\n \\n # Convert the JD transit time to a pyephem date:\\n ttr_i = jd2pyephemdate( ttrs[i] )\\n\\n # If we're wanting eclipse information, approximate the eclipse\\n # time by subtracting half a period (the more eccentric the orbit,\\n # the worse this approximation will be):\\n if sigtype=='eclipses':\\n ttr_i -= 0.5 * per_i\\n\\n # Find the transit with mid-time occurring immediately\\n # before the observing run:\\n if ttr_i>date_start:\\n while ttr_i>date_start:\\n ttr_i -= per_i\\n else:\\n while ttr_i<date_start:\\n ttr_i += per_i\\n ttr_i -= per_i\\n\\n # If it's not even partially visible, start at the next transit: \\n if ( ttr_i + 0.5*dur_i )<date_start:\\n ttr_i += per_i\\n\\n # Now that we have a starting time, loop over successive transits\\n # until we reach the one with mid-time immediately before the end\\n # of the observing window:\\n while ttr_i<date_end:\\n\\n # Set the UT date of the current transit within the\\n # observatory object:\\n obs.date = ttr_i\\n\\n # Update the target ephemerides and calculate its\\n # elevation in the sky:\\n target_i.compute( obs )\\n target_i_alt_midtime = np.rad2deg( float( target_i.alt ) )\\n # If the target is not above the minimum elevation, bump up to\\n # the next transit and go back to the top of the loop:\\n if target_i_alt_midtime<target_elev_min:\\n ttr_i += per_i\\n continue\\n\\n # Given the altitude, calculate the approximate airmass:\\n zenith_i_midtime = 90 - target_i_alt_midtime\\n airmass = calc_airmass( zenith_i_midtime )\\n \\n # Update the Sun and Moon ephemerides and work out\\n # their elevations with respect to the horizon:\\n sun.compute( obs )\\n sun_alt_midtime = np.rad2deg( float( sun.alt ) )\\n moon.compute( obs )\\n moon_alt_midtime = np.rad2deg( float( moon.alt ) )\\n # If the Sun is above the maximum elevation limit, bump up to\\n # the next transit and go back to the top of the loop:\\n if sun_alt_midtime>sun_alt_max:\\n ttr_i += per_i\\n continue\\n # Get the Moon phase as a percentage of the illuminated face:\\n moonphase = '{0:d}'.format( int( np.round( moon.phase ) ) )\\n # Get the target-Moon angular separation:\\n moondist = int( np.round( np.rad2deg( ephem.separation( ( target_i.az, target_i.alt ), \\\\\\n ( moon.az, moon.alt ) ) ) ) )\\n moondist = '{0:d}'.format( moondist )\\n\\n # If we make it to here we will consider the transit potentially\\n # observable. Next, evaluate whether or not its detectability rank\\n # meets our requirements:\\n if first_i==True:\\n\\n # Write the header for the current object to the output file:\\n nchar = max( [ len( colheadingsa_bp ), len( colheadingsb_bp ) ] )\\n ofile_bp.write( '\\\\n\\\\n{0}\\\\n#\\\\n'.format( '#'*( nchar_bp ) ) )\\n if unranked==True:\\n if sigtype=='transits':\\n header_str = '# {0} --> not enough information to rank primary transit signal \\\\n#\\\\n'\\\\\\n .format( targets[i] )\\n else:\\n header_str = '# {0} --> not enough information to rank secondary eclipse signal \\\\n#\\\\n'\\\\\\n .format( targets[i] )\\n else:\\n if sigtype=='transits':\\n header_str = '# {0} --> primary transit signal ranked {1} out of {2} \\\\n#\\\\n'\\\\\\n .format( targets[i], str( rank_i ), str( nranked ) )\\n else:\\n header_str = '# {0} --> secondary eclipse signal ranked {1} out of {2} \\\\n#\\\\n'\\\\\\n .format( targets[i], str( rank_i ), str( nranked ) )\\n header_str += '# RA (hh mm ss.s) Dec (dd mm ss.s)\\\\n'\\n ra_str = ras[i].replace( ':', ' ' )\\n dec_str = decs[i].replace( ':', ' ' )\\n header_str += '# {0} {1}\\\\n#\\\\n'.format( ra_str, dec_str )\\n header_str += colheadingsa_bp\\n header_str += colheadingsb_bp\\n\\n ofile_bp.write( header_str )\\n ofile_bp.write( '{0}{1}\\\\n'.format( '#', '-'*( nchar_bp-1 ) ) )\\n \\n first_i = False\\n \\n # Now we want to work out some more details about\\n # what kind of transit it will be.\\n\\n # Determine the Sun, Moon and target elevations\\n # at the start of the observations:\\n obs.date = ttr_i - dur_i*( 0.5 + oot_deltdur )\\n sun.compute( obs )\\n sun_alt_start = np.rad2deg( float( sun.alt ) )\\n moon.compute( obs )\\n moon_alt_start = np.rad2deg( float( moon.alt ) )\\n target_i.compute( obs )\\n target_i_alt_start = np.rad2deg( float( target_i.alt ) ) \\n\\n # Do the same for the end of the observations:\\n obs.date = ttr_i + dur_i*( 0.5 + oot_deltdur )\\n sun.compute( obs )\\n sun_alt_end = np.rad2deg( float( sun.alt ) )\\n moon.compute( obs )\\n moon_alt_end = np.rad2deg( float( moon.alt ) )\\n target_i.compute( obs )\\n target_i_alt_end = np.rad2deg( float( target_i.alt ) )\\n\\n # Determine the Sun, Moon and target elevations\\n # at ingress:\\n obs.date = ttr_i-0.5*dur_i\\n sun.compute( obs )\\n sun_alt_ingress = np.rad2deg( float( sun.alt ) )\\n moon.compute( obs )\\n moon_alt_ingress = np.rad2deg( float( moon.alt ) )\\n target_i.compute( obs )\\n target_i_alt_ingress = np.rad2deg( float( target_i.alt ) ) \\n\\n # Do the same for egress:\\n obs.date = ttr_i+0.5*dur_i\\n sun.compute( obs )\\n sun_alt_egress = np.rad2deg( float( sun.alt ) )\\n moon.compute( obs )\\n moon_alt_egress = np.rad2deg( float( moon.alt ) )\\n target_i.compute( obs )\\n target_i_alt_egress = np.rad2deg( float( target_i.alt ) )\\n\\n # First category of transits are those where the entire transit and\\n # requested out-of-transit baselines either side of ingress and egress\\n # occur while the Sun is below the maximum acceptable altitude:\\n if ( sun_alt_start<sun_alt_max )*( sun_alt_end<sun_alt_max ):\\n\\n # Case 1 = The Sun is always below our dark night time threshold:\\n if ( sun_alt_start<sun_alt_dark )*( sun_alt_end<sun_alt_dark ):\\n trtype = 'full-all_in_darktime'\\n\\n # Case 2 = The Sun remains within the twilight range for the entire transit:\\n elif ( sun_alt_start>sun_alt_dark )*( sun_alt_start<sun_alt_twil )*\\\\\\n ( sun_alt_end>sun_alt_dark )*( sun_alt_end<sun_alt_twil ):\\n trtype = 'full-all_in_twilight'\\n \\n # Case 3 = The Sun starts low enough to be classified as twilight,\\n # but not low enough to be classified dark, and by the end of the\\n # transit has descended low enough to be considered dark: \\n elif ( sun_alt_start<sun_alt_twil )*( sun_alt_start>sun_alt_dark )* \\\\\\n ( sun_alt_end<sun_alt_dark ):\\n trtype = 'full-twilight_to_dark'\\n\\n # Case 4 = The Sun starts low enough to be considered at dark, but\\n # by the end of the transit it has ascended enough that it is no\\n # longer considered dark but twilight instead:\\n elif ( sun_alt_end<sun_alt_twil )*( sun_alt_end>sun_alt_dark)* \\\\\\n ( sun_alt_start<sun_alt_dark ):\\n trtype = 'full-dark_to_twilight'\\n\\n # Case 5 = At the start of the transit, the Sun is at an altitude\\n # somewhere between its maximum acceptable value and the twilight\\n # value, so we say the transit starts at 'dusk':\\n elif ( sun_alt_start<sun_alt_max )*( sun_alt_start>sun_alt_twil ):\\n trtype = 'full-start_at_dusk'\\n\\n # Case 6 = At the end of the transit, the Sun is at an altitude\\n # somewhere between its maximum acceptable value and the twilight\\n # value, so we say the transit ends at 'dawn':\\n elif ( sun_alt_end<sun_alt_max )*( sun_alt_end>sun_alt_twil ):\\n trtype = 'full-end_at_dawn'\\n\\n # Don't think there should be any other cases?\\n else:\\n pdb.set_trace() #if this happens, need to work out what the Case should be\\n print 'backstop'\\n pdb.set_trace()\\n \\n # The following variations describe cases where we do not get the\\n # full transit plus out-of-transit baseline:\\n\\n elif ( sun_alt_ingress<sun_alt_max )*( sun_alt_egress<sun_alt_max ):\\n\\n # Case 6 = The sky darkness was within our acceptable range for the\\n # full duration of the transit but we don't get the full out-of-transit\\n # baseline either before or after the transit within this range:\\n trtype = 'full-partial_oot'\\n\\n elif ( sun_alt_ingress>sun_alt_max )*( sun_alt_end<sun_alt_max ):\\n\\n # Case 7 = At the start of the transit, the Sun was above our minimum\\n # acceptable altitude, but by the time of mid-transit it had descended\\n # below this level and remained acceptable until the end of the transit:\\n trtype = 'partial-miss_ingress'\\n\\n elif ( sun_alt_start<sun_alt_max )*( sun_alt_egress>sun_alt_max ):\\n\\n # Case 8 = At the start of the transit, the Sun was above our minimum\\n # acceptable altitude, but by the time of mid-transit it had descended\\n # below this level and remained acceptable until the end of the transit:\\n trtype = 'partial-miss_egress'\\n\\n else:\\n # Case 9 = In the case of a transit lasting longer than the entire night,\\n # the Sun altitude meets the minimum requirement at the transit mid-time,\\n # but it's at an unacceptable altitude for both the start and end:\\n trtype = 'partial-only_middle'\\n\\n # Now work out if the Moon is above or below the horizon:\\n if ( moon_alt_start<moon_alt_set )*( moon_alt_end<moon_alt_set ):\\n moonpos = 'moon-down'\\n moonphase = '-'\\n moondist = '-'\\n else:\\n if ( moon_alt_start>0 )*( moon_alt_end>0 ):\\n moonpos = 'moon-up'\\n elif ( moon_alt_start<0 )*( moon_alt_end>moon_alt_set ):\\n moonpos = 'moon-rising'\\n elif ( moon_alt_start>moon_alt_set )*( moon_alt_end<0 ):\\n moonpos = 'moon-setting'\\n else:\\n pdb.set_trace() #this shouldn't happen\\n\\n # Determine the start and end times of transit in UT: \\n utc_tstart_tuple = ephem.date( ttr_i-0.5*dur_i ).tuple()\\n utc_tstart_dt = datetime.datetime( int(utc_tstart_tuple[0]), \\\\\\n int(utc_tstart_tuple[1]), \\\\\\n int(utc_tstart_tuple[2]), \\\\\\n int(utc_tstart_tuple[3]), \\\\\\n int(utc_tstart_tuple[4]), \\\\\\n int(utc_tstart_tuple[5]), \\\\\\n tzinfo=pytz.utc )\\n\\n utc_tend_tuple = ephem.date( ttr_i+0.5*dur_i ).tuple()\\n utc_tend_dt = datetime.datetime( int(utc_tend_tuple[0]), \\\\\\n int(utc_tend_tuple[1]), \\\\\\n int(utc_tend_tuple[2]), \\\\\\n int(utc_tend_tuple[3]), \\\\\\n int(utc_tend_tuple[4]), \\\\\\n int(utc_tend_tuple[5]), \\\\\\n tzinfo=pytz.utc )\\n \\n # Express the transit mid-time as a Modified Julian Date:\\n mjd = ephem.julian_date( ttr_i ) - 2400000.5\\n\\n # Prepare and write output line to file:\\n outstr_bp = make_outstr_bp( mjd, utc_tstart_dt, utc_tend_dt, zenith_i_midtime, \\\\\\n airmass, trtype, moonpos, moondist, moonphase )\\n ofile_bp.write( outstr_bp )\\n\\n # Also save the lines to be written to other chronological output file later:\\n mjds += [ mjd ]\\n date_floats += [ ephem.Date( utc_tstart_dt )+1.0 ] # number of days since midday on 1 Jan 1900 \\n\\n outstr_ch = make_outstr_ch( targets[i], mjd, utc_tstart_dt, utc_tend_dt, zenith_i_midtime, \\\\\\n airmass, trtype, moonpos, moondist, moonphase )\\n outstrs_ch += [ outstr_ch ]\\n\\n # Tick over to the next transit for the next loop:\\n ttr_i += per_i\\n\\n # Now that we've identified all of the transits, sort them into\\n # chronological order and write this information to output:\\n header_str = '#\\\\n#\\\\n{0}\\\\n'.format( '#'*nchar_ch )\\n header_str += colheadingsa_ch\\n header_str += colheadingsb_ch\\n ofile_ch.write( header_str )\\n ofile_ch.write( '{0}{1}\\\\n'.format( '#', '-'*( nchar_ch-1 ) ) )\\n mjds = np.array( mjds )\\n date_floats = np.array( date_floats )\\n ixs = np.argsort( mjds )\\n for i in range( len( mjds ) ):\\n j = ixs[i]\\n df = np.floor( date_floats[j] )\\n if i!=0:\\n df_prev = np.floor( date_floats[ixs[i-1]] )\\n if df-df_prev>=1.0:\\n ofile_ch.write( '#{0}\\\\n'.format( '-'*( nchar_ch-1 ) ) )\\n ofile_ch.write( outstrs_ch[j] )\\n ofile_ch.write( '{0}{1}\\\\n'.format( '#', '-'*( nchar-1 ) ) )\\n\\n # Save the output files and finish:\\n ofile_bp.close()\\n ofile_ch.close()\\n print '\\\\nSaved output in:'\\n print ' %s' % ofilename_byplanet\\n print ' %s' % ofilename_chronolog\\n\\n return ofilename_byplanet, ofilename_chronolog\",\n \"def _UpdateCriteria(self):\\n grad = self.traj.grad[-1]\\n disp = self.traj.coords[-1] - self.traj.coords[-2]\\n self.delta_e = self.traj.energy[-1] - self.traj.energy[-2]\\n self.grad_max = numpy.amax(grad)\\n self.disp_max = numpy.amax(disp)\\n self.grad_rms = math.sqrt(numpy.mean(grad**2))\\n self.disp_rms = math.sqrt(numpy.mean(disp**2))\",\n \"def __init__(\\n self,\\n newE0=None,\\n newE1=None,\\n newE2=None,\\n newMaximumHorizontalProjection=None,\\n newMaximumVerticalProjection=None,\\n newEquivalentHorizontalRadius=None,\\n ):\\n\\n # Required Keys\\n if newE0 is not None:\\n self.e0 = newE0\\n else:\\n self.e0 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\\n\\n if newE1 is not None:\\n self.e1 = newE1\\n else:\\n self.e1 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\\n\\n if newE2 is not None:\\n self.e2 = newE2\\n else:\\n self.e2 = processingformats.errorEllipseAxis.ErrorEllipseAxis()\\n\\n if newMaximumHorizontalProjection is not None:\\n self.maximumHorizontalProjection = newMaximumHorizontalProjection\\n\\n if newMaximumVerticalProjection is not None:\\n self.maximumVerticalProjection = newMaximumVerticalProjection\\n\\n if newEquivalentHorizontalRadius is not None:\\n self.equivalentHorizontalRadius = newEquivalentHorizontalRadius\",\n \"def extractOblateEllipse(kperp,kpar,aniso):\\n\\n if aniso > 1.:\\n #print(\\\"Swapping axis for oblate ellipse\\\")\\n aniso = 1. / aniso\\n\\n # Define the eccentricity of the ellipse\\n e = np.sqrt( 1. - aniso**2. )\\n\\n\\n # the oblate surface area\\n surface = 2. * np.pi * kperp**2. * ( 1. + ( (1. - e**2.) / e ) * np.arctanh(e) )\\n\\n return surface\",\n \"def __init__(self, *args, **kwargs):\\n try:\\n geometry = kwargs['geometry']\\n except:\\n pass\\n # ...\\n dim = geometry.dim\\n if dim == 1:\\n func_one = lambda x : [ 1. ]\\n func_zero = lambda x : [ 0. ]\\n func_stiff = lambda x : [ 1. ]\\n if dim == 2:\\n func_one = lambda x,y : [ 1. ]\\n func_zero = lambda x,y : [ 0. ]\\n func_stiff = lambda x,y : [ 1., 0. \\\\\\n , 0., 1. ]\\n if dim == 3:\\n func_one = lambda x,y,z : [ 1. ]\\n func_zero = lambda x,y,z : [ 0. ]\\n func_stiff = lambda x,y,z : [ 1., 0., 0. \\\\\\n , 0., 1., 0. \\\\\\n , 0., 0., 1. ]\\n # ...\\n\\n # ...\\n tc_d = {}\\n tc_d['A'] = func_stiff\\n tc_d['b'] = func_zero\\n try:\\n tc_d['AllDirichlet'] = kwargs['AllDirichlet']\\n except:\\n pass\\n try:\\n tc_d['bc_dirichlet'] = kwargs['bc_dirichlet']\\n except:\\n pass\\n try:\\n tc_d['bc_neumann'] = kwargs['bc_neumann']\\n except:\\n pass\\n try:\\n tc_d['Metric'] = kwargs['Metric']\\n except:\\n pass\\n # ...\\n\\n # ...\\n poisson.__init__(self, *args, **kwargs)\\n self.Dn = basicPDE(geometry=geometry, testcase=tc_d)\\n # ...\\n\\n # ...\",\n \"def initialize_variables(self):\\n super(D2Model, self).initialize_variables()\\n\\n s = \\\"::: initializing 2D variables :::\\\"\\n print_text(s, cls=self)\\n\\n # Depth below sea level :\\n class Depth(Expression):\\n def eval(self, values, x):\\n values[0] = abs(min(0, x[2]))\\n self.D = Depth(element=self.Q.ufl_element())\\n \\n # Enthalpy model\\n self.theta_surface = Function(self.Q, name='theta_surface')\\n self.theta_float = Function(self.Q, name='theta_float')\\n self.theta_app = Function(self.Q, name='theta_app')\\n self.theta = Function(self.Q, name='theta')\\n self.theta0 = Function(self.Q, name='theta0')\\n self.W0 = Function(self.Q, name='W0')\\n self.thetahat = Function(self.Q, name='thetahat')\\n self.uhat = Function(self.Q, name='uhat')\\n self.vhat = Function(self.Q, name='vhat')\\n self.what = Function(self.Q, name='what')\\n self.mhat = Function(self.Q, name='mhat')\\n self.rho_b = Function(self.Q, name='rho_b')\\n\\n # Age model \\n self.age = Function(self.Q, name='age')\\n self.a0 = Function(self.Q, name='a0')\\n\\n # Surface climate model\\n self.precip = Function(self.Q, name='precip')\\n\\n # Stokes-balance model :\\n self.u_s = Function(self.Q, name='u_s')\\n self.u_t = Function(self.Q, name='u_t')\\n self.F_id = Function(self.Q, name='F_id')\\n self.F_jd = Function(self.Q, name='F_jd')\\n self.F_ib = Function(self.Q, name='F_ib')\\n self.F_jb = Function(self.Q, name='F_jb')\\n self.F_ip = Function(self.Q, name='F_ip')\\n self.F_jp = Function(self.Q, name='F_jp')\\n self.F_ii = Function(self.Q, name='F_ii')\\n self.F_ij = Function(self.Q, name='F_ij')\\n self.F_iz = Function(self.Q, name='F_iz')\\n self.F_ji = Function(self.Q, name='F_ji')\\n self.F_jj = Function(self.Q, name='F_jj')\\n self.F_jz = Function(self.Q, name='F_jz')\\n self.tau_iz = Function(self.Q, name='tau_iz')\\n self.tau_jz = Function(self.Q, name='tau_jz')\",\n \"def doParametersOfInterest(self):\\n\\n self.modelBuilder.doVar(\\\"Afb[0.6,-0.70,0.70]\\\");\\n self.modelBuilder.doSet(\\\"POI\\\",\\\"Afb\\\")\\n\\n # ss templates\\n self.modelBuilder.doVar(\\\"Rdy_mumu_ss[1.0,0.0,10.0]\\\");\\n self.modelBuilder.doVar(\\\"Rdy_ee_ss[1.0,0.0,10.0]\\\");\\n \\n self.modelBuilder.factory_('expr::Rpl(\\\"(1.+@0)\\\",Afb)')\\n self.modelBuilder.factory_('expr::Rmn(\\\"(1.-@0)\\\",Afb)')\",\n \"def __init__(self,E,px,py,pz):\\n Particle.__init__(self)\\n self.E=float(E)\\n self.px=float(px)\\n self.py=float(py)\\n self.pz=float(pz)\\n self.cal_pt()\\n self.cal_phi()\\n self.cal_eta()\\n #self.cal_mass()\\n #print self.E,self.px,self.py,self.pz\\n #print self.pt,self.phi,self.eta\",\n \"def simulation_OFC(self,ncmE,ncmC,f,g,Cfun,h,dt,tf,x0,z0=None,dscale=10.0,\\\\\\n xnames=\\\"num\\\",Ncol=1,FigSize=(20,10),FontSize=20,phis=None):\\n \\\"\\\"\\\"\\n \\n \\n 1) SIMULATION\\n \\n \\n \\\"\\\"\\\"\\n if len(sig(f).parameters) == 1:\\n fun1 = f\\n f = lambda x,p: fun1(x)\\n if len(sig(g).parameters) == 1:\\n fun2 = g\\n g = lambda x,p: fun2(x)\\n if len(sig(Cfun).parameters) == 1:\\n fun3 = Cfun\\n Cfun = lambda x,p: fun3(x)\\n if len(sig(h).parameters) == 1:\\n fun4 = h\\n h = lambda x,p: fun4(x)\\n print(\\\"========================================================\\\")\\n print(\\\"====================== SIMULATIOM ======================\\\")\\n print(\\\"========================================================\\\")\\n if dt <= self.dt_rk:\\n self.dt_rk = dt\\n self.Nrk = int(dt/self.dt_rk)\\n Nsim = int(tf/dt)\\n np.set_printoptions(precision=1)\\n print(\\\"time step =\\\",dt)\\n print(\\\"terminal time =\\\",tf)\\n print(\\\"initial state =\\\",x0)\\n print(\\\"estimated initial state =\\\",z0)\\n funx = lambda x,p,dEf: f(x,p)+dEf(x,p)\\n z = z0\\n zhis = np.zeros((Nsim+1,self.n))\\n zhis[0,:] = z\\n x = x0\\n xhis = np.zeros((Nsim+1,self.n))\\n xhis[0,:] = x\\n tit1 = \\\"Performance of NCM-based Output Feedback (1)\\\"\\n tit2 = \\\"Performance of NCM-based Output Feedback (2)\\\"\\n tit3 = \\\"Performance of NCM-based Output Feedback (3)\\\"\\n tit4 = \\\"Performance of NCM-based Output Feedback (4)\\\"\\n ly = r\\\"estimation error: $\\\\|x-\\\\hat{x}\\\\|_2$\\\"\\n l1 = r\\\"estimation error\\\"\\n lyb = r\\\"tracking error: $\\\\|x-x_d\\\\|_2$\\\"\\n l1b = r\\\"tracking error\\\"\\n bNam1 = \\\"=================== ESTIMATION ERROR ===================\\\"\\n bNam2 = \\\"============ ESTIMATION ERROR OF EACH STATE ============\\\"\\n bNam3 = \\\"==================== Tracking ERROR ====================\\\"\\n bNam4 = \\\"============= Tracking ERROR OF EACH STATE =============\\\"\\n l2 = r\\\"optimal steady-state upper bound\\\"\\n if phis == None:\\n phis = np.linspace(self.plims[0,:],self.plims[1,:],Nsim)\\n for k in range(Nsim):\\n p = phis[k,:]\\n Mc = ncmC.ncm(z,p)\\n u = -g(z,p).T@Mc@z\\n dEfC = lambda x,p: g(x,p)@u\\n d1 = self.unifrand2(ncmC.d1_over,np.size(ncmC.Bw(x,p),1))*dscale\\n x = self.rk4(x,p,dEfC,funx)+ncmC.Bw(x,p)@d1*dt\\n xhis[k+1,:] = x\\n Me = ncmE.ncm(z,p)\\n Cx = Cfun(z,p)\\n Lx = Me@Cx.T\\n #Lx = K.T\\n d2 = self.unifrand2(ncmE.d2_over,np.size(ncmE.Gw(x,p),1))*dscale\\n y = h(x,u,p)+ncmE.Gw(x,p)@d2\\n funz = lambda z,p,dEf: f(z,p)+g(z,p)@u+dEf(z,p)\\n dEfE = lambda z,p: Lx@(y-h(z,u,p))\\n z = self.rk4(z,p,dEfE,funz)\\n zhis[k+1,:] = z\\n this = np.linspace(0,tf,Nsim+1)\\n \\\"\\\"\\\"\\n \\n \\n 2) FIGURE GENERATION\\n \\n \\n \\\"\\\"\\\"\\n print(\\\"========================================================\\\")\\n print(bNam1)\\n print(\\\"========================================================\\\")\\n matplotlib.rcParams.update({\\\"font.size\\\": 15})\\n matplotlib.rc(\\\"text\\\",usetex=True)\\n plt.figure()\\n plt.plot(this,np.sqrt(np.sum((xhis-zhis)**2,1)))\\n plt.plot(this,np.ones(np.size(this))*ncmE.Jcv_opt)\\n plt.xlabel(r\\\"time\\\",fontsize=FontSize)\\n plt.ylabel(ly,fontsize=FontSize)\\n plt.legend([l1,l2],loc=\\\"best\\\")\\n plt.title(tit1,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam2)\\n print(\\\"========================================================\\\")\\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\\n if Ncol == 1:\\n ax = np.reshape(ax,(self.n,1))\\n elif Nrow == 1:\\n ax = np.reshape(ax,(1,self.n))\\n if xnames == \\\"num\\\":\\n xnames = []\\n for i in range(self.n):\\n xnames += [r\\\"state \\\"+str(i+1)]\\n for row in range(Nrow):\\n for col in range(Ncol):\\n i = Ncol*row+col\\n if i+1 <= self.n:\\n ax[row,col].plot(this,xhis[:,i]-zhis[:,i])\\n ax[row,col].set_xlabel(r\\\"time\\\",fontsize=FontSize)\\n LabelName = r\\\"estimation error: \\\"+xnames[i]\\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\\n fig.suptitle(tit2,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam3)\\n print(\\\"========================================================\\\")\\n matplotlib.rcParams.update({\\\"font.size\\\": 15})\\n matplotlib.rc(\\\"text\\\",usetex=True)\\n plt.figure()\\n plt.plot(this,np.sqrt(np.sum((xhis)**2,1)))\\n plt.plot(this,np.ones(np.size(this))*ncmC.Jcv_opt)\\n plt.xlabel(r\\\"time\\\",fontsize=FontSize)\\n plt.ylabel(lyb,fontsize=FontSize)\\n plt.legend([l1b,l2],loc=\\\"best\\\")\\n plt.title(tit3,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(bNam4)\\n print(\\\"========================================================\\\")\\n Nrow = int(self.n/Ncol)+np.remainder(self.n,Ncol)\\n fig,ax = plt.subplots(Nrow,Ncol,figsize=FigSize)\\n plt.subplots_adjust(wspace=0.25,hspace=0.25)\\n if Ncol == 1:\\n ax = np.reshape(ax,(self.n,1))\\n elif Nrow == 1:\\n ax = np.reshape(ax,(1,self.n))\\n if xnames == \\\"num\\\":\\n xnames = []\\n for i in range(self.n):\\n xnames += [r\\\"state \\\"+str(i+1)]\\n for row in range(Nrow):\\n for col in range(Ncol):\\n i = Ncol*row+col\\n if i+1 <= self.n:\\n ax[row,col].plot(this,xhis[:,i])\\n ax[row,col].set_xlabel(r\\\"time\\\",fontsize=FontSize)\\n LabelName = r\\\"tracking error: \\\"+xnames[i]\\n ax[row,col].set_ylabel(LabelName,fontsize=FontSize)\\n fig.suptitle(tit4,fontsize=FontSize)\\n plt.show()\\n print(\\\"========================================================\\\")\\n print(\\\"==================== SIMULATIOM END ====================\\\")\\n print(\\\"========================================================\\\")\\n return this,xhis,zhis\",\n \"def projected():\\n # pull updated list of donors(class)\\n projected_list = create_donors_list()\\n print('''Welcome to the Projection Option. Here you can run projections for contributions. \\n Help Companies structure their matching donations based on past contribution amounts.\\n Simply enter the minumum and maximum donation range that will be matched and see the total contribution:''')\\n try:\\n minimum_input = float(\\n input('Enter a minimum donation amount (0 if none): '))\\n maximum_input = float(\\n input('Enter a maximum donation amount (0 if none): '))\\n factor = float(\\n input('Please enter the factor you wish to multiply these donations by >> '))\\n except ValueError:\\n print('Please follow instructions and enter a number only')\\n\\n projections = projection(projected_list, factor,\\n minimum_input, maximum_input)\\n print('\\\\nProjected contribution value: ${:,.2f}'.format(projections))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.606067","0.60375684","0.5986863","0.5974436","0.5932277","0.5917319","0.5792665","0.57505715","0.573772","0.56984025","0.5694427","0.5688644","0.5684781","0.5637021","0.562528","0.5622044","0.55693513","0.55580497","0.5556933","0.55527645","0.55185956","0.55151486","0.5512713","0.5503979","0.54987675","0.549087","0.5478232","0.54722404","0.54573905","0.54531026","0.54523206","0.5451089","0.54487246","0.54244184","0.54176694","0.54111093","0.5396433","0.5392391","0.53913444","0.5386097","0.53837264","0.53651696","0.53528905","0.5352348","0.53512025","0.5344104","0.5333301","0.533126","0.5329402","0.5313246","0.53098714","0.52952194","0.5292666","0.5291086","0.5291086","0.5291033","0.52889574","0.5288187","0.52848285","0.5282079","0.52767956","0.52755326","0.527307","0.52685815","0.5265773","0.52626055","0.5262374","0.52618253","0.5255955","0.52555734","0.5249075","0.5235691","0.5234805","0.523478","0.52336174","0.5233313","0.5231632","0.52254504","0.52232593","0.52230716","0.5220692","0.5213281","0.5211037","0.5207541","0.5197662","0.5191402","0.51889485","0.5188094","0.51824975","0.51806754","0.5176153","0.5174849","0.5169704","0.51669306","0.51619184","0.5155114","0.51511824","0.5149982","0.51444536","0.5143172"],"string":"[\n \"0.606067\",\n \"0.60375684\",\n \"0.5986863\",\n \"0.5974436\",\n \"0.5932277\",\n \"0.5917319\",\n \"0.5792665\",\n \"0.57505715\",\n \"0.573772\",\n \"0.56984025\",\n \"0.5694427\",\n \"0.5688644\",\n \"0.5684781\",\n \"0.5637021\",\n \"0.562528\",\n \"0.5622044\",\n \"0.55693513\",\n \"0.55580497\",\n \"0.5556933\",\n \"0.55527645\",\n \"0.55185956\",\n \"0.55151486\",\n \"0.5512713\",\n \"0.5503979\",\n \"0.54987675\",\n \"0.549087\",\n \"0.5478232\",\n \"0.54722404\",\n \"0.54573905\",\n \"0.54531026\",\n \"0.54523206\",\n \"0.5451089\",\n \"0.54487246\",\n \"0.54244184\",\n \"0.54176694\",\n \"0.54111093\",\n \"0.5396433\",\n \"0.5392391\",\n \"0.53913444\",\n \"0.5386097\",\n \"0.53837264\",\n \"0.53651696\",\n \"0.53528905\",\n \"0.5352348\",\n \"0.53512025\",\n \"0.5344104\",\n \"0.5333301\",\n \"0.533126\",\n \"0.5329402\",\n \"0.5313246\",\n \"0.53098714\",\n \"0.52952194\",\n \"0.5292666\",\n \"0.5291086\",\n \"0.5291086\",\n \"0.5291033\",\n \"0.52889574\",\n \"0.5288187\",\n \"0.52848285\",\n \"0.5282079\",\n \"0.52767956\",\n \"0.52755326\",\n \"0.527307\",\n \"0.52685815\",\n \"0.5265773\",\n \"0.52626055\",\n \"0.5262374\",\n \"0.52618253\",\n \"0.5255955\",\n \"0.52555734\",\n \"0.5249075\",\n \"0.5235691\",\n \"0.5234805\",\n \"0.523478\",\n \"0.52336174\",\n \"0.5233313\",\n \"0.5231632\",\n \"0.52254504\",\n \"0.52232593\",\n \"0.52230716\",\n \"0.5220692\",\n \"0.5213281\",\n \"0.5211037\",\n \"0.5207541\",\n \"0.5197662\",\n \"0.5191402\",\n \"0.51889485\",\n \"0.5188094\",\n \"0.51824975\",\n \"0.51806754\",\n \"0.5176153\",\n \"0.5174849\",\n \"0.5169704\",\n \"0.51669306\",\n \"0.51619184\",\n \"0.5155114\",\n \"0.51511824\",\n \"0.5149982\",\n \"0.51444536\",\n \"0.5143172\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6673543"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84683,"cells":{"query":{"kind":"string","value":"Computes a scale matrix."},"document":{"kind":"string","value":"def scale(v: InputTensor) -> t.Tensor:\n v = util.to_tensor(v, dtype=t.float32)\n assert len(v.shape) == 1\n return t.diag(t.cat([v, v.new_ones([1])], dim=0))"},"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 scaleMatrix(self, sx=0, sy=0, sz=0):\n\n return np.array([[sx, 0, 0, 0],\n [0, sy, 0, 0],\n [0, 0, sz, 0],\n [0, 0, 0, 1]])","def Scale(*args, **kwargs):\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)","def matScale(mat, scale):\n shape=matShape(mat)\n return [[matGet(mat,x,y)*scale for y in range(shape[1])] \\\n for x in range(shape[0])]","def scaling_matrix(sx, sy, sz):\n S = np.array([[sx, 0, 0, 0],\n [0, sy, 0, 0],\n [0, 0, sz, 0],\n [0, 0, 0, 1]])\n return S","def scale(matrix, s):\n x, y = matrix.shape\n print(matrix.shape)\n\n print(np.ones(matrix.shape))\n # b = np.ones(x, y)\n # print(\"ones:\", b)\n return np.kron(a, np.ones((x, y)))","def scale_matrix(N):\n return N * np.identity(2)","def apply_scale( vectors, scale ):\n # create a scaling matrix\n matrix = numpy.array([\n [ scale[ 0 ], 0.0, 0.0 ],\n [ 0.0, scale[ 1 ], 0.0 ],\n [ 0.0, 0.0, scale[ 2 ] ]\n ])\n return numpy.dot( vectors, matrix )","def scale_columns(matrix, scales):\n return np.einsum(\"ij,j->ij\", matrix, scales)","def scaling(mat, factor):\n\treturn mat / (mat + factor)","def row_scale(x, s):\r\n return col_scale(x.T, s).T","def getScalingMatrix(sx, sy, sz):\n return MatrixExtended([\n [sx, 0, 0, 0],\n [0, sy, 0, 0],\n [0, 0, sz, 0],\n [0, 0, 0, 1]])","def scale(self, scale):\n \n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\n self.transform(scale_matrix)","def col_scale(x, s):\r\n\r\n if x.format == 'csc':\r\n return ColScaleCSC()(x, s)\r\n elif x.format == 'csr':\r\n return RowScaleCSC()(x.T, s).T\r\n else:\r\n raise NotImplementedError()","def scale_matrix(matrix, k):\n new_matrix = []\n for v in range(NUMBER_VECTORS):\n new_matrix.append(matrix[v].scale(k))\n return new_matrix","def scale_matrix(scaler, M):\n # Section 1: Make a copy of the given matrix\n new = copy_matrix(M)\n rows = len(new); cols = len(new[0])\n\n # Section 2: Scale each element of the copied matrix\n for i in range(rows):\n for j in range(cols):\n new[i][j] = new[i][j] * scaler\n\n return new","def scaleAll(self, scale):\n center = [self.width/2, self.height/2, 0, 0]\n matrix = self.scaleMatrix(scale, scale, scale)\n\n for wireframe in self.wireframes.values():\n wireframe.scale(center, matrix)","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]","def scale(inp, ab):\n\n return inp * ab[0] + ab[1]\n # pass","def homog_scale_mtx(scale: float) -> numpy.array:\n return numpy.array(\n [[scale, 0, 0, 0], [0, scale, 0, 0], [0, 0, scale, 0], [0, 0, 0, 1]],\n dtype=numpy.float64,\n )","def _scale(self, normalize, mat):\n mat = mat.astype(float)\n if normalize:\n mat = sklearn_norm(mat,\n feature_range=(0, 1),\n axis=0,\n copy=True)\n else:\n return mat\n return mat","def extractScale(self,groups):\n self.scaleX = float(groups[0])\n self.scaleY = float(groups[0])\n if len(groups) == 2 and groups[1]:\n self.scaleY = float(groups[1])\n self.matrix = [[self.scaleX, 0.0, 0.0], \\\n [0.0, self.scaleY, 0.0]]","def scale(self, scale_x: float, scale_y: float) -> None:\n self.tensor[:, 0::2] *= scale_x\n self.tensor[:, 1::2] *= scale_y","def scale(self, up):\n s = 1.1 if up else 0.9\n self.scaling_matrix = np.dot(\n self.scaling_matrix,\n F.scaling([s, s, s])\n )\n\n self.aabb.scale(s)","def rescale(data_matrix):\n means, stdevs = scale(data_matrix)\n\n def rescaled(i, j):\n if stdevs[j] > 0:\n return (data_matrix[i][j] - means[j]) / stdevs[j]\n else:\n return data_matrix[i][j]\n\n num_rows, num_cols = shape(data_matrix)\n return make_matrix(num_rows, num_cols, rescaled)","def scale(self):","def scale_data(X,m,s):\n \n n = X.shape\n if len(n) > 1:\n p = n[1]\n else:\n p = 1\n n = n[0]\n \n s = _handle_zeros_in_scale(s)\n \n if p == 1:\n Xm = X - float(m)\n Xs = Xm / s\n else:\n Xm = X - np.array([m for i in range(1,n+1)])\n Xs = Xm / np.array([s for i in range(1,n+1)])\n return(Xs)","def scale(c, scalar):\n return [c[0]*scalar, c[1]*scalar]","def scaling(sx,sy,Mat):\r\n # SM is the Scaling Matrix ( 3 X 3 )\r\n SM = [[sx,0,0],[0,sy,0],[0,0,1]]\r\n Scaled = Multiply(SM,Mat)\r\n # Scaled[0][0] is the updated x coordinate\r\n # Scaled[1][0] is the updated y coordinate\r\n return Scaled[0][0],Scaled[1][0],Scaled[2][0]","def matrixGrayScale(M, scale=255):\r\n M = M-np.min(M)*np.ones_like(M)\r\n M = M/np.max(M)*scale\r\n return M","def scale(f, a, j=0):\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))","def convert_scale(g, op, block):\n\n scale = op.attr(\"scale\")\n bias = op.attr(\"bias\")\n bias_after_scale = op.attr(\"bias_after_scale\")\n x = g.get_node(op.input(\"X\")[0])\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\n out = x\n else:\n if np.isclose(bias, 0.0):\n out = x * _expr.const(np.array(scale).astype(\"float32\"))\n elif np.isclose(scale, 1.0):\n out = x + _expr.const(np.array(bias).astype(\"float32\"))\n else:\n if bias_after_scale:\n out = x * _expr.const(np.array(scale).astype(\"float32\")) + _expr.const(\n np.array(bias).astype(\"float32\")\n )\n else:\n out = (x + _expr.const(np.array(bias).astype(\"float32\"))) * _expr.const(\n np.array(scale).astype(\"float32\")\n )\n g.add_node(op.output(\"Out\")[0], out)","def convert_scaling_to_form_factors(qz, scale):\n apply_absorption_correction(qz, scale)\n apply_Lorentz_correction(qz, scale)\n for i in xrange(len(scale)):\n scale[i] = np.sign(scale[i]) * math.sqrt(abs(scale[i]))","def __mul__(self, scale):\n return Vec(self.x * scale, self.y * scale)","def scale(self):\n return self._a","def ScalePoints(points, sigma = 0.02):\n assert(points.shape[1]==3)\n\n scale = np.random.uniform(1-sigma, 1+sigma)\n scale_matrix = np.array([[scale, 0, 0],\n [0, scale, 0],\n [0, 0, scale]])\n scaled = np.dot(points, scale_matrix)\n\n return scaled","def scale(X, *, axis=..., with_mean=..., with_std=..., copy=...):\n ...","def _call_scale(vecObj, sc):\n res = vecObj.scale(sc)\n return res","def scale(self, sx: float = 1, sy: float = 1, sz: float = 1,\n center: Onion[Iterable[Onion[float, int]], Point3D] = None) -> 'Component':\n scale = Matrix3D.create()\n translation = Matrix3D.create()\n if abs(sx) != abs(sy) or abs(sy) != abs(sz):\n raise ValueError(\"Non-uniform scaling is not currently supported\")\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 translation.translation = center_point.asVector()\n translation.invert()\n self._local_transform.transformBy(translation)\n\n scale.setCell(0, 0, sx)\n scale.setCell(1, 1, sy)\n scale.setCell(2, 2, sz)\n self._local_transform.transformBy(scale)\n\n translation.invert()\n self._local_transform.transformBy(translation)\n\n self._reset_cache()\n return self","def apply_scale( vertices, scale=1.0 ):\n checkVerticesValidity( vertices )\n if type(scale) != float:\n raise ValueError\n \n for i in range(len(vertices)):\n v = vertices[i]\n tmpv = [v[0]*scale, v[1]*scale, v[2]*scale]\n vertices[i] = tmpv","def transform(self, mat: TxMatrix) -> None:\n super().transform(mat)\n self.scale = self.scale * mat.scale","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def getMatrix(self, scale):\n \n kbx = np.sqrt(self.kbxn**2. + self.kbxSF**2.) # rms kbeta\n kby = np.sqrt(self.kbyn**2. + self.kbySF**2.) # rms kbeta\n\n kbx = kbx / scale.lg\n kby = kby / scale.lg\n \n matx = np.zeros([2,2])\n\n if (kbx > 0.):\n matx[0][0] = np.cos(kbx*self.undlen)\n matx[0][1] = 1. /kbx * np.sin(kbx*self.undlen)\n matx[1][0] = -kbx * np.sin(kbx*self.undlen)\n matx[1][1] = np.cos(kbx*self.undlen)\n else: # just a free space drift\n matx[0][0] = 1.\n matx[0][1] = self.undlen\n matx[1][0] = 0.\n matx[1][1] = 1.\n\n maty = np.zeros([2,2])\n\n if (kby > 0.):\n maty[0][0] = np.cos(kby*self.undlen)\n maty[0][1] = 1. /kby * np.sin(kby*self.undlen)\n maty[1][0] = -kby * np.sin(kby*self.undlen)\n maty[1][1] = np.cos(kby*self.undlen)\n else: # just a free space drift\n maty[0][0] = 1.\n maty[0][1] = self.undlen\n maty[1][0] = 0.\n maty[1][1] = 1.\n \n return matx, maty","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 scale(self, scale):\n\t\tself._current_score *= scale","def scale(self):\n return self._gev_bijector.scale","def __scale_bboxes(self, bboxes, scale_x, scale_y):\n with tf.variable_scope('scale_bboxes'):\n return tf.multiply(bboxes, tf.tile([[scale_y, scale_x, scale_y,\n scale_x]],\n [tf.shape(bboxes)[0], 1]))","def getScale(self):\n \n dag_node = OpenMaya.MFnDagNode(self.thisObj)\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\n \n util = OpenMaya.MScriptUtil()\n util.createFromDouble(0.0, 0.0, 0.0)\n pointeur = util.asDoublePtr()\n transform_node.getScale(pointeur)\n \n sx = util.getDoubleArrayItem(pointeur, 0)\n sy = util.getDoubleArrayItem(pointeur, 1)\n sz = util.getDoubleArrayItem(pointeur, 2)\n\n return sx, sy, sz","def scale(self, scale_factor: float) -> None:\n self.tensor[:, :3] *= scale_factor","def scale_rot_matrix(self, u, v):\n # signed angle old new vectors (rotation)\n a = self.signed_angle(u, v)\n # scale factor\n scale = v.length / u.length\n ca = scale * cos(a)\n sa = scale * sin(a)\n return scale, Matrix([\n [ca, -sa],\n [sa, ca]\n ])","def scaleMatrix( source=None ):\n if source is None:\n return None,None\n else:\n (x,y,z) = source[:3]\n if x == y == z == 1.0:\n return None, None\n forward = tmatrixaccel.scaleMatrix( x,y,z )\n backward = tmatrixaccel.scaleMatrix( 1.0/(x or VERY_SMALL),1.0/(y or VERY_SMALL), 1.0/(z or VERY_SMALL) )\n return forward, backward","def scale(self,s):\n return Vector(self.x * s, self.y * s, self.z * s)","def rescale(A, d1, d2):\n \n A[0, 1] = A[0, 1] * (d2 / d1)\n A[1, 0] = A[1, 0] * (d1 / d2)\n \n return A","def scale_image(self, pixels, size):\n x_min, x_max = np.amin(pixels[:,0]), np.amax(pixels[:,0])\n y_min, y_max = np.amin(pixels[:,1]), np.amax(pixels[:,1])\n z_min, z_max = np.amin(pixels[:,2]), np.amax(pixels[:,2])\n \n pixels[:,0] -= x_min \n pixels[:,1] -= y_min\n pixels[:,2] -= z_min\n \n x_max -= x_min\n y_max -= y_min\n z_max -= z_min\n \n scale_factor = size / max(x_max, y_max, z_max) \n # All points are now between [0..max]\n\n pixels *= scale_factor\n return pixels","def scale_operator(L, lmax, scale=1):\n I = sparse.identity(L.shape[0], format=L.format, dtype=L.dtype)\n L *= 2 * scale / lmax\n L -= I\n return L","def scale(m, scale = 1):\n try:\n scaleX = abs(scale[0])\n scaleY = abs(scale[1])\n except:\n scaleX = abs(scale)\n scaleY = abs(scale)\n resolution = (int(m.getWidth() * scaleX), int(m.getHeight() * scaleY))\n return createBySurface(pygame.transform.scale(m.toSurface(), resolution))","def scale(self):\n return self.distribution.scale","def scale(coord):\n scl = 0.07465 # scale (for 21zoom use 0.07465)\n for i in range(len(coord)):\n for j in range(len(coord[i])):\n coord[i][j][0], coord[i][j][1] = coord[i][j][0] * scl, coord[i][j][1] * scl\n return coord","def scale(self, alpha):\n\t\tc = SparseVector(self.d)\n\t\tfor i in self.st.keys():\n\t\t\tc.put(i, alpha*self.get(i))\n\t\treturn c","def scale(self, scale=1):\n self.x *= scale\n self.y *= scale\n self.width *= scale\n self.height *= scale\n\n # Always update the corners after operation\n self.update_corners()\n return","def _scale(x, axis=None):\n x = _remove_baseline(x, axis=axis)\n x /= np.std(x, ddof=1, axis=axis, keepdims=True)\n return x","def my_scale_sim_mat(w):\n rowsum = np.array(np.sum(w, axis=1), dtype=np.float32)\n r_inv = np.power(rowsum, -1).flatten()\n r_inv[np.isinf(r_inv)] = 0.\n r_mat_inv = sp.diags(r_inv)\n w = r_mat_inv.dot(w)\n return w","def scale(img, scale):\n return resize(img, x_scale=scale, y_scale=scale)","def scale(self, sx : float, sy : float, sz : float):\n answ = self.clone()\n for i in range(len(self._elements)):\n answ._elements[i]._element = self._elements[i].element.scale(sx, sy, sz)\n\n return answ","def scale(self, sx, sy):\n self._impl.scale(sx, sy)","def _scale(x):\n scaleFactor = 1\n _ret = int(x/scaleFactor)\n return _ret","def rescale(tx):\n mins = np.amin(tx, axis=0)\n maxs = np.amax(tx, axis=0)\n txscale = (tx - mins) / (maxs - mins)\n return txscale","def scale_it(val):\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])","def factor_to_scale(factor):\n return 1 / B.sqrt(4 * factor / B.pi)","def scale(img, scales):\n outputs = []\n for sc in scales:\n outputs.append(\n cv2.resize(img, None, fx=sc, fy=sc, interpolation=cv2.INTER_CUBIC)\n )\n return outputs","def get_scale():\r\n\r\n \r\n return 0.5","def cmdscale(D):\n # Number of points \n n = len(D)\n # Centering matrix \n H = np.eye(n) - np.ones((n, n))/n\n # YY^T \n B = -H.dot(D**2).dot(H)/2\n # Diagonalize \n evals, evecs = np.linalg.eigh(B)\n # Sort by eigenvalue in descending order \n idx = np.argsort(evals)[::-1]\n evals = evals[idx]\n evecs = evecs[:,idx]\n # Compute the coordinates using positive-eigenvalued components only \n w, = np.where(evals > 0)\n L = np.diag(np.sqrt(evals[w]))\n V = evecs[:,w]\n Y = V.dot(L)\n return Y, evals","def scale_vector(vector, scale):\n return vector[0] * scale, vector[1] * scale, vector[2] * scale","def ScaleRows(self, s):\n return _hypre.HypreParMatrix_ScaleRows(self, s)","def scale(self) -> Tuple[float, float]:\n return self._scale","def _linear_to_mel_scale(linear_scale_in, n_mel_bins, mel_lower_hertz_edge,\n mel_upper_hertz_edge):\n\n linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(\n n_mel_bins, linear_scale_in.shape[-1], _SAMPLE_RATE, mel_lower_hertz_edge,\n mel_upper_hertz_edge\n )\n\n mel_scale_out = tf.tensordot(linear_scale_in, linear_to_mel_weight_matrix, 1)\n return mel_scale_out","def scale_axes(self, scale, axes=None):\n axes = self._get_axes_numbers(axes)\n scale = self._cook_args(scale, axes, [1., 1.])\n return Signal2D(self.values, index=self.index*scale[0], columns=self.columns*scale[1])","def scaling():\n \n for i in range(cfg.nfea):\n dm = 0\n var = 0\n for j in range(cfg.ntrain):\n dm += cfg.a[j,i]\n dm = dm/cfg.ntrain\n \n for j in range(cfg.ntrain):\n var += (cfg.a[j,i]-dm)**2\n\n var = var/cfg.ntrain\n var = np.sqrt(var)\n \n if var >= 10**(-5):\n cfg.clin[i] = 1.0/var \n cfg.dlin[i] = -dm/var \n \n else: \n if np.abs(dm)<=1.0:\n cfg.clin[i] = 1.0\n cfg.dlin[i] = 0.0 \n else: \n cfg.clin[i] = 1.0/dm\n cfg.dlin[i] = 0.0 \n \n for j in range(cfg.ntrain):\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\n \n return","def scale(self) -> pulumi.Output[int]:\n return pulumi.get(self, \"scale\")","def scale(\n x: DataFrame,\n center: Union[bool, Iterable[NumericType]] = True,\n # pylint: disable=redefined-outer-name\n scale: Union[bool, Iterable[NumericType]] = True\n) -> DataFrame:\n # center\n ncols = x.shape[1]\n center_is_true = center is True\n out_attrs = {}\n\n if center is True:\n center = col_means(x)\n\n elif center is not False:\n if is_scalar(center):\n center = [center]\n if len(center) != ncols:\n raise ValueError(\n f\"length of `center` ({len(center)}) must equal \"\n f\"the number of columns of `x` ({ncols})\"\n )\n\n if center is not False:\n x = x - center\n out_attrs['scaled:center'] = Array(center)\n\n # scale\n if scale is True:\n def _rms(col: Series) -> Series:\n nonnas = col[is_not_null(col)] ** 2\n return sqrt(nonnas.sum() / (len(nonnas) - 1))\n\n scale = col_sds(x) if center_is_true else x.agg(_rms)\n\n elif scale is not False:\n if is_scalar(scale):\n scale = [scale]\n if len(scale) != ncols:\n raise ValueError(\n f\"length of `scale` ({len(center)}) must equal \"\n f\"the number of columns of `x` ({ncols})\"\n )\n\n if scale is not False:\n x = x / scale\n out_attrs['scaled:scale'] = Array(scale)\n\n if center is False and scale is False:\n x = x.copy()\n\n x.attrs.update(out_attrs)\n return x","def get_scale(self):\r\n try: return self.scale[0], self.scale[1], self.scale[2]\r\n except: return self.scale, self.scale, self.scale","def scale(x, p=2, inplace=False):\n return x / np.linalg.norm(x, ord=p)","def scale(self):\n return self._scale","def cmdscale(D):\n # Number of points\n n = len(D)\n\n # Centering matrix\n H = np.eye(n) - np.ones((n, n))/n\n\n # YY^T\n B = -H.dot(D**2).dot(H)/2\n\n # Diagonalize\n evals, evecs = np.linalg.eigh(B)\n\n # Sort by eigenvalue in descending order\n idx = np.argsort(evals)[::-1]\n evals = evals[idx]\n evecs = evecs[:, idx]\n\n # Compute the coordinates using positive-eigenvalued components only\n w, = np.where(evals > 0)\n L = np.diag(np.sqrt(evals[w]))\n V = evecs[:, w]\n Y = V.dot(L)\n\n return Y, evals[evals > 0]","def rescale_img(image: Matrix, scales: List[float]) -> List[Matrix]:\n rescaled_imgs = []\n for scale in scales:\n if scale == 1:\n rescaled_imgs.append(np.copy(image))\n else:\n rescaled_imgs.append(rescale(image, scale))\n return rescaled_imgs","def scale_matrix(self, matrix_df):\n\n print('scaling features...')\n\n originalkeys = matrix_df[['segment_id','date','time']].reset_index()\n originalkeys['index'] = originalkeys.index\n\n columns = list(matrix_df)\n columns.remove('segment_id')\n columns.remove('date')\n columns.remove('time')\n data_to_scale = matrix_df[columns]\n matrix_df_scaled_tmp = pd.DataFrame(preprocessing.scale(data_to_scale), columns = columns).reset_index()\n matrix_df_scaled_tmp['index']=matrix_df_scaled_tmp.index\n\n matrix_df_scaled_labels_tmp = pd.merge(matrix_df_scaled_tmp, originalkeys, on=['index'])\n matrix_df_scaled = matrix_df_scaled_tmp.drop(columns=['index'])\n matrix_df_scaled_withlabels = matrix_df_scaled_labels_tmp.drop(columns=['index'])\n \n return matrix_df_scaled_withlabels","def scale(self, sc):\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\n return self","def scale(self) -> pulumi.Input[int]:\n return pulumi.get(self, \"scale\")","def test_axiswise_scale():\n\n s = ConstantVariable(np.random.rand(3), OrderC)\n x = Variable((2, 3, 4, 5), OrderNCHW)\n\n y, = AxiswiseScale(None, axis=Axis.C)(x, s)\n\n assert isinstance(y.output_from, AxiswiseScale)\n\n UpgradeOperatorType().optimize(Graph([x], [y]))\n\n assert isinstance(y.output_from, ElementwiseMul)","def scale(self, scale):\n self.coords = self.coords * scale\n return self","def scale(self, const):\n return Vector(*[self[i]*const for i in range(len(self))])","def get_scale(self):\n\n scales = []\n for i in range(len(self.train_series)):\n series = self.train_series.iloc[i].values\n series = series[np.argmax(series != 0):]\n scale = ((series[1:] - series[:-1]) ** 2).mean()\n scales.append(scale)\n\n return np.array(scales)","def scale(self,n,d=1):\r\n\t\t\r\n\t\t# scale all terms\r\n\t\ts = [i.scale(n,d) for i in self]\r\n\t\t\r\n\t\treturn Li(s)","def b_scale_object():\n \n bpy.ops.transform.resize(value=(7.5,1,1), constraint_axis=(True,False,False))\n bpy.ops.transform.resize(value=(1,7.5,1), constraint_axis=(False,True,False))\n bpy.ops.transform.resize(value=(1,1,3.5), constraint_axis=(False,False,True))\n bpy.ops.object.transform_apply(scale=True)","def scale(self, factors):\n if isinstance(factors, numbers.Number):\n factors = np.ones(self.dim) * factors;\n self.raw_wires.scale(factors);","def scale4(a,c):\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]","def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))","def _scale_pads(\n pads: tuple[float, float, float, float], scale: float\n) -> tuple[float, float, float, float]:\n top, right, bottom, left = pads\n return top * scale, right * scale, bottom * scale, left * scale","def _multi_scale_ssim(x: torch.Tensor, y: torch.Tensor, data_range: Union[int, float], kernel: torch.Tensor,\n scale_weights: torch.Tensor, k1: float, k2: float) -> torch.Tensor:\n levels = scale_weights.size(0)\n min_size = (kernel.size(-1) - 1) * 2 ** (levels - 1) + 1\n if x.size(-1) < min_size or x.size(-2) < min_size:\n raise ValueError(f'Invalid size of the input images, expected at least {min_size}x{min_size}.')\n\n mcs = []\n ssim_val = None\n for iteration in range(levels):\n if iteration > 0:\n padding = max(x.shape[2] % 2, x.shape[3] % 2)\n x = F.pad(x, pad=[padding, 0, padding, 0], mode='replicate')\n y = F.pad(y, pad=[padding, 0, padding, 0], mode='replicate')\n x = F.avg_pool2d(x, kernel_size=2, padding=0)\n y = F.avg_pool2d(y, kernel_size=2, padding=0)\n\n ssim_val, cs = _ssim_per_channel(x, y, kernel=kernel, data_range=data_range, k1=k1, k2=k2)\n mcs.append(cs)\n\n # mcs, (level, batch)\n mcs_ssim = torch.relu(torch.stack(mcs[:-1] + [ssim_val], dim=0))\n\n # weights, (level)\n msssim_val = torch.prod((mcs_ssim ** scale_weights.view(-1, 1, 1)), dim=0).mean(1)\n\n return msssim_val","def scale(self,bvp):\n\n sol = bvp.solution\n # Additional aux entries for initial and terminal BCs\n extras = [{'type':'initial','vars':self.problem_data['state_list']},\n {'type':'terminal','vars':self.problem_data['state_list']}]\n\n # Scale the states and costates\n for idx,state in enumerate(self.problem_data['state_list']):\n sol.y[idx,:] /= self.scale_vals['states'][state]\n\n # Scale auxiliary variables\n for aux in (self.problem_data['aux_list']+extras):\n if aux['type'] not in Scaling.excluded_aux:\n for var in aux['vars']:\n sol.aux[aux['type']][var] /= self.scale_vals[aux['type']][var]\n\n # Scale parameters\n for idx, param in enumerate(self.problem_data['parameter_list']):\n sol.parameters[idx] /= self.scale_vals['parameters'][param]","def scale(val, src, dst):\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]","def scale(self, s):\n for n in range(len(self.mV)):\n self.mV[n] *= s\n return self"],"string":"[\n \"def scaleMatrix(self, sx=0, sy=0, sz=0):\\n\\n return np.array([[sx, 0, 0, 0],\\n [0, sy, 0, 0],\\n [0, 0, sz, 0],\\n [0, 0, 0, 1]])\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)\",\n \"def matScale(mat, scale):\\n shape=matShape(mat)\\n return [[matGet(mat,x,y)*scale for y in range(shape[1])] \\\\\\n for x in range(shape[0])]\",\n \"def scaling_matrix(sx, sy, sz):\\n S = np.array([[sx, 0, 0, 0],\\n [0, sy, 0, 0],\\n [0, 0, sz, 0],\\n [0, 0, 0, 1]])\\n return S\",\n \"def scale(matrix, s):\\n x, y = matrix.shape\\n print(matrix.shape)\\n\\n print(np.ones(matrix.shape))\\n # b = np.ones(x, y)\\n # print(\\\"ones:\\\", b)\\n return np.kron(a, np.ones((x, y)))\",\n \"def scale_matrix(N):\\n return N * np.identity(2)\",\n \"def apply_scale( vectors, scale ):\\n # create a scaling matrix\\n matrix = numpy.array([\\n [ scale[ 0 ], 0.0, 0.0 ],\\n [ 0.0, scale[ 1 ], 0.0 ],\\n [ 0.0, 0.0, scale[ 2 ] ]\\n ])\\n return numpy.dot( vectors, matrix )\",\n \"def scale_columns(matrix, scales):\\n return np.einsum(\\\"ij,j->ij\\\", matrix, scales)\",\n \"def scaling(mat, factor):\\n\\treturn mat / (mat + factor)\",\n \"def row_scale(x, s):\\r\\n return col_scale(x.T, s).T\",\n \"def getScalingMatrix(sx, sy, sz):\\n return MatrixExtended([\\n [sx, 0, 0, 0],\\n [0, sy, 0, 0],\\n [0, 0, sz, 0],\\n [0, 0, 0, 1]])\",\n \"def scale(self, scale):\\n \\n scale_matrix = wf.scaleMatrix(scale, self.width/2, self.height/2, 0)\\n self.transform(scale_matrix)\",\n \"def col_scale(x, s):\\r\\n\\r\\n if x.format == 'csc':\\r\\n return ColScaleCSC()(x, s)\\r\\n elif x.format == 'csr':\\r\\n return RowScaleCSC()(x.T, s).T\\r\\n else:\\r\\n raise NotImplementedError()\",\n \"def scale_matrix(matrix, k):\\n new_matrix = []\\n for v in range(NUMBER_VECTORS):\\n new_matrix.append(matrix[v].scale(k))\\n return new_matrix\",\n \"def scale_matrix(scaler, M):\\n # Section 1: Make a copy of the given matrix\\n new = copy_matrix(M)\\n rows = len(new); cols = len(new[0])\\n\\n # Section 2: Scale each element of the copied matrix\\n for i in range(rows):\\n for j in range(cols):\\n new[i][j] = new[i][j] * scaler\\n\\n return new\",\n \"def scaleAll(self, scale):\\n center = [self.width/2, self.height/2, 0, 0]\\n matrix = self.scaleMatrix(scale, scale, scale)\\n\\n for wireframe in self.wireframes.values():\\n wireframe.scale(center, matrix)\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\",\n \"def scale(inp, ab):\\n\\n return inp * ab[0] + ab[1]\\n # pass\",\n \"def homog_scale_mtx(scale: float) -> numpy.array:\\n return numpy.array(\\n [[scale, 0, 0, 0], [0, scale, 0, 0], [0, 0, scale, 0], [0, 0, 0, 1]],\\n dtype=numpy.float64,\\n )\",\n \"def _scale(self, normalize, mat):\\n mat = mat.astype(float)\\n if normalize:\\n mat = sklearn_norm(mat,\\n feature_range=(0, 1),\\n axis=0,\\n copy=True)\\n else:\\n return mat\\n return mat\",\n \"def extractScale(self,groups):\\n self.scaleX = float(groups[0])\\n self.scaleY = float(groups[0])\\n if len(groups) == 2 and groups[1]:\\n self.scaleY = float(groups[1])\\n self.matrix = [[self.scaleX, 0.0, 0.0], \\\\\\n [0.0, self.scaleY, 0.0]]\",\n \"def scale(self, scale_x: float, scale_y: float) -> None:\\n self.tensor[:, 0::2] *= scale_x\\n self.tensor[:, 1::2] *= scale_y\",\n \"def scale(self, up):\\n s = 1.1 if up else 0.9\\n self.scaling_matrix = np.dot(\\n self.scaling_matrix,\\n F.scaling([s, s, s])\\n )\\n\\n self.aabb.scale(s)\",\n \"def rescale(data_matrix):\\n means, stdevs = scale(data_matrix)\\n\\n def rescaled(i, j):\\n if stdevs[j] > 0:\\n return (data_matrix[i][j] - means[j]) / stdevs[j]\\n else:\\n return data_matrix[i][j]\\n\\n num_rows, num_cols = shape(data_matrix)\\n return make_matrix(num_rows, num_cols, rescaled)\",\n \"def scale(self):\",\n \"def scale_data(X,m,s):\\n \\n n = X.shape\\n if len(n) > 1:\\n p = n[1]\\n else:\\n p = 1\\n n = n[0]\\n \\n s = _handle_zeros_in_scale(s)\\n \\n if p == 1:\\n Xm = X - float(m)\\n Xs = Xm / s\\n else:\\n Xm = X - np.array([m for i in range(1,n+1)])\\n Xs = Xm / np.array([s for i in range(1,n+1)])\\n return(Xs)\",\n \"def scale(c, scalar):\\n return [c[0]*scalar, c[1]*scalar]\",\n \"def scaling(sx,sy,Mat):\\r\\n # SM is the Scaling Matrix ( 3 X 3 )\\r\\n SM = [[sx,0,0],[0,sy,0],[0,0,1]]\\r\\n Scaled = Multiply(SM,Mat)\\r\\n # Scaled[0][0] is the updated x coordinate\\r\\n # Scaled[1][0] is the updated y coordinate\\r\\n return Scaled[0][0],Scaled[1][0],Scaled[2][0]\",\n \"def matrixGrayScale(M, scale=255):\\r\\n M = M-np.min(M)*np.ones_like(M)\\r\\n M = M/np.max(M)*scale\\r\\n return M\",\n \"def scale(f, a, j=0):\\n return f.per(dmp_scale_in(f.rep, f.dom.convert(a), j, f.lev, f.dom))\",\n \"def convert_scale(g, op, block):\\n\\n scale = op.attr(\\\"scale\\\")\\n bias = op.attr(\\\"bias\\\")\\n bias_after_scale = op.attr(\\\"bias_after_scale\\\")\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\\n out = x\\n else:\\n if np.isclose(bias, 0.0):\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\"))\\n elif np.isclose(scale, 1.0):\\n out = x + _expr.const(np.array(bias).astype(\\\"float32\\\"))\\n else:\\n if bias_after_scale:\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\")) + _expr.const(\\n np.array(bias).astype(\\\"float32\\\")\\n )\\n else:\\n out = (x + _expr.const(np.array(bias).astype(\\\"float32\\\"))) * _expr.const(\\n np.array(scale).astype(\\\"float32\\\")\\n )\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def convert_scaling_to_form_factors(qz, scale):\\n apply_absorption_correction(qz, scale)\\n apply_Lorentz_correction(qz, scale)\\n for i in xrange(len(scale)):\\n scale[i] = np.sign(scale[i]) * math.sqrt(abs(scale[i]))\",\n \"def __mul__(self, scale):\\n return Vec(self.x * scale, self.y * scale)\",\n \"def scale(self):\\n return self._a\",\n \"def ScalePoints(points, sigma = 0.02):\\n assert(points.shape[1]==3)\\n\\n scale = np.random.uniform(1-sigma, 1+sigma)\\n scale_matrix = np.array([[scale, 0, 0],\\n [0, scale, 0],\\n [0, 0, scale]])\\n scaled = np.dot(points, scale_matrix)\\n\\n return scaled\",\n \"def scale(X, *, axis=..., with_mean=..., with_std=..., copy=...):\\n ...\",\n \"def _call_scale(vecObj, sc):\\n res = vecObj.scale(sc)\\n return res\",\n \"def scale(self, sx: float = 1, sy: float = 1, sz: float = 1,\\n center: Onion[Iterable[Onion[float, int]], Point3D] = None) -> 'Component':\\n scale = Matrix3D.create()\\n translation = Matrix3D.create()\\n if abs(sx) != abs(sy) or abs(sy) != abs(sz):\\n raise ValueError(\\\"Non-uniform scaling is not currently supported\\\")\\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 translation.translation = center_point.asVector()\\n translation.invert()\\n self._local_transform.transformBy(translation)\\n\\n scale.setCell(0, 0, sx)\\n scale.setCell(1, 1, sy)\\n scale.setCell(2, 2, sz)\\n self._local_transform.transformBy(scale)\\n\\n translation.invert()\\n self._local_transform.transformBy(translation)\\n\\n self._reset_cache()\\n return self\",\n \"def apply_scale( vertices, scale=1.0 ):\\n checkVerticesValidity( vertices )\\n if type(scale) != float:\\n raise ValueError\\n \\n for i in range(len(vertices)):\\n v = vertices[i]\\n tmpv = [v[0]*scale, v[1]*scale, v[2]*scale]\\n vertices[i] = tmpv\",\n \"def transform(self, mat: TxMatrix) -> None:\\n super().transform(mat)\\n self.scale = self.scale * mat.scale\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def getMatrix(self, scale):\\n \\n kbx = np.sqrt(self.kbxn**2. + self.kbxSF**2.) # rms kbeta\\n kby = np.sqrt(self.kbyn**2. + self.kbySF**2.) # rms kbeta\\n\\n kbx = kbx / scale.lg\\n kby = kby / scale.lg\\n \\n matx = np.zeros([2,2])\\n\\n if (kbx > 0.):\\n matx[0][0] = np.cos(kbx*self.undlen)\\n matx[0][1] = 1. /kbx * np.sin(kbx*self.undlen)\\n matx[1][0] = -kbx * np.sin(kbx*self.undlen)\\n matx[1][1] = np.cos(kbx*self.undlen)\\n else: # just a free space drift\\n matx[0][0] = 1.\\n matx[0][1] = self.undlen\\n matx[1][0] = 0.\\n matx[1][1] = 1.\\n\\n maty = np.zeros([2,2])\\n\\n if (kby > 0.):\\n maty[0][0] = np.cos(kby*self.undlen)\\n maty[0][1] = 1. /kby * np.sin(kby*self.undlen)\\n maty[1][0] = -kby * np.sin(kby*self.undlen)\\n maty[1][1] = np.cos(kby*self.undlen)\\n else: # just a free space drift\\n maty[0][0] = 1.\\n maty[0][1] = self.undlen\\n maty[1][0] = 0.\\n maty[1][1] = 1.\\n \\n return matx, maty\",\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 scale(self, scale):\\n\\t\\tself._current_score *= scale\",\n \"def scale(self):\\n return self._gev_bijector.scale\",\n \"def __scale_bboxes(self, bboxes, scale_x, scale_y):\\n with tf.variable_scope('scale_bboxes'):\\n return tf.multiply(bboxes, tf.tile([[scale_y, scale_x, scale_y,\\n scale_x]],\\n [tf.shape(bboxes)[0], 1]))\",\n \"def getScale(self):\\n \\n dag_node = OpenMaya.MFnDagNode(self.thisObj)\\n transform_node = OpenMaya.MFnTransform(dag_node.parent( 0 ))\\n \\n util = OpenMaya.MScriptUtil()\\n util.createFromDouble(0.0, 0.0, 0.0)\\n pointeur = util.asDoublePtr()\\n transform_node.getScale(pointeur)\\n \\n sx = util.getDoubleArrayItem(pointeur, 0)\\n sy = util.getDoubleArrayItem(pointeur, 1)\\n sz = util.getDoubleArrayItem(pointeur, 2)\\n\\n return sx, sy, sz\",\n \"def scale(self, scale_factor: float) -> None:\\n self.tensor[:, :3] *= scale_factor\",\n \"def scale_rot_matrix(self, u, v):\\n # signed angle old new vectors (rotation)\\n a = self.signed_angle(u, v)\\n # scale factor\\n scale = v.length / u.length\\n ca = scale * cos(a)\\n sa = scale * sin(a)\\n return scale, Matrix([\\n [ca, -sa],\\n [sa, ca]\\n ])\",\n \"def scaleMatrix( source=None ):\\n if source is None:\\n return None,None\\n else:\\n (x,y,z) = source[:3]\\n if x == y == z == 1.0:\\n return None, None\\n forward = tmatrixaccel.scaleMatrix( x,y,z )\\n backward = tmatrixaccel.scaleMatrix( 1.0/(x or VERY_SMALL),1.0/(y or VERY_SMALL), 1.0/(z or VERY_SMALL) )\\n return forward, backward\",\n \"def scale(self,s):\\n return Vector(self.x * s, self.y * s, self.z * s)\",\n \"def rescale(A, d1, d2):\\n \\n A[0, 1] = A[0, 1] * (d2 / d1)\\n A[1, 0] = A[1, 0] * (d1 / d2)\\n \\n return A\",\n \"def scale_image(self, pixels, size):\\n x_min, x_max = np.amin(pixels[:,0]), np.amax(pixels[:,0])\\n y_min, y_max = np.amin(pixels[:,1]), np.amax(pixels[:,1])\\n z_min, z_max = np.amin(pixels[:,2]), np.amax(pixels[:,2])\\n \\n pixels[:,0] -= x_min \\n pixels[:,1] -= y_min\\n pixels[:,2] -= z_min\\n \\n x_max -= x_min\\n y_max -= y_min\\n z_max -= z_min\\n \\n scale_factor = size / max(x_max, y_max, z_max) \\n # All points are now between [0..max]\\n\\n pixels *= scale_factor\\n return pixels\",\n \"def scale_operator(L, lmax, scale=1):\\n I = sparse.identity(L.shape[0], format=L.format, dtype=L.dtype)\\n L *= 2 * scale / lmax\\n L -= I\\n return L\",\n \"def scale(m, scale = 1):\\n try:\\n scaleX = abs(scale[0])\\n scaleY = abs(scale[1])\\n except:\\n scaleX = abs(scale)\\n scaleY = abs(scale)\\n resolution = (int(m.getWidth() * scaleX), int(m.getHeight() * scaleY))\\n return createBySurface(pygame.transform.scale(m.toSurface(), resolution))\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def scale(coord):\\n scl = 0.07465 # scale (for 21zoom use 0.07465)\\n for i in range(len(coord)):\\n for j in range(len(coord[i])):\\n coord[i][j][0], coord[i][j][1] = coord[i][j][0] * scl, coord[i][j][1] * scl\\n return coord\",\n \"def scale(self, alpha):\\n\\t\\tc = SparseVector(self.d)\\n\\t\\tfor i in self.st.keys():\\n\\t\\t\\tc.put(i, alpha*self.get(i))\\n\\t\\treturn c\",\n \"def scale(self, scale=1):\\n self.x *= scale\\n self.y *= scale\\n self.width *= scale\\n self.height *= scale\\n\\n # Always update the corners after operation\\n self.update_corners()\\n return\",\n \"def _scale(x, axis=None):\\n x = _remove_baseline(x, axis=axis)\\n x /= np.std(x, ddof=1, axis=axis, keepdims=True)\\n return x\",\n \"def my_scale_sim_mat(w):\\n rowsum = np.array(np.sum(w, axis=1), dtype=np.float32)\\n r_inv = np.power(rowsum, -1).flatten()\\n r_inv[np.isinf(r_inv)] = 0.\\n r_mat_inv = sp.diags(r_inv)\\n w = r_mat_inv.dot(w)\\n return w\",\n \"def scale(img, scale):\\n return resize(img, x_scale=scale, y_scale=scale)\",\n \"def scale(self, sx : float, sy : float, sz : float):\\n answ = self.clone()\\n for i in range(len(self._elements)):\\n answ._elements[i]._element = self._elements[i].element.scale(sx, sy, sz)\\n\\n return answ\",\n \"def scale(self, sx, sy):\\n self._impl.scale(sx, sy)\",\n \"def _scale(x):\\n scaleFactor = 1\\n _ret = int(x/scaleFactor)\\n return _ret\",\n \"def rescale(tx):\\n mins = np.amin(tx, axis=0)\\n maxs = np.amax(tx, axis=0)\\n txscale = (tx - mins) / (maxs - mins)\\n return txscale\",\n \"def scale_it(val):\\n return scale(val, 0, 1, bpm_range[0], bpm_range[1])\",\n \"def factor_to_scale(factor):\\n return 1 / B.sqrt(4 * factor / B.pi)\",\n \"def scale(img, scales):\\n outputs = []\\n for sc in scales:\\n outputs.append(\\n cv2.resize(img, None, fx=sc, fy=sc, interpolation=cv2.INTER_CUBIC)\\n )\\n return outputs\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def cmdscale(D):\\n # Number of points \\n n = len(D)\\n # Centering matrix \\n H = np.eye(n) - np.ones((n, n))/n\\n # YY^T \\n B = -H.dot(D**2).dot(H)/2\\n # Diagonalize \\n evals, evecs = np.linalg.eigh(B)\\n # Sort by eigenvalue in descending order \\n idx = np.argsort(evals)[::-1]\\n evals = evals[idx]\\n evecs = evecs[:,idx]\\n # Compute the coordinates using positive-eigenvalued components only \\n w, = np.where(evals > 0)\\n L = np.diag(np.sqrt(evals[w]))\\n V = evecs[:,w]\\n Y = V.dot(L)\\n return Y, evals\",\n \"def scale_vector(vector, scale):\\n return vector[0] * scale, vector[1] * scale, vector[2] * scale\",\n \"def ScaleRows(self, s):\\n return _hypre.HypreParMatrix_ScaleRows(self, s)\",\n \"def scale(self) -> Tuple[float, float]:\\n return self._scale\",\n \"def _linear_to_mel_scale(linear_scale_in, n_mel_bins, mel_lower_hertz_edge,\\n mel_upper_hertz_edge):\\n\\n linear_to_mel_weight_matrix = tf.signal.linear_to_mel_weight_matrix(\\n n_mel_bins, linear_scale_in.shape[-1], _SAMPLE_RATE, mel_lower_hertz_edge,\\n mel_upper_hertz_edge\\n )\\n\\n mel_scale_out = tf.tensordot(linear_scale_in, linear_to_mel_weight_matrix, 1)\\n return mel_scale_out\",\n \"def scale_axes(self, scale, axes=None):\\n axes = self._get_axes_numbers(axes)\\n scale = self._cook_args(scale, axes, [1., 1.])\\n return Signal2D(self.values, index=self.index*scale[0], columns=self.columns*scale[1])\",\n \"def scaling():\\n \\n for i in range(cfg.nfea):\\n dm = 0\\n var = 0\\n for j in range(cfg.ntrain):\\n dm += cfg.a[j,i]\\n dm = dm/cfg.ntrain\\n \\n for j in range(cfg.ntrain):\\n var += (cfg.a[j,i]-dm)**2\\n\\n var = var/cfg.ntrain\\n var = np.sqrt(var)\\n \\n if var >= 10**(-5):\\n cfg.clin[i] = 1.0/var \\n cfg.dlin[i] = -dm/var \\n \\n else: \\n if np.abs(dm)<=1.0:\\n cfg.clin[i] = 1.0\\n cfg.dlin[i] = 0.0 \\n else: \\n cfg.clin[i] = 1.0/dm\\n cfg.dlin[i] = 0.0 \\n \\n for j in range(cfg.ntrain):\\n cfg.a_scaled[j,i] = cfg.clin[i]*cfg.a[j,i] + cfg.dlin[i]\\n \\n return\",\n \"def scale(self) -> pulumi.Output[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def scale(\\n x: DataFrame,\\n center: Union[bool, Iterable[NumericType]] = True,\\n # pylint: disable=redefined-outer-name\\n scale: Union[bool, Iterable[NumericType]] = True\\n) -> DataFrame:\\n # center\\n ncols = x.shape[1]\\n center_is_true = center is True\\n out_attrs = {}\\n\\n if center is True:\\n center = col_means(x)\\n\\n elif center is not False:\\n if is_scalar(center):\\n center = [center]\\n if len(center) != ncols:\\n raise ValueError(\\n f\\\"length of `center` ({len(center)}) must equal \\\"\\n f\\\"the number of columns of `x` ({ncols})\\\"\\n )\\n\\n if center is not False:\\n x = x - center\\n out_attrs['scaled:center'] = Array(center)\\n\\n # scale\\n if scale is True:\\n def _rms(col: Series) -> Series:\\n nonnas = col[is_not_null(col)] ** 2\\n return sqrt(nonnas.sum() / (len(nonnas) - 1))\\n\\n scale = col_sds(x) if center_is_true else x.agg(_rms)\\n\\n elif scale is not False:\\n if is_scalar(scale):\\n scale = [scale]\\n if len(scale) != ncols:\\n raise ValueError(\\n f\\\"length of `scale` ({len(center)}) must equal \\\"\\n f\\\"the number of columns of `x` ({ncols})\\\"\\n )\\n\\n if scale is not False:\\n x = x / scale\\n out_attrs['scaled:scale'] = Array(scale)\\n\\n if center is False and scale is False:\\n x = x.copy()\\n\\n x.attrs.update(out_attrs)\\n return x\",\n \"def get_scale(self):\\r\\n try: return self.scale[0], self.scale[1], self.scale[2]\\r\\n except: return self.scale, self.scale, self.scale\",\n \"def scale(x, p=2, inplace=False):\\n return x / np.linalg.norm(x, ord=p)\",\n \"def scale(self):\\n return self._scale\",\n \"def cmdscale(D):\\n # Number of points\\n n = len(D)\\n\\n # Centering matrix\\n H = np.eye(n) - np.ones((n, n))/n\\n\\n # YY^T\\n B = -H.dot(D**2).dot(H)/2\\n\\n # Diagonalize\\n evals, evecs = np.linalg.eigh(B)\\n\\n # Sort by eigenvalue in descending order\\n idx = np.argsort(evals)[::-1]\\n evals = evals[idx]\\n evecs = evecs[:, idx]\\n\\n # Compute the coordinates using positive-eigenvalued components only\\n w, = np.where(evals > 0)\\n L = np.diag(np.sqrt(evals[w]))\\n V = evecs[:, w]\\n Y = V.dot(L)\\n\\n return Y, evals[evals > 0]\",\n \"def rescale_img(image: Matrix, scales: List[float]) -> List[Matrix]:\\n rescaled_imgs = []\\n for scale in scales:\\n if scale == 1:\\n rescaled_imgs.append(np.copy(image))\\n else:\\n rescaled_imgs.append(rescale(image, scale))\\n return rescaled_imgs\",\n \"def scale_matrix(self, matrix_df):\\n\\n print('scaling features...')\\n\\n originalkeys = matrix_df[['segment_id','date','time']].reset_index()\\n originalkeys['index'] = originalkeys.index\\n\\n columns = list(matrix_df)\\n columns.remove('segment_id')\\n columns.remove('date')\\n columns.remove('time')\\n data_to_scale = matrix_df[columns]\\n matrix_df_scaled_tmp = pd.DataFrame(preprocessing.scale(data_to_scale), columns = columns).reset_index()\\n matrix_df_scaled_tmp['index']=matrix_df_scaled_tmp.index\\n\\n matrix_df_scaled_labels_tmp = pd.merge(matrix_df_scaled_tmp, originalkeys, on=['index'])\\n matrix_df_scaled = matrix_df_scaled_tmp.drop(columns=['index'])\\n matrix_df_scaled_withlabels = matrix_df_scaled_labels_tmp.drop(columns=['index'])\\n \\n return matrix_df_scaled_withlabels\",\n \"def scale(self, sc):\\n daskD.wait(self.client.map(_call_scale, self.vecDask, sc=sc, pure=False))\\n return self\",\n \"def scale(self) -> pulumi.Input[int]:\\n return pulumi.get(self, \\\"scale\\\")\",\n \"def test_axiswise_scale():\\n\\n s = ConstantVariable(np.random.rand(3), OrderC)\\n x = Variable((2, 3, 4, 5), OrderNCHW)\\n\\n y, = AxiswiseScale(None, axis=Axis.C)(x, s)\\n\\n assert isinstance(y.output_from, AxiswiseScale)\\n\\n UpgradeOperatorType().optimize(Graph([x], [y]))\\n\\n assert isinstance(y.output_from, ElementwiseMul)\",\n \"def scale(self, scale):\\n self.coords = self.coords * scale\\n return self\",\n \"def scale(self, const):\\n return Vector(*[self[i]*const for i in range(len(self))])\",\n \"def get_scale(self):\\n\\n scales = []\\n for i in range(len(self.train_series)):\\n series = self.train_series.iloc[i].values\\n series = series[np.argmax(series != 0):]\\n scale = ((series[1:] - series[:-1]) ** 2).mean()\\n scales.append(scale)\\n\\n return np.array(scales)\",\n \"def scale(self,n,d=1):\\r\\n\\t\\t\\r\\n\\t\\t# scale all terms\\r\\n\\t\\ts = [i.scale(n,d) for i in self]\\r\\n\\t\\t\\r\\n\\t\\treturn Li(s)\",\n \"def b_scale_object():\\n \\n bpy.ops.transform.resize(value=(7.5,1,1), constraint_axis=(True,False,False))\\n bpy.ops.transform.resize(value=(1,7.5,1), constraint_axis=(False,True,False))\\n bpy.ops.transform.resize(value=(1,1,3.5), constraint_axis=(False,False,True))\\n bpy.ops.object.transform_apply(scale=True)\",\n \"def scale(self, factors):\\n if isinstance(factors, numbers.Number):\\n factors = np.ones(self.dim) * factors;\\n self.raw_wires.scale(factors);\",\n \"def scale4(a,c):\\n return [a[0]*c,a[1]*c,a[2]*c,a[3]*c]\",\n \"def scale(input):\\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))\",\n \"def _scale_pads(\\n pads: tuple[float, float, float, float], scale: float\\n) -> tuple[float, float, float, float]:\\n top, right, bottom, left = pads\\n return top * scale, right * scale, bottom * scale, left * scale\",\n \"def _multi_scale_ssim(x: torch.Tensor, y: torch.Tensor, data_range: Union[int, float], kernel: torch.Tensor,\\n scale_weights: torch.Tensor, k1: float, k2: float) -> torch.Tensor:\\n levels = scale_weights.size(0)\\n min_size = (kernel.size(-1) - 1) * 2 ** (levels - 1) + 1\\n if x.size(-1) < min_size or x.size(-2) < min_size:\\n raise ValueError(f'Invalid size of the input images, expected at least {min_size}x{min_size}.')\\n\\n mcs = []\\n ssim_val = None\\n for iteration in range(levels):\\n if iteration > 0:\\n padding = max(x.shape[2] % 2, x.shape[3] % 2)\\n x = F.pad(x, pad=[padding, 0, padding, 0], mode='replicate')\\n y = F.pad(y, pad=[padding, 0, padding, 0], mode='replicate')\\n x = F.avg_pool2d(x, kernel_size=2, padding=0)\\n y = F.avg_pool2d(y, kernel_size=2, padding=0)\\n\\n ssim_val, cs = _ssim_per_channel(x, y, kernel=kernel, data_range=data_range, k1=k1, k2=k2)\\n mcs.append(cs)\\n\\n # mcs, (level, batch)\\n mcs_ssim = torch.relu(torch.stack(mcs[:-1] + [ssim_val], dim=0))\\n\\n # weights, (level)\\n msssim_val = torch.prod((mcs_ssim ** scale_weights.view(-1, 1, 1)), dim=0).mean(1)\\n\\n return msssim_val\",\n \"def scale(self,bvp):\\n\\n sol = bvp.solution\\n # Additional aux entries for initial and terminal BCs\\n extras = [{'type':'initial','vars':self.problem_data['state_list']},\\n {'type':'terminal','vars':self.problem_data['state_list']}]\\n\\n # Scale the states and costates\\n for idx,state in enumerate(self.problem_data['state_list']):\\n sol.y[idx,:] /= self.scale_vals['states'][state]\\n\\n # Scale auxiliary variables\\n for aux in (self.problem_data['aux_list']+extras):\\n if aux['type'] not in Scaling.excluded_aux:\\n for var in aux['vars']:\\n sol.aux[aux['type']][var] /= self.scale_vals[aux['type']][var]\\n\\n # Scale parameters\\n for idx, param in enumerate(self.problem_data['parameter_list']):\\n sol.parameters[idx] /= self.scale_vals['parameters'][param]\",\n \"def scale(val, src, dst):\\n return ((val - src[0]) / (src[1] - src[0])) * (dst[1] - dst[0]) + dst[0]\",\n \"def scale(self, s):\\n for n in range(len(self.mV)):\\n self.mV[n] *= s\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7577946","0.7523797","0.74303293","0.7282001","0.7124156","0.7081991","0.70752174","0.7051836","0.69150233","0.6839642","0.6801334","0.6769318","0.6742835","0.66912425","0.6654237","0.6651771","0.65922874","0.64853823","0.64189833","0.6410784","0.6398859","0.637518","0.6288902","0.6256263","0.6226565","0.6205438","0.6201334","0.61942977","0.6175079","0.6173684","0.6171845","0.61672145","0.6165712","0.6158807","0.6154485","0.61404866","0.61243224","0.6101308","0.6097647","0.6078823","0.607028","0.606447","0.6058227","0.6052483","0.60492885","0.60299313","0.6010371","0.60062444","0.6001594","0.59893316","0.5983745","0.5977468","0.5974122","0.59596765","0.5940964","0.5939014","0.59338105","0.59252316","0.5920663","0.5918512","0.59150815","0.5912212","0.59083205","0.58964616","0.5863887","0.5861737","0.58531094","0.58515054","0.58414483","0.58406353","0.5831956","0.5822252","0.58190906","0.58161336","0.581448","0.5802265","0.57966673","0.5792917","0.57769275","0.5773239","0.57727504","0.5751328","0.57444525","0.5738972","0.5736892","0.5733436","0.57265407","0.57208663","0.57187384","0.57143295","0.57137847","0.5709668","0.5703609","0.56985265","0.5678653","0.5678477","0.5668869","0.5666361","0.5661232","0.5659659","0.5653543"],"string":"[\n \"0.7577946\",\n \"0.7523797\",\n \"0.74303293\",\n \"0.7282001\",\n \"0.7124156\",\n \"0.7081991\",\n \"0.70752174\",\n \"0.7051836\",\n \"0.69150233\",\n \"0.6839642\",\n \"0.6801334\",\n \"0.6769318\",\n \"0.6742835\",\n \"0.66912425\",\n \"0.6654237\",\n \"0.6651771\",\n \"0.65922874\",\n \"0.64853823\",\n \"0.64189833\",\n \"0.6410784\",\n \"0.6398859\",\n \"0.637518\",\n \"0.6288902\",\n \"0.6256263\",\n \"0.6226565\",\n \"0.6205438\",\n \"0.6201334\",\n \"0.61942977\",\n \"0.6175079\",\n \"0.6173684\",\n \"0.6171845\",\n \"0.61672145\",\n \"0.6165712\",\n \"0.6158807\",\n \"0.6154485\",\n \"0.61404866\",\n \"0.61243224\",\n \"0.6101308\",\n \"0.6097647\",\n \"0.6078823\",\n \"0.607028\",\n \"0.606447\",\n \"0.6058227\",\n \"0.6052483\",\n \"0.60492885\",\n \"0.60299313\",\n \"0.6010371\",\n \"0.60062444\",\n \"0.6001594\",\n \"0.59893316\",\n \"0.5983745\",\n \"0.5977468\",\n \"0.5974122\",\n \"0.59596765\",\n \"0.5940964\",\n \"0.5939014\",\n \"0.59338105\",\n \"0.59252316\",\n \"0.5920663\",\n \"0.5918512\",\n \"0.59150815\",\n \"0.5912212\",\n \"0.59083205\",\n \"0.58964616\",\n \"0.5863887\",\n \"0.5861737\",\n \"0.58531094\",\n \"0.58515054\",\n \"0.58414483\",\n \"0.58406353\",\n \"0.5831956\",\n \"0.5822252\",\n \"0.58190906\",\n \"0.58161336\",\n \"0.581448\",\n \"0.5802265\",\n \"0.57966673\",\n \"0.5792917\",\n \"0.57769275\",\n \"0.5773239\",\n \"0.57727504\",\n \"0.5751328\",\n \"0.57444525\",\n \"0.5738972\",\n \"0.5736892\",\n \"0.5733436\",\n \"0.57265407\",\n \"0.57208663\",\n \"0.57187384\",\n \"0.57143295\",\n \"0.57137847\",\n \"0.5709668\",\n \"0.5703609\",\n \"0.56985265\",\n \"0.5678653\",\n \"0.5678477\",\n \"0.5668869\",\n \"0.5666361\",\n \"0.5661232\",\n \"0.5659659\",\n \"0.5653543\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84684,"cells":{"query":{"kind":"string","value":"Computes a translation matrix."},"document":{"kind":"string","value":"def translate(v: InputTensor) -> t.Tensor:\n result = util.to_tensor(v, dtype=t.float32)\n assert len(result.shape) >= 1\n dimensions = result.shape[-1]\n result = result[..., None, :].transpose(-1, -2)\n result = t.constant_pad_nd(result, [dimensions, 0, 0, 1])\n id_matrix = t.diag(result.new_ones([dimensions + 1]))\n id_matrix = id_matrix.expand_as(result)\n result = result + id_matrix\n return result"},"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 TranslationMatrix(x, y, z):\n\treturn np.matrix([ [1., 0., 0., x],\n\t\t\t\t\t\t[0., 1., 0., y],\n\t\t\t\t\t\t[0., 0., 1., z],\n\t\t\t\t\t\t[0., 0., 0., 1.]])","def translation_matrix(tx, ty, tz):\n T = np.array([[1, 0, 0, tx],\n [0, 1, 0, ty],\n [0, 0, 1, tz],\n [0, 0, 0, 1 ]])\n return T","def Translate(*args, **kwargs):\n return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)","def get_translation_matrix2d(translations: Tensor) -> Tensor:\n transform: Tensor = eye_like(3, translations)[:, :2, :]\n transform[..., 2] += translations # tx/ty\n\n # pad transform to get Bx3x3\n transform_h = convert_affinematrix_to_homography(transform)\n\n return transform_h","def matrix(self):\n return self._translation","def transformation_matrix(self, s1, s2, s3, t1, t2, t3):\n\n s1 = np.array(s1)\n s2 = np.array(s2)\n s3 = np.array(s3)\n t1 = np.array(t1)\n t2 = np.array(t2)\n t3 = np.array(t3)\n\n Q = np.array(\n [\n [t2[0] - t1[0], t2[1] - t1[1], t2[2] - t1[2]],\n [t3[0] - t1[0], t3[1] - t1[1], t3[2] - t1[2]],\n ]\n )\n\n P = np.array([[s2[0] - s1[0], s2[1] - s1[1]], [s3[0] - s1[0], s3[1] - s1[1]]])\n\n try:\n # Invert the P matrix\n Pinv = inv(P)\n\n # Build the dot product\n T = np.dot(Pinv, Q)\n\n # Offset\n V0 = np.subtract(t2, np.transpose(s2[0:2]).dot(T))\n except Exception as e:\n self.log.error(\"An error occured during the transformation.\", exc_info=True)\n return -1, -1\n\n return T, V0","def translate(self, x=0, y=0, z=0):\n\t\ttranslation = np.identity(4)\n\t\ttranslation[0, 3] += x\n\t\ttranslation[1, 3] += y\n\t\ttranslation[2, 3] += z\n\t\t\n\t\tself.matrix = np.matmul(self.matrix, translation)","def getTranslationMatrix(tx, ty, tz):\n return MatrixExtended([\n [1, 0, 0, tx],\n [0, 1, 0, ty],\n [0, 0, 1, tz],\n [0, 0, 0, 1]])","def translationMatrix(self, dx, dy, dz):\n\n return np.array([[1,0,0,0],\n [0,1,0,0],\n [0,0,1,0],\n [dx,dy,dz,1]])","def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])","def translation_matrix(direction):\n M = numpy.identity(4)\n M[:3, 3] = direction[:3]\n return M","def __compose_transformation(self):\n s = self.scale\n rotR = self.rotation\n t = self.translation\n T = np.eye(4)\n T[0:3, 3] = t\n R = np.eye(4)\n R[0:3, 0:3] = rotR\n M = T.dot(R)\n if s == 1:\n M = T.dot(R)\n else:\n S = np.eye(4)\n S[0:3, 0:3] = np.diag([s, s, s])\n M = T.dot(R).dot(S)\n return M","def get_transformation_matrix(theta=45):\n\n theta = theta/360 * 2 * np.pi # in radians\n hx = np.cos(theta)\n sy = np.sin(theta)\n\n S = np.array([[1, hx, 0],\n [0, sy, 0],\n [0, 0, 1]])\n #S_inv = np.linalg.inv(S)\n #old_coords = np.array([[2, 2, 1], [6, 6, 1]]).T\n #new_coords = np.matmul(S, old_coords)\n #recovered_coords = np.matmul(S_inv, new_coords)\n #print('new coords: ', new_coords)\n #print('recovered coords: ', recovered_coords)\n return S","def compute_trans_matrix( self, n_components ):\n matrix = np.zeros((n_components,n_components))\n matrix[-1,-1] = 1.\n\n for i in range(0,matrix.shape[0]-1):\n matrix[i,i:i+2] = [0.5,0.5]\n\n return matrix","def get_translation_matrix(translation_vector):\r\n T = torch.zeros(translation_vector.shape[0], 4, 4).to(device=translation_vector.device)\r\n\r\n t = translation_vector.contiguous().view(-1, 3, 1)\r\n\r\n T[:, 0, 0] = 1\r\n T[:, 1, 1] = 1\r\n T[:, 2, 2] = 1\r\n T[:, 3, 3] = 1\r\n T[:, :3, 3, None] = t\r\n\r\n return T","def make_transform_matrix(\n scale_factor: float,\n ccw_rotate_rads: float,\n x_translate: float,\n y_translate: float\n):\n rotate_scale_matrix = np.vstack((\n cv2.getRotationMatrix2D(\n center=(0, 0),\n angle=180 * ccw_rotate_rads / np.pi,\n scale=scale_factor\n ),\n np.array([0, 0, 1])\n ))\n translate_matrix = np.array([\n [1, 0, x_translate], # again, cv origin is top left, so y\n [0, 1, y_translate],\n [0, 0, 1]\n ])\n\n return np.dot(translate_matrix, rotate_scale_matrix)","def transformation_matrix(self):\n t = np.array([[0.0], [0.0], [0.0]])\n Rt = np.hstack([self.rotation_matrix, t])\n return np.vstack([Rt, np.array([0.0, 0.0, 0.0, 1.0])])","def translation_from_matrix(matrix):\r\n return numpy.array(matrix, copy=False)[:3, 3].copy()","def transl(x, y, z):\n displace_vector = [[x],\n [y],\n [z]]\n return np.matrix(displace_vector)","def translate(dx,dy,Mat):\r\n # MT is the Translation (3 X 3) Matrix\r\n MT=[[1,0,dx],[0,1,dy],[0,0,1]]\r\n Translated= Multiply(MT,Mat)\r\n # Translated[0][0] is the updated x coordinate\r\n # Translated[1][0] is the updated y coordinate\r\n return Translated[0][0],Translated[1][0],Translated[2][0]","def transformation_from_parameters(axisangle, translation, invert=False):\r\n R = rot_from_axisangle(axisangle)\r\n t = translation.clone()\r\n\r\n if invert:\r\n R = R.transpose(1, 2)\r\n t *= -1\r\n\r\n T = get_translation_matrix(t)\r\n\r\n if invert:\r\n M = torch.matmul(R, T)\r\n else:\r\n M = torch.matmul(T, R)\r\n\r\n return M","def _init_transformation_matrix(self):\n # Set up basic transformation matrix\n c_transform = np.zeros((self.n_beads, self.n_beads))\n\n # Get auxiliary array with bead indices\n n = np.arange(1, self.n_beads + 1)\n\n # for k = 0\n c_transform[0, :] = 1.0\n\n for k in range(1, self.n_beads // 2 + 1):\n c_transform[k, :] = np.sqrt(2) * np.cos(2 * np.pi * k * n / self.n_beads)\n\n for k in range(self.n_beads // 2 + 1, self.n_beads):\n c_transform[k, :] = np.sqrt(2) * np.sin(2 * np.pi * k * n / self.n_beads)\n\n if self.n_beads % 2 == 0:\n c_transform[self.n_beads // 2, :] = (-1) ** n\n\n # Since matrix is initialized as C(k,n) does not need to be transposed\n c_transform /= np.sqrt(self.n_beads)\n c_transform = torch.from_numpy(c_transform)\n\n return c_transform","def transformation_matrix(dx, dy, dz, roll=0):\n r = rotation_matrix(dx, dy, dz, roll)\n t = np.zeros((12, 12), dtype='float')\n t[:3,:3] = t[3:6,3:6] = t[6:9,6:9] = t[9:12,9:12] = r\n return t","def transformationMatrix(self,index=None):\n if self.method == 'pca':\n if index is not None:\n coordinateIndex = distribution1D.vectori_cxx(len(index))\n for i in range(len(index)):\n coordinateIndex[i] = index[i]\n matrixDim = self._distribution.getTransformationMatrixDimensions(coordinateIndex)\n transformation = self._distribution.getTransformationMatrix(coordinateIndex)\n else:\n matrixDim = self._distribution.getTransformationMatrixDimensions()\n transformation = self._distribution.getTransformationMatrix()\n row = matrixDim[0]\n column = matrixDim[1]\n # convert 1D vector to 2D array\n L = np.atleast_1d(transformation).reshape(row,column)\n else:\n self.raiseAnError(NotImplementedError,' transformationMatrix is not yet implemented for ' + self.method + ' method')\n return L","def Translate(shift_x, shift_y): \n shifted = numpy.matrix([[1.0, 0.0, 1.0 ],\n [0.0, 1.0, 1.0 ],\n [shift_x, shift_y, 1.0 ]]) \n return shifted","def make_project_matrix(X):\n X = np.mat(X)\n return np.eye(X.shape[0]) - (X*(np.linalg.inv(X.T*X)*X.T))","def getTranslationMatrix2d(dx, dy):\n return matrix([[1, 0, dx], [0, 1, dy], [0, 0, 1]])","def translateEuler(trans):\n return np.array([[1,0,0,trans[0]],[0,1,0,trans[1]],[0,0,1,trans[2]],[0,0,0,1]])","def _get_affine_matrix(center, angle, translate, scale, shear):\n angle = np.deg2rad(angle)\n shear = np.deg2rad(shear)\n C = np.matrix([[1., 0., center[0]],\n [0., 1., center[1]],\n [0., 0., 1.]])\n T = np.matrix([[1., 0., translate[0]],\n [0., 1., translate[1]],\n [0., 0., 1.]])\n RSS = np.matrix([[np.cos(angle), -np.sin(angle + shear), 0.],\n [np.sin(angle), np.cos(angle + shear), 0.],\n [ 0., 0., 1./scale]]) * scale\n M = T * C * RSS * np.linalg.inv(C)\n return M","def translateEuler(self,trans):\n return np.array([[1,0,0,trans[0]],[0,1,0,trans[1]],[0,0,1,trans[2]],[0,0,0,1]])","def transMatrix( source=None ):\n if source is None:\n return None,None\n else:\n (x,y,z) = source[:3]\n if x == y == z == 0.0:\n return None, None \n return tmatrixaccel.transMatrix( x,y,z ),tmatrixaccel.transMatrix( -x, -y, -z )","def get_transformation_matrix(self):\n\n s = self.sin()\n c = self.cos()\n return np.array(\n [\n c ** 2,\n c * s,\n -(c ** 2),\n -c * s,\n c * s,\n s ** 2,\n -c * s,\n -(s ** 2),\n -(c ** 2),\n -c * s,\n c ** 2,\n c * s,\n -c * s,\n -(s ** 2),\n c * s,\n s ** 2,\n ],\n dtype=np.float64,\n ).reshape(4, 4)","def extractTranslate(self,groups):\n self.translateX = float(groups[0])\n self.translateY = float(groups[0])\n if len(groups) == 2 and groups[1]:\n self.translateY = float(groups[1])\n self.matrix = [[1.0, 0.0, self.translateX], \\\n [0.0, 1.0, self.translateY]]","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n\n origin = np.array([location.x, location.y, location.z])\n return matrix, origin","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def toConceptual(self, matrix=None):\n\n if matrix is None:\n matrix = self.state.double()\n if len(matrix.shape) > 1:\n C = torch.mm(self.TPinv, matrix)\n else:\n C = torch.matmul(self.TPinv, matrix)\n C = fortran_reshape(C, (self.grammar.nF, self.grammar.nR))\n return C","def createTransMatrix(pages):\n links = getLinks(pages)\n urls = getUrls(pages)\n nPages = len(pages)\n m = np.matrix([[weightLink(nPages, u, l) for u in urls] for l in links])\n return dampingFactor(nPages, m)","def transforms_multiply(t0s, t1s):\r\n \r\n return ut.matrix_multiply(t0s, t1s)","def get_matrix(self, transform):\r\n\r\n rotation = transform.rotation\r\n location = transform.location\r\n c_y = np.cos(np.radians(rotation.yaw))\r\n s_y = np.sin(np.radians(rotation.yaw))\r\n c_r = np.cos(np.radians(rotation.roll))\r\n s_r = np.sin(np.radians(rotation.roll))\r\n c_p = np.cos(np.radians(rotation.pitch))\r\n s_p = np.sin(np.radians(rotation.pitch))\r\n matrix = np.matrix(np.identity(4))\r\n matrix[0, 3] = location.x\r\n matrix[1, 3] = location.y\r\n matrix[2, 3] = location.z\r\n matrix[0, 0] = c_p * c_y\r\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\r\n matrix[1, 0] = s_y * c_p\r\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\r\n matrix[2, 0] = s_p\r\n matrix[2, 1] = -c_p * s_r\r\n matrix[2, 2] = c_p * c_r\r\n return matrix","def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\n\n if phi is None:\n phi = const.PHI_IDX * 10.0\n\n #extrinsic x intrinsic\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\n\n intrinsic_matrix = np.eye(4, dtype=np.float32)\n extrinsic_matrix = np.eye(4, dtype=np.float32)\n\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\n\n #theta rotation\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\n rotation_azimuth[0, 0] = cos_theta\n rotation_azimuth[2, 2] = cos_theta\n rotation_azimuth[0, 2] = -sin_theta\n rotation_azimuth[2, 0] = sin_theta\n rotation_azimuth[1, 1] = 1.0\n\n #phi rotation\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\n rotation_elevation[0, 0] = cos_phi\n rotation_elevation[0, 1] = sin_phi\n rotation_elevation[1, 0] = -sin_phi\n rotation_elevation[1, 1] = cos_phi\n rotation_elevation[2, 2] = 1.0\n\n #rotate phi, then theta\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\n if invert_rot:\n rotation_matrix = np.linalg.inv(rotation_matrix)\n\n displacement = np.zeros((3, 1), dtype=np.float32)\n displacement[0, 0] = const.DIST_TO_CAM\n displacement = np.matmul(rotation_matrix, displacement)\n\n #assembling 4x4 from R + T\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\n extrinsic_matrix[0:3, 3:4] = -displacement\n\n if invert_focal:\n intrinsic_matrix[2, 2] = float(const.focal_length)\n intrinsic_matrix[1, 1] = float(const.focal_length)\n else:\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\n\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\n return camera_matrix","def transformation_matrix(self, di=(0, 0, 0), dj=(0, 0, 0)):\n xi, xj = self.get_nodes()\n di, dj = np.asarray(di), np.asarray(dj)\n dx, dy, dz = (xj - xi) + (dj - di)\n return transformation_matrix(dx, dy, dz, self.roll)","def get_transformation_matrix(theta=45):\n\n theta = theta/360 * 2 * np.pi # in radians\n hx = np.cos(theta)\n sy = np.sin(theta)\n \n S = np.array([[1, hx, 0],\n [0, sy, 0],\n [0, 0, 1]])\n\n return S","def _calc_matrix(self):\n\t\tz = self.zoom\n\t\talloc = self.allocation\n\t\tif self.image:\n\t\t\tiw, ih = self.image.get_width(), self.image.get_height()\n\t\telse:\n\t\t\tiw, ih = 0, 0\n#\t\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\n\t\t\n\t\ti2w = cairo.Matrix(\n\t\t\tz,0,\n\t\t\t0,z,\n\t\t\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \n\t\t\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\n\t\t\t)\n\t\t\n\t\tself._i2w_matrix = i2w\n\t\t\n\t\tw2i = cairo.Matrix(*i2w) #copy\n\t\tw2i.invert()\n\t\tself._w2i_matrix = w2i","def compute_matrix(*params, **hyperparams):\n phi = params[0]\n d, t = hyperparams[\"dimension\"]\n\n if qml.math.get_interface(phi) == \"tensorflow\":\n p = qml.math.exp(1j * qml.math.cast_like(phi, 1j))\n minus_p = qml.math.exp(-1j * qml.math.cast_like(phi, 1j))\n zeros = qml.math.zeros_like(p)\n\n columns = []\n for i in range(t):\n columns.append(\n [p if j == i else zeros for j in range(t)]\n if i < d\n else [minus_p if j == i else zeros for j in range(t)]\n )\n r = qml.math.stack(columns, like=\"tensorflow\", axis=-2)\n return r\n\n arg = 1j * phi\n prefactors = qml.math.array([1 if index < d else -1 for index in range(t)], like=phi)\n\n if qml.math.ndim(arg) == 0:\n return qml.math.diag(qml.math.exp(arg * prefactors))\n\n diags = qml.math.exp(qml.math.outer(arg, prefactors))\n return qml.math.stack(qml.math.diag(d) for d in diags)","def affine_transform(trans_mat, p0):\r\n n_data, n_dim = np.shape(p0)\r\n p0 = np.hstack((p0, np.ones((n_data, 1))))\r\n #return np.transpose(np.dot(np.transpose(trans_mat), np.transpose(p0)))\r\n return np.dot(p0, trans_mat)","def translate3d(p, a=0, b=0, c=0):\n translation_mat = np.matrix([\n [1,0,0,0],\n [0,1,0,0],\n [0,0,1,0],\n [a,b,c,1]\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def translation_vector(self):\n return self.affine_matrix[0:3][:, 3]","def get_affine_matrix2d(\n translations: torch.Tensor,\n center: torch.Tensor,\n scale: torch.Tensor,\n angle: torch.Tensor,\n sx: Optional[torch.Tensor] = None,\n sy: Optional[torch.Tensor] = None,\n) -> torch.Tensor:\n transform: torch.Tensor = get_rotation_matrix2d(center, -angle, scale)\n transform[..., 2] += translations # tx/ty\n\n # pad transform to get Bx3x3\n transform_h = convert_affinematrix_to_homography(transform)\n\n if any(s is not None for s in [sx, sy]):\n shear_mat = get_shear_matrix2d(center, sx, sy)\n transform_h = transform_h @ shear_mat\n\n return transform_h","def make_translations(dataset, labels):\n offset = 10\n translations = [\n (0, offset),\n (0, -offset),\n (offset, 0),\n (-offset, 0),\n (-offset, -offset),\n (-offset, offset),\n (offset, -offset),\n (offset, offset)\n ]\n\n was_flattened = (len(dataset[0].shape) == 1)\n augmented_dataset = []\n augmented_labels = []\n \n for image, label in zip(dataset, labels):\n if was_flattened:\n image = unflatten(image)\n \n height = image.shape[0]\n width = image.shape[1]\n \n for t_x, t_y in translations:\n new_image = np.zeros(image.shape)\n t_mat = np.array([[1,0,t_x],[0,1,t_y],[0,0,1]])\n\n for x in range(0, width):\n for y in range(0, height):\n old_coords = np.array([[x],[y],[1]])\n new_coords = t_mat.dot(old_coords) # translation here\n\n if new_coords[0] > 0 and new_coords[0] < width and new_coords[1] > 0 and new_coords[1] < height:\n new_image[new_coords[1], new_coords[0]] = image[y, x]\n \n if was_flattened:\n new_image.flatten()\n augmented_dataset.append(new_image)\n augmented_labels.append(label)\n\n return (augmented_dataset, augmented_labels)","def _transform(self, matrix):\n for x in list(self.keys()):\n ar = self[x]\n if len(ar.shape) == 2 and ar.shape[1] == 3:\n self[x] = np.dot(matrix, ar.transpose()).transpose()","def compute_matrix(self):\n\n fac = self.a / self.dx ** 2\n\n diagonal = np.ones(self.nx) * 2 * fac\n lower = np.ones(self.nx - 1) * -fac\n upper = np.ones(self.nx - 1) * -fac\n\n matrix = sp.diags(\n diagonals=[diagonal, lower, upper],\n offsets=[0, -1, 1], shape=(self.nx, self.nx),\n format='csr')\n\n return matrix","def translations_to_projective_transforms(\n translations: TensorLike, name: Optional[str] = None\n) -> tf.Tensor:\n with tf.name_scope(name or \"translations_to_projective_transforms\"):\n translation_or_translations = tf.convert_to_tensor(\n translations, name=\"translations\", dtype=tf.dtypes.float32\n )\n if translation_or_translations.get_shape().ndims is None:\n raise TypeError(\"translation_or_translations rank must be statically known\")\n elif len(translation_or_translations.get_shape()) == 1:\n translations = translation_or_translations[None]\n elif len(translation_or_translations.get_shape()) == 2:\n translations = translation_or_translations\n else:\n raise TypeError(\"Translations should have rank 1 or 2.\")\n num_translations = tf.shape(translations)[0]\n # The translation matrix looks like:\n # [[1 0 -dx]\n # [0 1 -dy]\n # [0 0 1]]\n # where the last entry is implicit.\n # Translation matrices are always float32.\n return tf.concat(\n values=[\n tf.ones((num_translations, 1), tf.dtypes.float32),\n tf.zeros((num_translations, 1), tf.dtypes.float32),\n -translations[:, 0, None],\n tf.zeros((num_translations, 1), tf.dtypes.float32),\n tf.ones((num_translations, 1), tf.dtypes.float32),\n -translations[:, 1, None],\n tf.zeros((num_translations, 2), tf.dtypes.float32),\n ],\n axis=1,\n )","def matrix(self):\n m = Matrix.identity(4, 4)\n\n m[:3, :3] = self.rotation.matrix.data\n m[:3, 3:4] = self.translation.matrix.data\n\n return m","def translate(geom, xoff=0.0, yoff=0.0, zoff=0.0):\n matrix = (1.0, 0.0, 0.0,\n 0.0, 1.0, 0.0,\n 0.0, 0.0, 1.0,\n xoff, yoff, zoff)\n return affine_transform(geom, matrix)","def translate_np(note_matrix, shift=1, direction=\"up\"):\n if direction == \"down\":\n shift = shift * -1\n translated_matrix = np.roll(note_matrix, shift, axis=-2)\n return translated_matrix","def _create_target_matrix(A, tranmat):\n A = A.dot(tranmat)\n # TODO: add lambda parameter to math.log\n scores = np.log(A.data) - math.log(A.shape[0])\n A.data[scores >= 0] = 0.\n A.eliminate_zeros()\n return A","def compute_matrix(theta, pauli_word): # pylint: disable=arguments-differ\n if not PauliRot._check_pauli_word(pauli_word):\n raise ValueError(\n f'The given Pauli word \"{pauli_word}\" contains characters that are not allowed. '\n \"Allowed characters are I, X, Y and Z\"\n )\n\n interface = qml.math.get_interface(theta)\n\n if interface == \"tensorflow\":\n theta = qml.math.cast_like(theta, 1j)\n\n # Simplest case is if the Pauli is the identity matrix\n if set(pauli_word) == {\"I\"}:\n exp = qml.math.exp(-0.5j * theta)\n iden = qml.math.eye(2 ** len(pauli_word), like=theta)\n if qml.math.get_interface(theta) == \"tensorflow\":\n iden = qml.math.cast_like(iden, 1j)\n if qml.math.get_interface(theta) == \"torch\":\n td = exp.device\n iden = iden.to(td)\n\n if qml.math.ndim(theta) == 0:\n return exp * iden\n\n return qml.math.stack([e * iden for e in exp])\n\n # We first generate the matrix excluding the identity parts and expand it afterwards.\n # To this end, we have to store on which wires the non-identity parts act\n non_identity_wires, non_identity_gates = zip(\n *[(wire, gate) for wire, gate in enumerate(pauli_word) if gate != \"I\"]\n )\n\n multi_Z_rot_matrix = MultiRZ.compute_matrix(theta, len(non_identity_gates))\n\n # now we conjugate with Hadamard and RX to create the Pauli string\n conjugation_matrix = functools.reduce(\n qml.math.kron,\n [PauliRot._PAULI_CONJUGATION_MATRICES[gate] for gate in non_identity_gates],\n )\n if interface == \"tensorflow\":\n conjugation_matrix = qml.math.cast_like(conjugation_matrix, 1j)\n # Note: we use einsum with reverse arguments here because it is not multi-dispatched\n # and the tensordot containing multi_Z_rot_matrix should decide about the interface\n return expand_matrix(\n qml.math.einsum(\n \"...jk,ij->...ik\",\n qml.math.tensordot(multi_Z_rot_matrix, conjugation_matrix, axes=[[-1], [0]]),\n qml.math.conj(conjugation_matrix),\n ),\n non_identity_wires,\n list(range(len(pauli_word))),\n )","def translate(self, vector):\n \n matrix = wf.translationMatrix(*vector)\n for wireframe in self.wireframes.values():\n wireframe.transform(matrix)","def rotation_to_transformation_matrix(R):\n R = Matrix(R)\n T = R.col_insert(3, Matrix([0., 0., 0.]))\n T = T.row_insert(3, Matrix([[0., 0., 0., 1.]]))\n return T","def get_ee_transform_matrices(self):\n translation_mat = np.zeros((4, 4))\n rotation_mat = np.zeros((4, 4))\n\n with open(directory + '/EE_to_Palm_Translation_Matrix.csv', newline='') as f:\n reader = csv.reader(f)\n for j, row in enumerate(reader):\n for i, col in enumerate(row):\n translation_mat[j][i] = float(col)\n\n with open(directory + '/EE_to_Palm_Rotation_Matrix.csv', newline='') as f:\n reader = csv.reader(f)\n for j, row in enumerate(reader):\n for i, col in enumerate(row):\n rotation_mat[j][i] = float(col)\n\n return translation_mat, rotation_mat","def translate(self, tr):\n c = self.c -self.a*tr[0] -self.b*tr[1]\n self.c =c\n self.pointN = self.pointN+tr\n self.point1 = self.point1+tr\n self.points +=tr","def transform_calcualtion(height, width, t_mat, h_offset, w_offset, nh_flag, nw_flag):\n # default coordination/location of transformed matrix according to source data(data map)\n coord_map = default_coord(height, width, h_offset, w_offset)\n\n for i in range(height):\n for j in range(width):\n # base calculations\n result = [(t_mat[0][0])*(coord_map[i, j, 0])+int((t_mat[0][1])*(coord_map[i, j, 1])),\n (t_mat[1][0])*(coord_map[i, j, 0])+(t_mat[1][1])*(coord_map[i, j, 1])]\n # since all coordinations must not be negative\n # if happened also apply a translation by offset\n coord_map[i, j, :] = [(result[0], result[0]+h_offset)[nh_flag],\n (result[1], result[1]+w_offset)[nw_flag]]\n return coord_map","def compute_T_matrix(coordinates, p, reference=[[1,0,0],[0,1,0],[0,0,1]], origin=[0,0,0]):\n e_b_x = coordinates[0]\n e_b_y = coordinates[1]\n e_b_z = coordinates[2]\n \n e_a_x = reference[0] \n e_a_y = reference[1]\n e_a_z = reference[2]\n \n # Compute the rotation matrix\n x_b_a = [np.dot(e_b_x, e_a_x), np.dot(e_b_x, e_a_y), np.dot(e_b_x, e_a_z)]\n y_b_a = [np.dot(e_b_y, e_a_x), np.dot(e_b_y, e_a_y), np.dot(e_b_y, e_a_z)]\n z_b_a = [np.dot(e_b_z, e_a_x), np.dot(e_b_z, e_a_y), np.dot(e_b_z, e_a_z)]\n \n R_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0]],[x_b_a[1], y_b_a[1], z_b_a[1]],x_b_a[2], y_b_a[2], z_b_a[2]]\n \n # Compute the displacement \n displacement = [p[0]-origin[0], p[1]-origin[1], p[2]-origin[2]]\n \n # Make it into a transform matrix\n T_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0], displacement[0]],\n [x_b_a[1], y_b_a[1], z_b_a[1], displacement[1]],\n [x_b_a[2], y_b_a[2], z_b_a[2], displacement[2]],\n [0, 0, 0, 1]]\n \n T_a_b = np.linalg.inv(T_b_a).tolist()\n \n return T_b_a, T_a_b","def compute_T_matrix(coordinates, p, reference=[[1,0,0],[0,1,0],[0,0,1]], origin=[0,0,0]):\n e_b_x = coordinates[0]\n e_b_y = coordinates[1]\n e_b_z = coordinates[2]\n \n e_a_x = reference[0] \n e_a_y = reference[1]\n e_a_z = reference[2]\n \n # Compute the rotation matrix\n x_b_a = [np.dot(e_b_x, e_a_x), np.dot(e_b_x, e_a_y), np.dot(e_b_x, e_a_z)]\n y_b_a = [np.dot(e_b_y, e_a_x), np.dot(e_b_y, e_a_y), np.dot(e_b_y, e_a_z)]\n z_b_a = [np.dot(e_b_z, e_a_x), np.dot(e_b_z, e_a_y), np.dot(e_b_z, e_a_z)]\n \n R_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0]],[x_b_a[1], y_b_a[1], z_b_a[1]],x_b_a[2], y_b_a[2], z_b_a[2]]\n \n # Compute the displacement \n displacement = [p[0]-origin[0], p[1]-origin[1], p[2]-origin[2]]\n \n # Make it into a transform matrix\n T_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0], displacement[0]],\n [x_b_a[1], y_b_a[1], z_b_a[1], displacement[1]],\n [x_b_a[2], y_b_a[2], z_b_a[2], displacement[2]],\n [0, 0, 0, 1]]\n \n T_a_b = np.linalg.inv(T_b_a).tolist()\n \n return T_b_a, T_a_b","def get_matrix_list(transform):\n c_y = np.cos(np.radians(transform[5]))\n s_y = np.sin(np.radians(transform[5]))\n c_r = np.cos(np.radians(transform[3]))\n s_r = np.sin(np.radians(transform[3]))\n c_p = np.cos(np.radians(transform[4]))\n s_p = np.sin(np.radians(transform[4]))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = transform[0]\n matrix[1, 3] = transform[1]\n matrix[2, 3] = transform[2]\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n origin = np.array(transform[:3])\n return matrix, origin","def get_affine_matrix2d(\n translations: Tensor,\n center: Tensor,\n scale: Tensor,\n angle: Tensor,\n sx: Tensor | None = None,\n sy: Tensor | None = None,\n) -> Tensor:\n transform: Tensor = get_rotation_matrix2d(center, -angle, scale)\n transform[..., 2] += translations # tx/ty\n\n # pad transform to get Bx3x3\n transform_h = convert_affinematrix_to_homography(transform)\n\n if any(s is not None for s in [sx, sy]):\n shear_mat = get_shear_matrix2d(center, sx, sy)\n transform_h = transform_h @ shear_mat\n\n return transform_h","def inverse_rigid_trans(Tr): \n inv_Tr = np.zeros_like(Tr) # 3x4\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\n return inv_Tr","def transform_mat(R, t):\n return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)","def transform_mat(R, t):\n return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)","def transformation_matrix(self) -> TransformationMatrixType:\n # camera translation\n if self._transformation_matrix is None:\n self._transformation_matrix = numpy.matmul(\n self.projection_matrix,\n self.camera_matrix,\n )\n\n return self._transformation_matrix","def affine_matrix(self) -> np.ndarray:\n return self._forward_link._inverse_tf_matrix","def transAffine2D( iScale=(1, 1), iTrans=(0, 0), iRot=0, iShear=(0, 0) ): \n iRot = iRot * np.pi / 180\n oMatScale = np.matrix( ((iScale[0],0,0),(0,iScale[1],0),(0,0,1)) )\n oMatTrans = np.matrix( ((1,0,iTrans[0]),(0,1,iTrans[1]),(0,0,1)) )\n oMatRot = np.matrix( ((np.cos(iRot),-np.sin(iRot),0),\\\n (np.sin(iRot),np.cos(iRot),0),(0,0,1)) )\n oMatShear = np.matrix( ((1,iShear[0],0),(iShear[1],1,0),(0,0,1)) )\n # ustvari izhodno matriko\n oMat2D = oMatTrans * oMatShear * oMatRot * oMatScale\n return oMat2D","def translate(note_matrix, direction=\"up\"):\n translated_matrix = []\n\n # If we translate upwards, the highest note falls off\n # If we translate down, the lowest note falls off\n dropped_idx = 0\n if direction == \"up\":\n dropped_idx = -1\n\n for step_notes in note_matrix:\n # Each step_notes is a (78 x 2)\n if direction == \"up\":\n translated_matrix.append([[0, 0]] + [pair for pair in step_notes[0:-1]])\n else:\n translated_matrix.append([pair for pair in step_notes[1:]] + [[0, 0]])\n\n return translated_matrix","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 get_matrix_from_transforms(position, normal, tangent):\n nor = MVector(normal).normal()\n tan = MVector(tangent).normal()\n ort = nor ^ tan\n pos = MVector(position)\n\n matrix = MMatrix()\n for row, vector in enumerate([nor, tan, ort, pos]):\n for column, value in enumerate(vector):\n matrix.setElement(row, column, value)\n\n return matrix","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 rotation_matrix_cp(axis, theta):\n axis = np.asarray(axis)\n theta = np.asarray(theta)\n axis = axis/math.sqrt(np.dot(axis, axis))\n a = math.cos(theta/2.0)\n b, c, d = -axis*math.sin(theta/2.0)\n aa, bb, cc, dd = a*a, b*b, c*c, d*d\n bc, ad, ac, ab, bd, cd = b*c, a*d, a*c, a*b, b*d, c*d\n return np.matrix([[aa+bb-cc-dd, 2*(bc+ad), 2*(bd-ac), 0.],\n [2*(bc-ad), aa+cc-bb-dd, 2*(cd+ab), 0.],\n [2*(bd+ac), 2*(cd-ab), aa+dd-bb-cc, 0.],\n [0., 0., 0., 1.]])","def compose_mat(rot):\n trans_mat = oMa.MTransformationMatrix()\n trans_mat.setRotation(rot)\n\n mat = trans_mat.asMatrix()\n\n return mat","def get_affine_matrix3d(\n translations: torch.Tensor,\n center: torch.Tensor,\n scale: torch.Tensor,\n angles: torch.Tensor,\n sxy: Optional[torch.Tensor] = None,\n sxz: Optional[torch.Tensor] = None,\n syx: Optional[torch.Tensor] = None,\n syz: Optional[torch.Tensor] = None,\n szx: Optional[torch.Tensor] = None,\n szy: Optional[torch.Tensor] = None,\n) -> torch.Tensor:\n transform: torch.Tensor = get_projective_transform(center, -angles, scale)\n transform[..., 3] += translations # tx/ty/tz\n\n # pad transform to get Bx3x3\n transform_h = convert_affinematrix_to_homography3d(transform)\n if any(s is not None for s in [sxy, sxz, syx, syz, szx, szy]):\n shear_mat = get_shear_matrix3d(center, sxy, sxz, syx, syz, szx, szy)\n transform_h = transform_h @ shear_mat\n\n return transform_h","def __lineartrans(self):\n do = self.domain\n self.transpoints = copy(self.pts)\n def t(x):\n return (x - do[0])/(do[1]-do[0])\n for i in range(len(self.transpoints)):\n self.transpoints[i,0] = t(self.transpoints[i,0])","def transformation(T,M):\n\n n = len(M) # Nb de lignes\n p = len(M[0]) # Nb de colonnes\n\n x1, y1 = vecteur_image(T,0,n)\n x2, y2 = vecteur_image(T,p,n)\n x3, y3 = vecteur_image(T,p,0)\n\n xmin = round(min(0,x1,x2,x3))\n xmax = round(max(0,x1,x2,x3))\n ymin = round(min(0,y1,y2,y3))\n ymax = round(max(0,y1,y2,y3))\n\n pp = xmax-xmin\n nn = ymax-ymin\n\n Tinv = inverse_matrice(T)\n\n N = [[0 for jj in range(pp)] for ii in range(nn)]\n for ii in range(nn):\n for jj in range(pp):\n j, i = vecteur_image(Tinv,jj+xmin,ii+ymin)\n j, i = floor(j), floor(i)\n if (0 <= i < n) and (0 <= j < p):\n N[ii][jj] = M[i][j] \n else:\n N[ii][jj] = 0\n\n return N","def trans_matrix_inv(m:numpy.ndarray):\n was2d = False\n if m.shape[1] == 3:\n was2d = True\n m = numpy.asarray([\n [1.0, 0.0, 0.0, 0.0],\n [0.0, m[0,0], m[0,1], m[0,2]],\n [0.0, m[1,0], m[1,1], m[1,2]],\n [0.0, 0.0, 0.0, 1.0]], numpy.float64)\n trans = m[0:3,3]\n rotate = numpy.zeros(3, numpy.float64)\n r = m[0:3,0:3]\n rc = numpy.linalg.cholesky(numpy.matmul(r.T, r)).T\n scale = numpy.diagonal(rc)\n if numpy.linalg.det(r) < 0.0:\n scale[0] *= -1.0\n rcd = rc * numpy.eye(3, dtype=numpy.float64)\n rc = numpy.linalg.solve(rcd, rc)\n shear = numpy.asarray([rc[0,1], rc[0,2], rc[1,2]], numpy.float64)\n r0 = trans_matrix({'rotate': rotate, 'scale': scale, 'shear': shear})[0:3,0:3]\n r0 = numpy.linalg.solve(numpy.linalg.inv(r), numpy.linalg.inv(r0))\n rotate[1] = numpy.arcsin(_frone(r0[0,2]))\n if numpy.abs((numpy.abs(rotate[1]) - (numpy.pi / 2.0))) < 1.0e-6:\n rotate[0] = 0.0\n rotate[2] = numpy.arctan2(-_frone(r0[1,0]), _frone(-r0[2,0] / r0[0,2]))\n else:\n rc = numpy.cos(rotate[1])\n rotate[0] = numpy.arctan2(_frone(r0[1,2] / rc), _frone(r0[2,2] / rc))\n rotate[2] = numpy.arctan2(_frone(r0[0,1] / rc), _frone(r0[0,0] / rc))\n if was2d:\n trans = trans[1:]\n rotate = rotate[0:1]\n scale = scale[1:]\n shear = shear[2:3]\n return (trans, rotate, scale, shear)","def translateAll(self, vector):\n matrix = self.translationMatrix(vector[0], vector[1], vector[2])\n for wireframe in self.wireframes.values():\n wireframe.transform(matrix)","def _compute_t_matrix(self):\n self.t_matrix = self._kronecker_product(\n tf.diag(tf.reshape(self.likelihood_variances, [-1])),\n tf.eye(self.n_points_int, dtype=tf.float64))\n return","def build_matrix(self):\n self.lb_make = LabelEncoder()\n self.lb_make.fit(self.Y_train)\n tokenizer = Tokenizer(num_words=2000)\n x_array_train = numpy.asarray(self.train['text'])\n x_array_test = numpy.asarray(self.test['text'])\n tokenizer.fit_on_texts(x_array_train)\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\n y_train_numbers = self.lb_make.transform(self.Y_train)\n y_test_numbers = self.lb_make.transform(self.Y_test)\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\n self.tokenizer = tokenizer\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix","def compute_matrix(phi): # pylint: disable=arguments-differ\n if qml.math.get_interface(phi) == \"tensorflow\":\n phi = qml.math.cast_like(phi, 1j)\n\n e = qml.math.exp(1j * phi)\n\n return qml.math.stack(\n [\n stack_last([1, 0, 0, 0]),\n stack_last([0, 0, e, 0]),\n stack_last([0, e, 0, 0]),\n stack_last([0, 0, 0, 1]),\n ],\n axis=-2,\n )","def rotation_matrix(rotate):\n tx, ty, tz = rotate\n Rx = np.array([[1, 0, 0], [0, np.cos(tx), -np.sin(tx)], [0, np.sin(tx), np.cos(tx)]])\n Ry = np.array([[np.cos(ty), 0, -np.sin(ty)], [0, 1, 0], [np.sin(ty), 0, np.cos(ty)]])\n Rz = np.array([[np.cos(tz), -np.sin(tz), 0], [np.sin(tz), np.cos(tz), 0], [0, 0, 1]])\n return np.dot(Rx, np.dot(Ry, Rz))","def transl(x, y=None, z=None):\n \n if y == None and z == None:\n x = mat(x)\n try:\n if ishomog(x):\n return x[0:3, 3].reshape(3, 1)\n else:\n return concatenate((concatenate((eye(3), x.reshape(3, 1)), 1), mat([0, 0, 0, 1])))\n except AttributeError:\n n = len(x)\n r = [[], [], []]\n for i in range(n):\n r = concatenate((r, x[i][0:3, 3]), 1)\n return r\n elif y != None and z != None:\n return concatenate((concatenate((eye(3), mat([x, y, z]).T), 1), mat([0, 0, 0, 1])))","def Translate(self, *args):\n return _itkTranslationTransformPython.itkTranslationTransformD2_Translate(self, *args)","def similarity_transformation(rot, mat):\n return np.dot(rot, np.dot(mat, np.linalg.inv(rot)))","def similarity_transformation(rot, mat):\n return np.dot(rot, np.dot(mat, np.linalg.inv(rot)))","def _get_transformation_matrix(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):\n\n # CONVERT DEGREES TO RADIANS\n rotation = math.pi * rotation / 180.\n shear = math.pi * shear / 180.\n\n # ROTATION MATRIX\n c1 = tf.math.cos(rotation)\n s1 = tf.math.sin(rotation)\n one = tf.constant([1], dtype='float32')\n zero = tf.constant([0], dtype='float32')\n rotation_matrix = tf.reshape(tf.concat([\n c1, s1, zero, -s1, c1, zero, zero, zero, one\n ], axis=0), [3, 3])\n\n # SHEAR MATRIX\n c2 = tf.math.cos(shear)\n s2 = tf.math.sin(shear)\n shear_matrix = tf.reshape(tf.concat([\n one, s2, zero, zero, c2, zero, zero, zero, one\n ], axis=0), [3, 3])\n\n # ZOOM MATRIX\n zoom_matrix = tf.reshape(tf.concat([\n one/height_zoom, zero, zero, zero, one/width_zoom, zero, zero, zero, one\n ], axis=0), [3, 3])\n\n # SHIFT MATRIX\n shift_matrix = tf.reshape(tf.concat([\n one, zero, height_shift, zero, one, width_shift, zero, zero, one\n ], axis=0), [3, 3])\n\n return keras.backend.dot(\n keras.backend.dot(rotation_matrix, shear_matrix),\n keras.backend.dot(zoom_matrix, shift_matrix))","def affine_matrix(self) -> np.ndarray:\n return self._tf_matrix","def _apply_transformations(structure, rotations, translations):\n # Additional first dimension for 'structure.repeat()'\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\n\n # Apply corresponding transformation for each copy in the assembly\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\n coord = structure.coord\n # Rotate\n coord = matrix_rotate(coord, rotation)\n # Translate\n coord += translation\n assembly_coord[i] = coord\n\n return repeat(structure, assembly_coord)","def matrix_math_api_examples():\n \n print(dingbat.vec2())\n print(dingbat.vec2(array.array('f', (20, 40))))\n print(dingbat.mat3())\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\n translate = dingbat.translation_matrix(-10, -20, -30)\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\n scale = dingbat.scale_matrix(100, 200, 300)\n print(translate)\n print(rotate)\n print(scale)\n print(dingbat.multiply_matrices(translate, rotate, scale))","def form_matrix_yt(w):\r\n M = np.zeros((len(w),len(w)))\r\n for i in range(len(w)):\r\n for j in range(len(w)):\r\n M[i,j] = YoungTableaux(w[i],w[j]).CMNR()\r\n return M","def get_transition_matrix(self):\n # Transition matrix\n P_trans = np.zeros((self.n_states, self.n_states))\n\n # Fill\n for s_num in range(2, (2**self.depth)):\n P_trans[(s_num - 1), (s_num//2 - 1)] = 1.0\n\n return P_trans","def homog_trans_mtx(x: float, y: float, z: float) -> numpy.array:\n return numpy.array(\n ((1, 0, 0, x), (0, 1, 0, y), (0, 0, 1, z), (0, 0, 0, 1)), dtype=numpy.float64\n )","def get_warp_matrix(theta, size_input, size_dst, size_target):\n theta = np.deg2rad(theta)\n matrix = np.zeros((2, 3), dtype=np.float32)\n scale_x = size_dst[0] / size_target[0]\n scale_y = size_dst[1] / size_target[1]\n matrix[0, 0] = math.cos(theta) * scale_x\n matrix[0, 1] = -math.sin(theta) * scale_x\n matrix[0, 2] = scale_x * (-0.5 * size_input[0] * math.cos(theta) + 0.5 * size_input[1] * math.sin(theta) + 0.5 * size_target[0])\n matrix[1, 0] = math.sin(theta) * scale_y\n matrix[1, 1] = math.cos(theta) * scale_y\n matrix[1, 2] = scale_y * (-0.5 * size_input[0] * math.sin(theta) - 0.5 * size_input[1] * math.cos(theta) + 0.5 * size_target[1])\n return matrix"],"string":"[\n \"def TranslationMatrix(x, y, z):\\n\\treturn np.matrix([ [1., 0., 0., x],\\n\\t\\t\\t\\t\\t\\t[0., 1., 0., y],\\n\\t\\t\\t\\t\\t\\t[0., 0., 1., z],\\n\\t\\t\\t\\t\\t\\t[0., 0., 0., 1.]])\",\n \"def translation_matrix(tx, ty, tz):\\n T = np.array([[1, 0, 0, tx],\\n [0, 1, 0, ty],\\n [0, 0, 1, tz],\\n [0, 0, 0, 1 ]])\\n return T\",\n \"def Translate(*args, **kwargs):\\n return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)\",\n \"def get_translation_matrix2d(translations: Tensor) -> Tensor:\\n transform: Tensor = eye_like(3, translations)[:, :2, :]\\n transform[..., 2] += translations # tx/ty\\n\\n # pad transform to get Bx3x3\\n transform_h = convert_affinematrix_to_homography(transform)\\n\\n return transform_h\",\n \"def matrix(self):\\n return self._translation\",\n \"def transformation_matrix(self, s1, s2, s3, t1, t2, t3):\\n\\n s1 = np.array(s1)\\n s2 = np.array(s2)\\n s3 = np.array(s3)\\n t1 = np.array(t1)\\n t2 = np.array(t2)\\n t3 = np.array(t3)\\n\\n Q = np.array(\\n [\\n [t2[0] - t1[0], t2[1] - t1[1], t2[2] - t1[2]],\\n [t3[0] - t1[0], t3[1] - t1[1], t3[2] - t1[2]],\\n ]\\n )\\n\\n P = np.array([[s2[0] - s1[0], s2[1] - s1[1]], [s3[0] - s1[0], s3[1] - s1[1]]])\\n\\n try:\\n # Invert the P matrix\\n Pinv = inv(P)\\n\\n # Build the dot product\\n T = np.dot(Pinv, Q)\\n\\n # Offset\\n V0 = np.subtract(t2, np.transpose(s2[0:2]).dot(T))\\n except Exception as e:\\n self.log.error(\\\"An error occured during the transformation.\\\", exc_info=True)\\n return -1, -1\\n\\n return T, V0\",\n \"def translate(self, x=0, y=0, z=0):\\n\\t\\ttranslation = np.identity(4)\\n\\t\\ttranslation[0, 3] += x\\n\\t\\ttranslation[1, 3] += y\\n\\t\\ttranslation[2, 3] += z\\n\\t\\t\\n\\t\\tself.matrix = np.matmul(self.matrix, translation)\",\n \"def getTranslationMatrix(tx, ty, tz):\\n return MatrixExtended([\\n [1, 0, 0, tx],\\n [0, 1, 0, ty],\\n [0, 0, 1, tz],\\n [0, 0, 0, 1]])\",\n \"def translationMatrix(self, dx, dy, dz):\\n\\n return np.array([[1,0,0,0],\\n [0,1,0,0],\\n [0,0,1,0],\\n [dx,dy,dz,1]])\",\n \"def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])\",\n \"def translation_matrix(direction):\\n M = numpy.identity(4)\\n M[:3, 3] = direction[:3]\\n return M\",\n \"def __compose_transformation(self):\\n s = self.scale\\n rotR = self.rotation\\n t = self.translation\\n T = np.eye(4)\\n T[0:3, 3] = t\\n R = np.eye(4)\\n R[0:3, 0:3] = rotR\\n M = T.dot(R)\\n if s == 1:\\n M = T.dot(R)\\n else:\\n S = np.eye(4)\\n S[0:3, 0:3] = np.diag([s, s, s])\\n M = T.dot(R).dot(S)\\n return M\",\n \"def get_transformation_matrix(theta=45):\\n\\n theta = theta/360 * 2 * np.pi # in radians\\n hx = np.cos(theta)\\n sy = np.sin(theta)\\n\\n S = np.array([[1, hx, 0],\\n [0, sy, 0],\\n [0, 0, 1]])\\n #S_inv = np.linalg.inv(S)\\n #old_coords = np.array([[2, 2, 1], [6, 6, 1]]).T\\n #new_coords = np.matmul(S, old_coords)\\n #recovered_coords = np.matmul(S_inv, new_coords)\\n #print('new coords: ', new_coords)\\n #print('recovered coords: ', recovered_coords)\\n return S\",\n \"def compute_trans_matrix( self, n_components ):\\n matrix = np.zeros((n_components,n_components))\\n matrix[-1,-1] = 1.\\n\\n for i in range(0,matrix.shape[0]-1):\\n matrix[i,i:i+2] = [0.5,0.5]\\n\\n return matrix\",\n \"def get_translation_matrix(translation_vector):\\r\\n T = torch.zeros(translation_vector.shape[0], 4, 4).to(device=translation_vector.device)\\r\\n\\r\\n t = translation_vector.contiguous().view(-1, 3, 1)\\r\\n\\r\\n T[:, 0, 0] = 1\\r\\n T[:, 1, 1] = 1\\r\\n T[:, 2, 2] = 1\\r\\n T[:, 3, 3] = 1\\r\\n T[:, :3, 3, None] = t\\r\\n\\r\\n return T\",\n \"def make_transform_matrix(\\n scale_factor: float,\\n ccw_rotate_rads: float,\\n x_translate: float,\\n y_translate: float\\n):\\n rotate_scale_matrix = np.vstack((\\n cv2.getRotationMatrix2D(\\n center=(0, 0),\\n angle=180 * ccw_rotate_rads / np.pi,\\n scale=scale_factor\\n ),\\n np.array([0, 0, 1])\\n ))\\n translate_matrix = np.array([\\n [1, 0, x_translate], # again, cv origin is top left, so y\\n [0, 1, y_translate],\\n [0, 0, 1]\\n ])\\n\\n return np.dot(translate_matrix, rotate_scale_matrix)\",\n \"def transformation_matrix(self):\\n t = np.array([[0.0], [0.0], [0.0]])\\n Rt = np.hstack([self.rotation_matrix, t])\\n return np.vstack([Rt, np.array([0.0, 0.0, 0.0, 1.0])])\",\n \"def translation_from_matrix(matrix):\\r\\n return numpy.array(matrix, copy=False)[:3, 3].copy()\",\n \"def transl(x, y, z):\\n displace_vector = [[x],\\n [y],\\n [z]]\\n return np.matrix(displace_vector)\",\n \"def translate(dx,dy,Mat):\\r\\n # MT is the Translation (3 X 3) Matrix\\r\\n MT=[[1,0,dx],[0,1,dy],[0,0,1]]\\r\\n Translated= Multiply(MT,Mat)\\r\\n # Translated[0][0] is the updated x coordinate\\r\\n # Translated[1][0] is the updated y coordinate\\r\\n return Translated[0][0],Translated[1][0],Translated[2][0]\",\n \"def transformation_from_parameters(axisangle, translation, invert=False):\\r\\n R = rot_from_axisangle(axisangle)\\r\\n t = translation.clone()\\r\\n\\r\\n if invert:\\r\\n R = R.transpose(1, 2)\\r\\n t *= -1\\r\\n\\r\\n T = get_translation_matrix(t)\\r\\n\\r\\n if invert:\\r\\n M = torch.matmul(R, T)\\r\\n else:\\r\\n M = torch.matmul(T, R)\\r\\n\\r\\n return M\",\n \"def _init_transformation_matrix(self):\\n # Set up basic transformation matrix\\n c_transform = np.zeros((self.n_beads, self.n_beads))\\n\\n # Get auxiliary array with bead indices\\n n = np.arange(1, self.n_beads + 1)\\n\\n # for k = 0\\n c_transform[0, :] = 1.0\\n\\n for k in range(1, self.n_beads // 2 + 1):\\n c_transform[k, :] = np.sqrt(2) * np.cos(2 * np.pi * k * n / self.n_beads)\\n\\n for k in range(self.n_beads // 2 + 1, self.n_beads):\\n c_transform[k, :] = np.sqrt(2) * np.sin(2 * np.pi * k * n / self.n_beads)\\n\\n if self.n_beads % 2 == 0:\\n c_transform[self.n_beads // 2, :] = (-1) ** n\\n\\n # Since matrix is initialized as C(k,n) does not need to be transposed\\n c_transform /= np.sqrt(self.n_beads)\\n c_transform = torch.from_numpy(c_transform)\\n\\n return c_transform\",\n \"def transformation_matrix(dx, dy, dz, roll=0):\\n r = rotation_matrix(dx, dy, dz, roll)\\n t = np.zeros((12, 12), dtype='float')\\n t[:3,:3] = t[3:6,3:6] = t[6:9,6:9] = t[9:12,9:12] = r\\n return t\",\n \"def transformationMatrix(self,index=None):\\n if self.method == 'pca':\\n if index is not None:\\n coordinateIndex = distribution1D.vectori_cxx(len(index))\\n for i in range(len(index)):\\n coordinateIndex[i] = index[i]\\n matrixDim = self._distribution.getTransformationMatrixDimensions(coordinateIndex)\\n transformation = self._distribution.getTransformationMatrix(coordinateIndex)\\n else:\\n matrixDim = self._distribution.getTransformationMatrixDimensions()\\n transformation = self._distribution.getTransformationMatrix()\\n row = matrixDim[0]\\n column = matrixDim[1]\\n # convert 1D vector to 2D array\\n L = np.atleast_1d(transformation).reshape(row,column)\\n else:\\n self.raiseAnError(NotImplementedError,' transformationMatrix is not yet implemented for ' + self.method + ' method')\\n return L\",\n \"def Translate(shift_x, shift_y): \\n shifted = numpy.matrix([[1.0, 0.0, 1.0 ],\\n [0.0, 1.0, 1.0 ],\\n [shift_x, shift_y, 1.0 ]]) \\n return shifted\",\n \"def make_project_matrix(X):\\n X = np.mat(X)\\n return np.eye(X.shape[0]) - (X*(np.linalg.inv(X.T*X)*X.T))\",\n \"def getTranslationMatrix2d(dx, dy):\\n return matrix([[1, 0, dx], [0, 1, dy], [0, 0, 1]])\",\n \"def translateEuler(trans):\\n return np.array([[1,0,0,trans[0]],[0,1,0,trans[1]],[0,0,1,trans[2]],[0,0,0,1]])\",\n \"def _get_affine_matrix(center, angle, translate, scale, shear):\\n angle = np.deg2rad(angle)\\n shear = np.deg2rad(shear)\\n C = np.matrix([[1., 0., center[0]],\\n [0., 1., center[1]],\\n [0., 0., 1.]])\\n T = np.matrix([[1., 0., translate[0]],\\n [0., 1., translate[1]],\\n [0., 0., 1.]])\\n RSS = np.matrix([[np.cos(angle), -np.sin(angle + shear), 0.],\\n [np.sin(angle), np.cos(angle + shear), 0.],\\n [ 0., 0., 1./scale]]) * scale\\n M = T * C * RSS * np.linalg.inv(C)\\n return M\",\n \"def translateEuler(self,trans):\\n return np.array([[1,0,0,trans[0]],[0,1,0,trans[1]],[0,0,1,trans[2]],[0,0,0,1]])\",\n \"def transMatrix( source=None ):\\n if source is None:\\n return None,None\\n else:\\n (x,y,z) = source[:3]\\n if x == y == z == 0.0:\\n return None, None \\n return tmatrixaccel.transMatrix( x,y,z ),tmatrixaccel.transMatrix( -x, -y, -z )\",\n \"def get_transformation_matrix(self):\\n\\n s = self.sin()\\n c = self.cos()\\n return np.array(\\n [\\n c ** 2,\\n c * s,\\n -(c ** 2),\\n -c * s,\\n c * s,\\n s ** 2,\\n -c * s,\\n -(s ** 2),\\n -(c ** 2),\\n -c * s,\\n c ** 2,\\n c * s,\\n -c * s,\\n -(s ** 2),\\n c * s,\\n s ** 2,\\n ],\\n dtype=np.float64,\\n ).reshape(4, 4)\",\n \"def extractTranslate(self,groups):\\n self.translateX = float(groups[0])\\n self.translateY = float(groups[0])\\n if len(groups) == 2 and groups[1]:\\n self.translateY = float(groups[1])\\n self.matrix = [[1.0, 0.0, self.translateX], \\\\\\n [0.0, 1.0, self.translateY]]\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n\\n origin = np.array([location.x, location.y, location.z])\\n return matrix, origin\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def toConceptual(self, matrix=None):\\n\\n if matrix is None:\\n matrix = self.state.double()\\n if len(matrix.shape) > 1:\\n C = torch.mm(self.TPinv, matrix)\\n else:\\n C = torch.matmul(self.TPinv, matrix)\\n C = fortran_reshape(C, (self.grammar.nF, self.grammar.nR))\\n return C\",\n \"def createTransMatrix(pages):\\n links = getLinks(pages)\\n urls = getUrls(pages)\\n nPages = len(pages)\\n m = np.matrix([[weightLink(nPages, u, l) for u in urls] for l in links])\\n return dampingFactor(nPages, m)\",\n \"def transforms_multiply(t0s, t1s):\\r\\n \\r\\n return ut.matrix_multiply(t0s, t1s)\",\n \"def get_matrix(self, transform):\\r\\n\\r\\n rotation = transform.rotation\\r\\n location = transform.location\\r\\n c_y = np.cos(np.radians(rotation.yaw))\\r\\n s_y = np.sin(np.radians(rotation.yaw))\\r\\n c_r = np.cos(np.radians(rotation.roll))\\r\\n s_r = np.sin(np.radians(rotation.roll))\\r\\n c_p = np.cos(np.radians(rotation.pitch))\\r\\n s_p = np.sin(np.radians(rotation.pitch))\\r\\n matrix = np.matrix(np.identity(4))\\r\\n matrix[0, 3] = location.x\\r\\n matrix[1, 3] = location.y\\r\\n matrix[2, 3] = location.z\\r\\n matrix[0, 0] = c_p * c_y\\r\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\r\\n matrix[1, 0] = s_y * c_p\\r\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\r\\n matrix[2, 0] = s_p\\r\\n matrix[2, 1] = -c_p * s_r\\r\\n matrix[2, 2] = c_p * c_r\\r\\n return matrix\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def transformation_matrix(self, di=(0, 0, 0), dj=(0, 0, 0)):\\n xi, xj = self.get_nodes()\\n di, dj = np.asarray(di), np.asarray(dj)\\n dx, dy, dz = (xj - xi) + (dj - di)\\n return transformation_matrix(dx, dy, dz, self.roll)\",\n \"def get_transformation_matrix(theta=45):\\n\\n theta = theta/360 * 2 * np.pi # in radians\\n hx = np.cos(theta)\\n sy = np.sin(theta)\\n \\n S = np.array([[1, hx, 0],\\n [0, sy, 0],\\n [0, 0, 1]])\\n\\n return S\",\n \"def _calc_matrix(self):\\n\\t\\tz = self.zoom\\n\\t\\talloc = self.allocation\\n\\t\\tif self.image:\\n\\t\\t\\tiw, ih = self.image.get_width(), self.image.get_height()\\n\\t\\telse:\\n\\t\\t\\tiw, ih = 0, 0\\n#\\t\\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\\n\\t\\t\\n\\t\\ti2w = cairo.Matrix(\\n\\t\\t\\tz,0,\\n\\t\\t\\t0,z,\\n\\t\\t\\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \\n\\t\\t\\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\\n\\t\\t\\t)\\n\\t\\t\\n\\t\\tself._i2w_matrix = i2w\\n\\t\\t\\n\\t\\tw2i = cairo.Matrix(*i2w) #copy\\n\\t\\tw2i.invert()\\n\\t\\tself._w2i_matrix = w2i\",\n \"def compute_matrix(*params, **hyperparams):\\n phi = params[0]\\n d, t = hyperparams[\\\"dimension\\\"]\\n\\n if qml.math.get_interface(phi) == \\\"tensorflow\\\":\\n p = qml.math.exp(1j * qml.math.cast_like(phi, 1j))\\n minus_p = qml.math.exp(-1j * qml.math.cast_like(phi, 1j))\\n zeros = qml.math.zeros_like(p)\\n\\n columns = []\\n for i in range(t):\\n columns.append(\\n [p if j == i else zeros for j in range(t)]\\n if i < d\\n else [minus_p if j == i else zeros for j in range(t)]\\n )\\n r = qml.math.stack(columns, like=\\\"tensorflow\\\", axis=-2)\\n return r\\n\\n arg = 1j * phi\\n prefactors = qml.math.array([1 if index < d else -1 for index in range(t)], like=phi)\\n\\n if qml.math.ndim(arg) == 0:\\n return qml.math.diag(qml.math.exp(arg * prefactors))\\n\\n diags = qml.math.exp(qml.math.outer(arg, prefactors))\\n return qml.math.stack(qml.math.diag(d) for d in diags)\",\n \"def affine_transform(trans_mat, p0):\\r\\n n_data, n_dim = np.shape(p0)\\r\\n p0 = np.hstack((p0, np.ones((n_data, 1))))\\r\\n #return np.transpose(np.dot(np.transpose(trans_mat), np.transpose(p0)))\\r\\n return np.dot(p0, trans_mat)\",\n \"def translate3d(p, a=0, b=0, c=0):\\n translation_mat = np.matrix([\\n [1,0,0,0],\\n [0,1,0,0],\\n [0,0,1,0],\\n [a,b,c,1]\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def translation_vector(self):\\n return self.affine_matrix[0:3][:, 3]\",\n \"def get_affine_matrix2d(\\n translations: torch.Tensor,\\n center: torch.Tensor,\\n scale: torch.Tensor,\\n angle: torch.Tensor,\\n sx: Optional[torch.Tensor] = None,\\n sy: Optional[torch.Tensor] = None,\\n) -> torch.Tensor:\\n transform: torch.Tensor = get_rotation_matrix2d(center, -angle, scale)\\n transform[..., 2] += translations # tx/ty\\n\\n # pad transform to get Bx3x3\\n transform_h = convert_affinematrix_to_homography(transform)\\n\\n if any(s is not None for s in [sx, sy]):\\n shear_mat = get_shear_matrix2d(center, sx, sy)\\n transform_h = transform_h @ shear_mat\\n\\n return transform_h\",\n \"def make_translations(dataset, labels):\\n offset = 10\\n translations = [\\n (0, offset),\\n (0, -offset),\\n (offset, 0),\\n (-offset, 0),\\n (-offset, -offset),\\n (-offset, offset),\\n (offset, -offset),\\n (offset, offset)\\n ]\\n\\n was_flattened = (len(dataset[0].shape) == 1)\\n augmented_dataset = []\\n augmented_labels = []\\n \\n for image, label in zip(dataset, labels):\\n if was_flattened:\\n image = unflatten(image)\\n \\n height = image.shape[0]\\n width = image.shape[1]\\n \\n for t_x, t_y in translations:\\n new_image = np.zeros(image.shape)\\n t_mat = np.array([[1,0,t_x],[0,1,t_y],[0,0,1]])\\n\\n for x in range(0, width):\\n for y in range(0, height):\\n old_coords = np.array([[x],[y],[1]])\\n new_coords = t_mat.dot(old_coords) # translation here\\n\\n if new_coords[0] > 0 and new_coords[0] < width and new_coords[1] > 0 and new_coords[1] < height:\\n new_image[new_coords[1], new_coords[0]] = image[y, x]\\n \\n if was_flattened:\\n new_image.flatten()\\n augmented_dataset.append(new_image)\\n augmented_labels.append(label)\\n\\n return (augmented_dataset, augmented_labels)\",\n \"def _transform(self, matrix):\\n for x in list(self.keys()):\\n ar = self[x]\\n if len(ar.shape) == 2 and ar.shape[1] == 3:\\n self[x] = np.dot(matrix, ar.transpose()).transpose()\",\n \"def compute_matrix(self):\\n\\n fac = self.a / self.dx ** 2\\n\\n diagonal = np.ones(self.nx) * 2 * fac\\n lower = np.ones(self.nx - 1) * -fac\\n upper = np.ones(self.nx - 1) * -fac\\n\\n matrix = sp.diags(\\n diagonals=[diagonal, lower, upper],\\n offsets=[0, -1, 1], shape=(self.nx, self.nx),\\n format='csr')\\n\\n return matrix\",\n \"def translations_to_projective_transforms(\\n translations: TensorLike, name: Optional[str] = None\\n) -> tf.Tensor:\\n with tf.name_scope(name or \\\"translations_to_projective_transforms\\\"):\\n translation_or_translations = tf.convert_to_tensor(\\n translations, name=\\\"translations\\\", dtype=tf.dtypes.float32\\n )\\n if translation_or_translations.get_shape().ndims is None:\\n raise TypeError(\\\"translation_or_translations rank must be statically known\\\")\\n elif len(translation_or_translations.get_shape()) == 1:\\n translations = translation_or_translations[None]\\n elif len(translation_or_translations.get_shape()) == 2:\\n translations = translation_or_translations\\n else:\\n raise TypeError(\\\"Translations should have rank 1 or 2.\\\")\\n num_translations = tf.shape(translations)[0]\\n # The translation matrix looks like:\\n # [[1 0 -dx]\\n # [0 1 -dy]\\n # [0 0 1]]\\n # where the last entry is implicit.\\n # Translation matrices are always float32.\\n return tf.concat(\\n values=[\\n tf.ones((num_translations, 1), tf.dtypes.float32),\\n tf.zeros((num_translations, 1), tf.dtypes.float32),\\n -translations[:, 0, None],\\n tf.zeros((num_translations, 1), tf.dtypes.float32),\\n tf.ones((num_translations, 1), tf.dtypes.float32),\\n -translations[:, 1, None],\\n tf.zeros((num_translations, 2), tf.dtypes.float32),\\n ],\\n axis=1,\\n )\",\n \"def matrix(self):\\n m = Matrix.identity(4, 4)\\n\\n m[:3, :3] = self.rotation.matrix.data\\n m[:3, 3:4] = self.translation.matrix.data\\n\\n return m\",\n \"def translate(geom, xoff=0.0, yoff=0.0, zoff=0.0):\\n matrix = (1.0, 0.0, 0.0,\\n 0.0, 1.0, 0.0,\\n 0.0, 0.0, 1.0,\\n xoff, yoff, zoff)\\n return affine_transform(geom, matrix)\",\n \"def translate_np(note_matrix, shift=1, direction=\\\"up\\\"):\\n if direction == \\\"down\\\":\\n shift = shift * -1\\n translated_matrix = np.roll(note_matrix, shift, axis=-2)\\n return translated_matrix\",\n \"def _create_target_matrix(A, tranmat):\\n A = A.dot(tranmat)\\n # TODO: add lambda parameter to math.log\\n scores = np.log(A.data) - math.log(A.shape[0])\\n A.data[scores >= 0] = 0.\\n A.eliminate_zeros()\\n return A\",\n \"def compute_matrix(theta, pauli_word): # pylint: disable=arguments-differ\\n if not PauliRot._check_pauli_word(pauli_word):\\n raise ValueError(\\n f'The given Pauli word \\\"{pauli_word}\\\" contains characters that are not allowed. '\\n \\\"Allowed characters are I, X, Y and Z\\\"\\n )\\n\\n interface = qml.math.get_interface(theta)\\n\\n if interface == \\\"tensorflow\\\":\\n theta = qml.math.cast_like(theta, 1j)\\n\\n # Simplest case is if the Pauli is the identity matrix\\n if set(pauli_word) == {\\\"I\\\"}:\\n exp = qml.math.exp(-0.5j * theta)\\n iden = qml.math.eye(2 ** len(pauli_word), like=theta)\\n if qml.math.get_interface(theta) == \\\"tensorflow\\\":\\n iden = qml.math.cast_like(iden, 1j)\\n if qml.math.get_interface(theta) == \\\"torch\\\":\\n td = exp.device\\n iden = iden.to(td)\\n\\n if qml.math.ndim(theta) == 0:\\n return exp * iden\\n\\n return qml.math.stack([e * iden for e in exp])\\n\\n # We first generate the matrix excluding the identity parts and expand it afterwards.\\n # To this end, we have to store on which wires the non-identity parts act\\n non_identity_wires, non_identity_gates = zip(\\n *[(wire, gate) for wire, gate in enumerate(pauli_word) if gate != \\\"I\\\"]\\n )\\n\\n multi_Z_rot_matrix = MultiRZ.compute_matrix(theta, len(non_identity_gates))\\n\\n # now we conjugate with Hadamard and RX to create the Pauli string\\n conjugation_matrix = functools.reduce(\\n qml.math.kron,\\n [PauliRot._PAULI_CONJUGATION_MATRICES[gate] for gate in non_identity_gates],\\n )\\n if interface == \\\"tensorflow\\\":\\n conjugation_matrix = qml.math.cast_like(conjugation_matrix, 1j)\\n # Note: we use einsum with reverse arguments here because it is not multi-dispatched\\n # and the tensordot containing multi_Z_rot_matrix should decide about the interface\\n return expand_matrix(\\n qml.math.einsum(\\n \\\"...jk,ij->...ik\\\",\\n qml.math.tensordot(multi_Z_rot_matrix, conjugation_matrix, axes=[[-1], [0]]),\\n qml.math.conj(conjugation_matrix),\\n ),\\n non_identity_wires,\\n list(range(len(pauli_word))),\\n )\",\n \"def translate(self, vector):\\n \\n matrix = wf.translationMatrix(*vector)\\n for wireframe in self.wireframes.values():\\n wireframe.transform(matrix)\",\n \"def rotation_to_transformation_matrix(R):\\n R = Matrix(R)\\n T = R.col_insert(3, Matrix([0., 0., 0.]))\\n T = T.row_insert(3, Matrix([[0., 0., 0., 1.]]))\\n return T\",\n \"def get_ee_transform_matrices(self):\\n translation_mat = np.zeros((4, 4))\\n rotation_mat = np.zeros((4, 4))\\n\\n with open(directory + '/EE_to_Palm_Translation_Matrix.csv', newline='') as f:\\n reader = csv.reader(f)\\n for j, row in enumerate(reader):\\n for i, col in enumerate(row):\\n translation_mat[j][i] = float(col)\\n\\n with open(directory + '/EE_to_Palm_Rotation_Matrix.csv', newline='') as f:\\n reader = csv.reader(f)\\n for j, row in enumerate(reader):\\n for i, col in enumerate(row):\\n rotation_mat[j][i] = float(col)\\n\\n return translation_mat, rotation_mat\",\n \"def translate(self, tr):\\n c = self.c -self.a*tr[0] -self.b*tr[1]\\n self.c =c\\n self.pointN = self.pointN+tr\\n self.point1 = self.point1+tr\\n self.points +=tr\",\n \"def transform_calcualtion(height, width, t_mat, h_offset, w_offset, nh_flag, nw_flag):\\n # default coordination/location of transformed matrix according to source data(data map)\\n coord_map = default_coord(height, width, h_offset, w_offset)\\n\\n for i in range(height):\\n for j in range(width):\\n # base calculations\\n result = [(t_mat[0][0])*(coord_map[i, j, 0])+int((t_mat[0][1])*(coord_map[i, j, 1])),\\n (t_mat[1][0])*(coord_map[i, j, 0])+(t_mat[1][1])*(coord_map[i, j, 1])]\\n # since all coordinations must not be negative\\n # if happened also apply a translation by offset\\n coord_map[i, j, :] = [(result[0], result[0]+h_offset)[nh_flag],\\n (result[1], result[1]+w_offset)[nw_flag]]\\n return coord_map\",\n \"def compute_T_matrix(coordinates, p, reference=[[1,0,0],[0,1,0],[0,0,1]], origin=[0,0,0]):\\n e_b_x = coordinates[0]\\n e_b_y = coordinates[1]\\n e_b_z = coordinates[2]\\n \\n e_a_x = reference[0] \\n e_a_y = reference[1]\\n e_a_z = reference[2]\\n \\n # Compute the rotation matrix\\n x_b_a = [np.dot(e_b_x, e_a_x), np.dot(e_b_x, e_a_y), np.dot(e_b_x, e_a_z)]\\n y_b_a = [np.dot(e_b_y, e_a_x), np.dot(e_b_y, e_a_y), np.dot(e_b_y, e_a_z)]\\n z_b_a = [np.dot(e_b_z, e_a_x), np.dot(e_b_z, e_a_y), np.dot(e_b_z, e_a_z)]\\n \\n R_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0]],[x_b_a[1], y_b_a[1], z_b_a[1]],x_b_a[2], y_b_a[2], z_b_a[2]]\\n \\n # Compute the displacement \\n displacement = [p[0]-origin[0], p[1]-origin[1], p[2]-origin[2]]\\n \\n # Make it into a transform matrix\\n T_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0], displacement[0]],\\n [x_b_a[1], y_b_a[1], z_b_a[1], displacement[1]],\\n [x_b_a[2], y_b_a[2], z_b_a[2], displacement[2]],\\n [0, 0, 0, 1]]\\n \\n T_a_b = np.linalg.inv(T_b_a).tolist()\\n \\n return T_b_a, T_a_b\",\n \"def compute_T_matrix(coordinates, p, reference=[[1,0,0],[0,1,0],[0,0,1]], origin=[0,0,0]):\\n e_b_x = coordinates[0]\\n e_b_y = coordinates[1]\\n e_b_z = coordinates[2]\\n \\n e_a_x = reference[0] \\n e_a_y = reference[1]\\n e_a_z = reference[2]\\n \\n # Compute the rotation matrix\\n x_b_a = [np.dot(e_b_x, e_a_x), np.dot(e_b_x, e_a_y), np.dot(e_b_x, e_a_z)]\\n y_b_a = [np.dot(e_b_y, e_a_x), np.dot(e_b_y, e_a_y), np.dot(e_b_y, e_a_z)]\\n z_b_a = [np.dot(e_b_z, e_a_x), np.dot(e_b_z, e_a_y), np.dot(e_b_z, e_a_z)]\\n \\n R_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0]],[x_b_a[1], y_b_a[1], z_b_a[1]],x_b_a[2], y_b_a[2], z_b_a[2]]\\n \\n # Compute the displacement \\n displacement = [p[0]-origin[0], p[1]-origin[1], p[2]-origin[2]]\\n \\n # Make it into a transform matrix\\n T_b_a = [[x_b_a[0], y_b_a[0], z_b_a[0], displacement[0]],\\n [x_b_a[1], y_b_a[1], z_b_a[1], displacement[1]],\\n [x_b_a[2], y_b_a[2], z_b_a[2], displacement[2]],\\n [0, 0, 0, 1]]\\n \\n T_a_b = np.linalg.inv(T_b_a).tolist()\\n \\n return T_b_a, T_a_b\",\n \"def get_matrix_list(transform):\\n c_y = np.cos(np.radians(transform[5]))\\n s_y = np.sin(np.radians(transform[5]))\\n c_r = np.cos(np.radians(transform[3]))\\n s_r = np.sin(np.radians(transform[3]))\\n c_p = np.cos(np.radians(transform[4]))\\n s_p = np.sin(np.radians(transform[4]))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = transform[0]\\n matrix[1, 3] = transform[1]\\n matrix[2, 3] = transform[2]\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n origin = np.array(transform[:3])\\n return matrix, origin\",\n \"def get_affine_matrix2d(\\n translations: Tensor,\\n center: Tensor,\\n scale: Tensor,\\n angle: Tensor,\\n sx: Tensor | None = None,\\n sy: Tensor | None = None,\\n) -> Tensor:\\n transform: Tensor = get_rotation_matrix2d(center, -angle, scale)\\n transform[..., 2] += translations # tx/ty\\n\\n # pad transform to get Bx3x3\\n transform_h = convert_affinematrix_to_homography(transform)\\n\\n if any(s is not None for s in [sx, sy]):\\n shear_mat = get_shear_matrix2d(center, sx, sy)\\n transform_h = transform_h @ shear_mat\\n\\n return transform_h\",\n \"def inverse_rigid_trans(Tr): \\n inv_Tr = np.zeros_like(Tr) # 3x4\\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\\n return inv_Tr\",\n \"def transform_mat(R, t):\\n return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)\",\n \"def transform_mat(R, t):\\n return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)\",\n \"def transformation_matrix(self) -> TransformationMatrixType:\\n # camera translation\\n if self._transformation_matrix is None:\\n self._transformation_matrix = numpy.matmul(\\n self.projection_matrix,\\n self.camera_matrix,\\n )\\n\\n return self._transformation_matrix\",\n \"def affine_matrix(self) -> np.ndarray:\\n return self._forward_link._inverse_tf_matrix\",\n \"def transAffine2D( iScale=(1, 1), iTrans=(0, 0), iRot=0, iShear=(0, 0) ): \\n iRot = iRot * np.pi / 180\\n oMatScale = np.matrix( ((iScale[0],0,0),(0,iScale[1],0),(0,0,1)) )\\n oMatTrans = np.matrix( ((1,0,iTrans[0]),(0,1,iTrans[1]),(0,0,1)) )\\n oMatRot = np.matrix( ((np.cos(iRot),-np.sin(iRot),0),\\\\\\n (np.sin(iRot),np.cos(iRot),0),(0,0,1)) )\\n oMatShear = np.matrix( ((1,iShear[0],0),(iShear[1],1,0),(0,0,1)) )\\n # ustvari izhodno matriko\\n oMat2D = oMatTrans * oMatShear * oMatRot * oMatScale\\n return oMat2D\",\n \"def translate(note_matrix, direction=\\\"up\\\"):\\n translated_matrix = []\\n\\n # If we translate upwards, the highest note falls off\\n # If we translate down, the lowest note falls off\\n dropped_idx = 0\\n if direction == \\\"up\\\":\\n dropped_idx = -1\\n\\n for step_notes in note_matrix:\\n # Each step_notes is a (78 x 2)\\n if direction == \\\"up\\\":\\n translated_matrix.append([[0, 0]] + [pair for pair in step_notes[0:-1]])\\n else:\\n translated_matrix.append([pair for pair in step_notes[1:]] + [[0, 0]])\\n\\n return translated_matrix\",\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 get_matrix_from_transforms(position, normal, tangent):\\n nor = MVector(normal).normal()\\n tan = MVector(tangent).normal()\\n ort = nor ^ tan\\n pos = MVector(position)\\n\\n matrix = MMatrix()\\n for row, vector in enumerate([nor, tan, ort, pos]):\\n for column, value in enumerate(vector):\\n matrix.setElement(row, column, value)\\n\\n return matrix\",\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 rotation_matrix_cp(axis, theta):\\n axis = np.asarray(axis)\\n theta = np.asarray(theta)\\n axis = axis/math.sqrt(np.dot(axis, axis))\\n a = math.cos(theta/2.0)\\n b, c, d = -axis*math.sin(theta/2.0)\\n aa, bb, cc, dd = a*a, b*b, c*c, d*d\\n bc, ad, ac, ab, bd, cd = b*c, a*d, a*c, a*b, b*d, c*d\\n return np.matrix([[aa+bb-cc-dd, 2*(bc+ad), 2*(bd-ac), 0.],\\n [2*(bc-ad), aa+cc-bb-dd, 2*(cd+ab), 0.],\\n [2*(bd+ac), 2*(cd-ab), aa+dd-bb-cc, 0.],\\n [0., 0., 0., 1.]])\",\n \"def compose_mat(rot):\\n trans_mat = oMa.MTransformationMatrix()\\n trans_mat.setRotation(rot)\\n\\n mat = trans_mat.asMatrix()\\n\\n return mat\",\n \"def get_affine_matrix3d(\\n translations: torch.Tensor,\\n center: torch.Tensor,\\n scale: torch.Tensor,\\n angles: torch.Tensor,\\n sxy: Optional[torch.Tensor] = None,\\n sxz: Optional[torch.Tensor] = None,\\n syx: Optional[torch.Tensor] = None,\\n syz: Optional[torch.Tensor] = None,\\n szx: Optional[torch.Tensor] = None,\\n szy: Optional[torch.Tensor] = None,\\n) -> torch.Tensor:\\n transform: torch.Tensor = get_projective_transform(center, -angles, scale)\\n transform[..., 3] += translations # tx/ty/tz\\n\\n # pad transform to get Bx3x3\\n transform_h = convert_affinematrix_to_homography3d(transform)\\n if any(s is not None for s in [sxy, sxz, syx, syz, szx, szy]):\\n shear_mat = get_shear_matrix3d(center, sxy, sxz, syx, syz, szx, szy)\\n transform_h = transform_h @ shear_mat\\n\\n return transform_h\",\n \"def __lineartrans(self):\\n do = self.domain\\n self.transpoints = copy(self.pts)\\n def t(x):\\n return (x - do[0])/(do[1]-do[0])\\n for i in range(len(self.transpoints)):\\n self.transpoints[i,0] = t(self.transpoints[i,0])\",\n \"def transformation(T,M):\\n\\n n = len(M) # Nb de lignes\\n p = len(M[0]) # Nb de colonnes\\n\\n x1, y1 = vecteur_image(T,0,n)\\n x2, y2 = vecteur_image(T,p,n)\\n x3, y3 = vecteur_image(T,p,0)\\n\\n xmin = round(min(0,x1,x2,x3))\\n xmax = round(max(0,x1,x2,x3))\\n ymin = round(min(0,y1,y2,y3))\\n ymax = round(max(0,y1,y2,y3))\\n\\n pp = xmax-xmin\\n nn = ymax-ymin\\n\\n Tinv = inverse_matrice(T)\\n\\n N = [[0 for jj in range(pp)] for ii in range(nn)]\\n for ii in range(nn):\\n for jj in range(pp):\\n j, i = vecteur_image(Tinv,jj+xmin,ii+ymin)\\n j, i = floor(j), floor(i)\\n if (0 <= i < n) and (0 <= j < p):\\n N[ii][jj] = M[i][j] \\n else:\\n N[ii][jj] = 0\\n\\n return N\",\n \"def trans_matrix_inv(m:numpy.ndarray):\\n was2d = False\\n if m.shape[1] == 3:\\n was2d = True\\n m = numpy.asarray([\\n [1.0, 0.0, 0.0, 0.0],\\n [0.0, m[0,0], m[0,1], m[0,2]],\\n [0.0, m[1,0], m[1,1], m[1,2]],\\n [0.0, 0.0, 0.0, 1.0]], numpy.float64)\\n trans = m[0:3,3]\\n rotate = numpy.zeros(3, numpy.float64)\\n r = m[0:3,0:3]\\n rc = numpy.linalg.cholesky(numpy.matmul(r.T, r)).T\\n scale = numpy.diagonal(rc)\\n if numpy.linalg.det(r) < 0.0:\\n scale[0] *= -1.0\\n rcd = rc * numpy.eye(3, dtype=numpy.float64)\\n rc = numpy.linalg.solve(rcd, rc)\\n shear = numpy.asarray([rc[0,1], rc[0,2], rc[1,2]], numpy.float64)\\n r0 = trans_matrix({'rotate': rotate, 'scale': scale, 'shear': shear})[0:3,0:3]\\n r0 = numpy.linalg.solve(numpy.linalg.inv(r), numpy.linalg.inv(r0))\\n rotate[1] = numpy.arcsin(_frone(r0[0,2]))\\n if numpy.abs((numpy.abs(rotate[1]) - (numpy.pi / 2.0))) < 1.0e-6:\\n rotate[0] = 0.0\\n rotate[2] = numpy.arctan2(-_frone(r0[1,0]), _frone(-r0[2,0] / r0[0,2]))\\n else:\\n rc = numpy.cos(rotate[1])\\n rotate[0] = numpy.arctan2(_frone(r0[1,2] / rc), _frone(r0[2,2] / rc))\\n rotate[2] = numpy.arctan2(_frone(r0[0,1] / rc), _frone(r0[0,0] / rc))\\n if was2d:\\n trans = trans[1:]\\n rotate = rotate[0:1]\\n scale = scale[1:]\\n shear = shear[2:3]\\n return (trans, rotate, scale, shear)\",\n \"def translateAll(self, vector):\\n matrix = self.translationMatrix(vector[0], vector[1], vector[2])\\n for wireframe in self.wireframes.values():\\n wireframe.transform(matrix)\",\n \"def _compute_t_matrix(self):\\n self.t_matrix = self._kronecker_product(\\n tf.diag(tf.reshape(self.likelihood_variances, [-1])),\\n tf.eye(self.n_points_int, dtype=tf.float64))\\n return\",\n \"def build_matrix(self):\\n self.lb_make = LabelEncoder()\\n self.lb_make.fit(self.Y_train)\\n tokenizer = Tokenizer(num_words=2000)\\n x_array_train = numpy.asarray(self.train['text'])\\n x_array_test = numpy.asarray(self.test['text'])\\n tokenizer.fit_on_texts(x_array_train)\\n x_train_matrix = tokenizer.texts_to_matrix(x_array_train, mode='count')\\n x_test_matrix = tokenizer.texts_to_matrix(x_array_test, mode='count')\\n y_train_numbers = self.lb_make.transform(self.Y_train)\\n y_test_numbers = self.lb_make.transform(self.Y_test)\\n y_train_matrix = keras.utils.to_categorical(y_train_numbers, 3)\\n y_test_matrix = keras.utils.to_categorical(y_test_numbers, 3)\\n self.tokenizer = tokenizer\\n return x_train_matrix, x_test_matrix, y_train_matrix, y_test_matrix\",\n \"def compute_matrix(phi): # pylint: disable=arguments-differ\\n if qml.math.get_interface(phi) == \\\"tensorflow\\\":\\n phi = qml.math.cast_like(phi, 1j)\\n\\n e = qml.math.exp(1j * phi)\\n\\n return qml.math.stack(\\n [\\n stack_last([1, 0, 0, 0]),\\n stack_last([0, 0, e, 0]),\\n stack_last([0, e, 0, 0]),\\n stack_last([0, 0, 0, 1]),\\n ],\\n axis=-2,\\n )\",\n \"def rotation_matrix(rotate):\\n tx, ty, tz = rotate\\n Rx = np.array([[1, 0, 0], [0, np.cos(tx), -np.sin(tx)], [0, np.sin(tx), np.cos(tx)]])\\n Ry = np.array([[np.cos(ty), 0, -np.sin(ty)], [0, 1, 0], [np.sin(ty), 0, np.cos(ty)]])\\n Rz = np.array([[np.cos(tz), -np.sin(tz), 0], [np.sin(tz), np.cos(tz), 0], [0, 0, 1]])\\n return np.dot(Rx, np.dot(Ry, Rz))\",\n \"def transl(x, y=None, z=None):\\n \\n if y == None and z == None:\\n x = mat(x)\\n try:\\n if ishomog(x):\\n return x[0:3, 3].reshape(3, 1)\\n else:\\n return concatenate((concatenate((eye(3), x.reshape(3, 1)), 1), mat([0, 0, 0, 1])))\\n except AttributeError:\\n n = len(x)\\n r = [[], [], []]\\n for i in range(n):\\n r = concatenate((r, x[i][0:3, 3]), 1)\\n return r\\n elif y != None and z != None:\\n return concatenate((concatenate((eye(3), mat([x, y, z]).T), 1), mat([0, 0, 0, 1])))\",\n \"def Translate(self, *args):\\n return _itkTranslationTransformPython.itkTranslationTransformD2_Translate(self, *args)\",\n \"def similarity_transformation(rot, mat):\\n return np.dot(rot, np.dot(mat, np.linalg.inv(rot)))\",\n \"def similarity_transformation(rot, mat):\\n return np.dot(rot, np.dot(mat, np.linalg.inv(rot)))\",\n \"def _get_transformation_matrix(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):\\n\\n # CONVERT DEGREES TO RADIANS\\n rotation = math.pi * rotation / 180.\\n shear = math.pi * shear / 180.\\n\\n # ROTATION MATRIX\\n c1 = tf.math.cos(rotation)\\n s1 = tf.math.sin(rotation)\\n one = tf.constant([1], dtype='float32')\\n zero = tf.constant([0], dtype='float32')\\n rotation_matrix = tf.reshape(tf.concat([\\n c1, s1, zero, -s1, c1, zero, zero, zero, one\\n ], axis=0), [3, 3])\\n\\n # SHEAR MATRIX\\n c2 = tf.math.cos(shear)\\n s2 = tf.math.sin(shear)\\n shear_matrix = tf.reshape(tf.concat([\\n one, s2, zero, zero, c2, zero, zero, zero, one\\n ], axis=0), [3, 3])\\n\\n # ZOOM MATRIX\\n zoom_matrix = tf.reshape(tf.concat([\\n one/height_zoom, zero, zero, zero, one/width_zoom, zero, zero, zero, one\\n ], axis=0), [3, 3])\\n\\n # SHIFT MATRIX\\n shift_matrix = tf.reshape(tf.concat([\\n one, zero, height_shift, zero, one, width_shift, zero, zero, one\\n ], axis=0), [3, 3])\\n\\n return keras.backend.dot(\\n keras.backend.dot(rotation_matrix, shear_matrix),\\n keras.backend.dot(zoom_matrix, shift_matrix))\",\n \"def affine_matrix(self) -> np.ndarray:\\n return self._tf_matrix\",\n \"def _apply_transformations(structure, rotations, translations):\\n # Additional first dimension for 'structure.repeat()'\\n assembly_coord = np.zeros((len(rotations),) + structure.coord.shape)\\n\\n # Apply corresponding transformation for each copy in the assembly\\n for i, (rotation, translation) in enumerate(zip(rotations, translations)):\\n coord = structure.coord\\n # Rotate\\n coord = matrix_rotate(coord, rotation)\\n # Translate\\n coord += translation\\n assembly_coord[i] = coord\\n\\n return repeat(structure, assembly_coord)\",\n \"def matrix_math_api_examples():\\n \\n print(dingbat.vec2())\\n print(dingbat.vec2(array.array('f', (20, 40))))\\n print(dingbat.mat3())\\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\\n translate = dingbat.translation_matrix(-10, -20, -30)\\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\\n scale = dingbat.scale_matrix(100, 200, 300)\\n print(translate)\\n print(rotate)\\n print(scale)\\n print(dingbat.multiply_matrices(translate, rotate, scale))\",\n \"def form_matrix_yt(w):\\r\\n M = np.zeros((len(w),len(w)))\\r\\n for i in range(len(w)):\\r\\n for j in range(len(w)):\\r\\n M[i,j] = YoungTableaux(w[i],w[j]).CMNR()\\r\\n return M\",\n \"def get_transition_matrix(self):\\n # Transition matrix\\n P_trans = np.zeros((self.n_states, self.n_states))\\n\\n # Fill\\n for s_num in range(2, (2**self.depth)):\\n P_trans[(s_num - 1), (s_num//2 - 1)] = 1.0\\n\\n return P_trans\",\n \"def homog_trans_mtx(x: float, y: float, z: float) -> numpy.array:\\n return numpy.array(\\n ((1, 0, 0, x), (0, 1, 0, y), (0, 0, 1, z), (0, 0, 0, 1)), dtype=numpy.float64\\n )\",\n \"def get_warp_matrix(theta, size_input, size_dst, size_target):\\n theta = np.deg2rad(theta)\\n matrix = np.zeros((2, 3), dtype=np.float32)\\n scale_x = size_dst[0] / size_target[0]\\n scale_y = size_dst[1] / size_target[1]\\n matrix[0, 0] = math.cos(theta) * scale_x\\n matrix[0, 1] = -math.sin(theta) * scale_x\\n matrix[0, 2] = scale_x * (-0.5 * size_input[0] * math.cos(theta) + 0.5 * size_input[1] * math.sin(theta) + 0.5 * size_target[0])\\n matrix[1, 0] = math.sin(theta) * scale_y\\n matrix[1, 1] = math.cos(theta) * scale_y\\n matrix[1, 2] = scale_y * (-0.5 * size_input[0] * math.sin(theta) - 0.5 * size_input[1] * math.cos(theta) + 0.5 * size_target[1])\\n return matrix\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7476626","0.73376346","0.71156037","0.70561665","0.70042557","0.69543445","0.68936795","0.6859392","0.6858805","0.6777836","0.6776042","0.67170495","0.6642511","0.6580854","0.6550882","0.6474842","0.64231503","0.63632214","0.6332118","0.63255674","0.62962896","0.6280561","0.625345","0.6246314","0.62330186","0.6191701","0.61888635","0.6152913","0.61347926","0.61137325","0.60851395","0.6015534","0.6009208","0.59930384","0.5988898","0.5988898","0.5985642","0.59595644","0.5959437","0.5951532","0.5939825","0.59334546","0.59284943","0.5901098","0.58874685","0.58859444","0.58700365","0.5868818","0.58651817","0.5864235","0.58608454","0.58570904","0.58437455","0.58293253","0.5827617","0.5818062","0.5816618","0.57988465","0.5788908","0.5741136","0.57313734","0.57264715","0.5704579","0.5697148","0.5697148","0.5693883","0.568846","0.56792855","0.5677406","0.5677406","0.5671304","0.5633062","0.5620673","0.5617164","0.5592682","0.5588784","0.5585997","0.5585229","0.5584018","0.5564121","0.5552061","0.55481386","0.5536149","0.5535718","0.55287445","0.5525717","0.5525562","0.55234134","0.55208683","0.55169916","0.5507676","0.5507676","0.55015177","0.5499928","0.5499164","0.5498285","0.5489467","0.54833126","0.54826814","0.54715"],"string":"[\n \"0.7476626\",\n \"0.73376346\",\n \"0.71156037\",\n \"0.70561665\",\n \"0.70042557\",\n \"0.69543445\",\n \"0.68936795\",\n \"0.6859392\",\n \"0.6858805\",\n \"0.6777836\",\n \"0.6776042\",\n \"0.67170495\",\n \"0.6642511\",\n \"0.6580854\",\n \"0.6550882\",\n \"0.6474842\",\n \"0.64231503\",\n \"0.63632214\",\n \"0.6332118\",\n \"0.63255674\",\n \"0.62962896\",\n \"0.6280561\",\n \"0.625345\",\n \"0.6246314\",\n \"0.62330186\",\n \"0.6191701\",\n \"0.61888635\",\n \"0.6152913\",\n \"0.61347926\",\n \"0.61137325\",\n \"0.60851395\",\n \"0.6015534\",\n \"0.6009208\",\n \"0.59930384\",\n \"0.5988898\",\n \"0.5988898\",\n \"0.5985642\",\n \"0.59595644\",\n \"0.5959437\",\n \"0.5951532\",\n \"0.5939825\",\n \"0.59334546\",\n \"0.59284943\",\n \"0.5901098\",\n \"0.58874685\",\n \"0.58859444\",\n \"0.58700365\",\n \"0.5868818\",\n \"0.58651817\",\n \"0.5864235\",\n \"0.58608454\",\n \"0.58570904\",\n \"0.58437455\",\n \"0.58293253\",\n \"0.5827617\",\n \"0.5818062\",\n \"0.5816618\",\n \"0.57988465\",\n \"0.5788908\",\n \"0.5741136\",\n \"0.57313734\",\n \"0.57264715\",\n \"0.5704579\",\n \"0.5697148\",\n \"0.5697148\",\n \"0.5693883\",\n \"0.568846\",\n \"0.56792855\",\n \"0.5677406\",\n \"0.5677406\",\n \"0.5671304\",\n \"0.5633062\",\n \"0.5620673\",\n \"0.5617164\",\n \"0.5592682\",\n \"0.5588784\",\n \"0.5585997\",\n \"0.5585229\",\n \"0.5584018\",\n \"0.5564121\",\n \"0.5552061\",\n \"0.55481386\",\n \"0.5536149\",\n \"0.5535718\",\n \"0.55287445\",\n \"0.5525717\",\n \"0.5525562\",\n \"0.55234134\",\n \"0.55208683\",\n \"0.55169916\",\n \"0.5507676\",\n \"0.5507676\",\n \"0.55015177\",\n \"0.5499928\",\n \"0.5499164\",\n \"0.5498285\",\n \"0.5489467\",\n \"0.54833126\",\n \"0.54826814\",\n \"0.54715\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5711762"},"document_rank":{"kind":"string","value":"62"}}},{"rowIdx":84685,"cells":{"query":{"kind":"string","value":"Transforms a batch of 3D points with a batch of matrices."},"document":{"kind":"string","value":"def transform_points_homogeneous(points: InputTensor,\n matrix: InputTensor, w: float) -> t.Tensor:\n points = util.to_tensor(points, dtype=t.float32)\n matrix = util.to_tensor(matrix, dtype=t.float32)\n assert points.shape[-1] == 3\n assert matrix.shape[-2:] == (4, 4)\n assert points.shape[:-2] == matrix.shape[:-2]\n\n batch_dims = points.shape[:-2]\n # Fold all batch dimensions into a single one\n points = points.reshape([-1] + list(points.shape[-2:]))\n matrix = matrix.reshape([-1] + list(matrix.shape[-2:]))\n\n points = t.constant_pad_nd(points, [0, 1], value=w)\n result = t.einsum(\"bnm,bvm->bvn\", matrix, points)\n result = result.reshape(batch_dims + result.shape[-2:])\n\n return result"},"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 apply_transformation(self, points):\n assert (points.shape[0] == 3)\n n = points.shape[1]\n points_ = np.vstack((points, np.ones((1, n))))\n points_trans_ = np.matmul(self.pose_mat, points_)\n points_transformed = np.true_divide(points_trans_[:3, :], points_trans_[[-1], :])\n return points_transformed","def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n shape_pc = batch_data[k, ...]\n rotation_matrix = rotation_matrices[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def transform_points(points, transf_matrix):\n if points.shape[0] not in [3, 4]:\n raise Exception(\n \"Points input should be (3,N) or (4,N) shape, received {}\".format(\n points.shape\n )\n )\n return transf_matrix.dot(np.vstack((points[:3, :], np.ones(points.shape[1]))))[\n :3, :\n ]","def transform_points(transf_matrix, points):\n if(type(points)==list):\n temp_pts = [np.array([x[0],x[1],x[2],1]) for x in points]\n newpts = []\n for pt in temp_pts:\n newpts.append((transf_matrix@pt)[:3])\n else:\n temp_pts = np.array([points[0],points[1],points[2],1])\n newpts=(transf_matrix@temp_pts)[:3]\n return newpts","def transform_points(self, points3d: np.ndarray) -> np.ndarray:\n assert self._r is not None\n assert self._t is not None\n assert isinstance(points3d, np.ndarray)\n\n if points3d.shape[1] == 6: # expunge RGB\n points3d = points3d[:, 0:3]\n points3d = points3d.transpose()\n rotation_matrix = np.empty((3, 3), dtype=float)\n rotation_as_np = np.array([self.r.w, self.r.x, self.r.y, self.r.z])\n _as_rotation_matrix_njit(rotation_as_np, rotation_matrix)\n points3d = np.add(np.matmul(rotation_matrix, points3d), self.t)\n return points3d.transpose()","def transform_pt_array(point_array,M):\n \n original_shape = point_array.shape\n \n num_points = int(np.size(point_array,0)*np.size(point_array,1)/2)\n # resize array into N x 2 array\n reshaped = point_array.reshape((num_points,2)) \n \n # add third row\n ones = np.ones([num_points,1])\n points3d = np.concatenate((reshaped,ones),1)\n \n # transform points\n tf_points3d = np.transpose(np.matmul(M,np.transpose(points3d)))\n \n # condense to two-dimensional coordinates\n tf_points = np.zeros([num_points,2])\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\n \n tf_point_array = tf_points.reshape(original_shape)\n \n return tf_point_array","def transform_pc3d(pcl_c3d, Ts, seq_n, K_cur, batch_n):\n\n ## need to transform: flat.uvb, flat.feature['xyz'], flat.feature['normal']\n ## no need to transform grid features\n \n assert batch_n % seq_n == 0 # mode==0\n n_group = batch_n // seq_n\n\n ## get relative pose\n T, R, t, target_id = relative_T(Ts, seq_n, batch_n)\n\n ## get accumulative length\n nb = pcl_c3d.flat.nb\n acc_b = []\n acc = 0\n acc_b.append( acc )\n for ib in range(batch_n):\n acc = acc + nb[ib]\n acc_b.append( acc )\n\n ## process flat features\n flat_xyz = pcl_c3d.flat.feature['xyz'] # 1*C*NB\n flat_normal = pcl_c3d.flat.feature['normal']\n trans_normal_list = []\n trans_xyz_list = []\n uvb_list = []\n new_nb = []\n for ib in range(batch_n):\n ## xyz\n trans_xyz = torch.matmul(R[ib], flat_xyz[:, :, acc_b[ib]:acc_b[ib+1]]) + t[ib]\n mask_positive = trans_xyz[0, 2, :] > 0\n trans_xyz = trans_xyz[:, :, mask_positive]\n trans_xyz_list.append(trans_xyz)\n new_nb.append(trans_xyz.shape[2])\n\n ## normal\n trans_normal = torch.matmul(R[ib], flat_normal[:, :, acc_b[ib]:acc_b[ib+1]])\n trans_normal = trans_normal[:, :, mask_positive]\n trans_normal_list.append(trans_normal)\n\n ## project to uv, add b\n uvb = torch.matmul(K_cur[ib], trans_xyz)\n uvb[:, :2] = uvb[:, :2] / uvb[:, [2]] #- 1 , commented because in dataset_read.py there is a K_mat2py() function converting K from matlab to python coordinate\n uvb[:, 2, :] = target_id[ib]\n uvb_list.append(uvb)\n\n ## construct the new object\n tr_pcl_c3d = PCL_C3D_Flat()\n tr_pcl_c3d.feature['xyz'] = torch.cat(trans_xyz_list, dim=2)\n tr_pcl_c3d.feature['normal'] = torch.cat(trans_normal_list, dim=2)\n tr_pcl_c3d.uvb = torch.cat(uvb_list, dim=2)\n tr_pcl_c3d.nb = new_nb\n\n for feat_key in pcl_c3d.flat.feature:\n if feat_key not in ['xyz', 'normal']:\n tr_pcl_c3d.feature[feat_key] = pcl_c3d.flat.feature[feat_key]\n\n return tr_pcl_c3d","def fun(params,n_cameras,n_points,camera_indices,point_indices,points_3d , points_2d):\n camera_params = params[:n_cameras * 6].reshape((n_cameras, 6))\n # points_3d = points_3d.T\n # points_3d = params[n_cameras * 7:].reshape((n_points, 3))\n # print(point_indices)\n points_proj = project(points_3d[point_indices], camera_params[camera_indices])\n return (points_proj - points_2d).ravel()","def transform_obj_list(object_list,M,M2 = None):\n \n for i, obj in enumerate(object_list):\n points = obj.all\n num_points = len(points)\n \n \n # add third row\n ones = np.ones([num_points,1])\n points3d = np.concatenate((points,ones),1)\n points3d = points3d[:,[0,1,4]]\n # transform points\n tf_points3d = np.transpose(np.matmul(M,np.transpose(points3d)))\n \n # condense to two-dimensional coordinates\n tf_points = np.zeros([num_points,2])\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\n \n object_list[i].all_world = tf_points\n \n if M2 is not None:\n tf_points3d = np.transpose(np.matmul(M2,np.transpose(points3d)))\n \n # condense to two-dimensional coordinates\n tf_points = np.zeros([num_points,2])\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\n \n object_list[i].all_gps = tf_points\n \n return object_list","def transform( self, matrix3 ):\n self._coords = matrix3._matrix * self._coords\n return self","def _transform(self, matrix):\n for x in list(self.keys()):\n ar = self[x]\n if len(ar.shape) == 2 and ar.shape[1] == 3:\n self[x] = np.dot(matrix, ar.transpose()).transpose()","def matrix_apply_to_3d_3x3(vol, matrix: np.matrix):\n from scipy import mgrid\n\n cx = vol.shape[0]/2\n cy = vol.shape[1]/2\n cz = vol.shape[2]/2\n\n # Calculate the new coordinates of every point\n grid = mgrid[-cx:vol.shape[0]-cx, -cy:vol.shape[1]-cy, -cz:vol.shape[2]-cz]\n temp = grid.reshape((3, grid.size / 3))\n # Add the fourth dimension (just 1s but needed for the computations)\n # Use the matrix to calculate the new positions of every point\n temp = np.dot(matrix, temp)\n # Delete the fourth dimension\n temp = np.array(temp)\n grid = np.reshape(temp, (3, vol.shape[0], vol.shape[1], vol.shape[2]))\n\n grid[0] += cx\n grid[1] += cy\n grid[2] += cz\n\n from scipy.ndimage.interpolation import map_coordinates\n d = map_coordinates(vol, grid, order=3)\n\n return d","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def trans_to_coordinates(T, pts):\n p = []\n for i in range(len(pts)):\n \n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\n p_a = np.matmul(T, p_b).tolist()\n p.append(p_a[0:3])\n\n return p","def transform(self, X):\n X = check_tensor(X, dtype=np.float32, n_dim=4)\n if self.batch_size is None:\n if self.force_reshape:\n return self.transform_function(X.transpose(\n *self.transpose_order))[0].reshape((len(X), -1))\n else:\n return self.transform_function(\n X.transpose(*self.transpose_order))\n else:\n XT = X.transpose(*self.transpose_order)\n n_samples = XT.shape[0]\n for i in range(0, n_samples, self.batch_size):\n transformed_batch = self.transform_function(\n XT[i:i + self.batch_size])\n # at first iteration, initialize output arrays to correct size\n if i == 0:\n shapes = [(n_samples,) + t.shape[1:] for t in\n transformed_batch]\n ravelled_shapes = [np.prod(shp[1:]) for shp in shapes]\n if self.force_reshape:\n output_width = np.sum(ravelled_shapes)\n output = np.empty((n_samples, output_width),\n dtype=transformed_batch[0].dtype)\n break_points = np.r_([0], np.cumsum(ravelled_shapes))\n raw_output = [\n output[:, start:stop] for start, stop in\n zip(break_points[:-1], break_points[1:])]\n else:\n output = [np.empty(shape,\n dtype=transformed_batch.dtype)\n for shape in shapes]\n raw_output = [arr.reshape(n_samples, -1)\n for arr in output]\n\n for transformed, out in zip(transformed_batch, raw_output):\n out[i:i + batch_size] = transformed\n return output","def apply_transform_on_3d_image(image: torch.Tensor, transforms: List[Callable]) -> torch.Tensor:\n for z in range(image.shape[0]):\n pil = TF.to_pil_image(image[z])\n for transform_fn in transforms:\n pil = transform_fn(pil)\n image[z] = TF.to_tensor(pil).squeeze()\n return image","def transform_points(points, T):\n\n homo_points = np.array([(x, y, 1) for (y, x) in points])\n t_points = np.array([T.dot(v) for v in homo_points ])\n swap = np.array([(x,y) for (y,x,z) in t_points])\n return swap","def get_perspective_transform(points_src: Tensor, points_dst: Tensor) -> Tensor:\n KORNIA_CHECK_SHAPE(points_src, [\"B\", \"4\", \"2\"])\n KORNIA_CHECK_SHAPE(points_dst, [\"B\", \"4\", \"2\"])\n KORNIA_CHECK(points_src.shape == points_dst.shape, \"Source data shape must match Destination data shape.\")\n KORNIA_CHECK(points_src.dtype == points_dst.dtype, \"Source data type must match Destination data type.\")\n\n # we build matrix A by using only 4 point correspondence. The linear\n # system is solved with the least square method, so here\n # we could even pass more correspondence\n\n # create the lhs tensor with shape # Bx8x8\n B: int = points_src.shape[0] # batch_size\n\n A = torch.empty(B, 8, 8, device=points_src.device, dtype=points_src.dtype)\n\n # we need to perform in batch\n _zeros = zeros(B, device=points_src.device, dtype=points_src.dtype)\n _ones = torch.ones(B, device=points_src.device, dtype=points_src.dtype)\n\n for i in range(4):\n x1, y1 = points_src[..., i, 0], points_src[..., i, 1] # Bx4\n x2, y2 = points_dst[..., i, 0], points_dst[..., i, 1] # Bx4\n\n A[:, 2 * i] = stack([x1, y1, _ones, _zeros, _zeros, _zeros, -x1 * x2, -y1 * x2], -1)\n A[:, 2 * i + 1] = stack([_zeros, _zeros, _zeros, x1, y1, _ones, -x1 * y2, -y1 * y2], -1)\n\n # the rhs tensor\n b = points_dst.view(-1, 8, 1)\n\n # solve the system Ax = b\n X: Tensor = _torch_solve_cast(A, b)\n\n # create variable to return the Bx3x3 transform\n M = torch.empty(B, 9, device=points_src.device, dtype=points_src.dtype)\n M[..., :8] = X[..., 0] # Bx8\n M[..., -1].fill_(1)\n\n return M.view(-1, 3, 3) # Bx3x3","def TransformPoint(transform, x, y, z):\n result = np.matmul(transform, np.array([x, y, z, 1.]))\n return result[0], result[1], result[2]","def batch_affine_warp3d(imgs, theta):\n n_batch = tf.shape(imgs)[0]\n xlen = int(imgs.shape[1])\n ylen = int(imgs.shape[2])\n zlen = int(imgs.shape[3])\n theta = tf.reshape(theta, [-1, 3, 4])\n matrix = tf.slice(theta, [0, 0, 0], [-1, -1, 3])\n t = tf.slice(theta, [0, 0, 3], [-1, -1, -1])\n\n grids = batch_mgrid(n_batch, xlen, ylen, zlen)\n grids = tf.reshape(grids, [n_batch, 3, -1])\n\n ### TODO: This code has been changed from batch_matmul to matmul.\n T_g = tf.matmul(matrix, grids) + t\n T_g = tf.reshape(T_g, [n_batch, 3, xlen, ylen, zlen])\n output = batch_warp3d(imgs, T_g)\n return output","def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])","def project_points(self, points_3d, camera):\n batch_size = points_3d.shape[0]\n device = points_3d.device\n cam_t = torch.stack([camera[:, 1], camera[:, 2], 2 * self.focal_length / (self.img_res * camera[:, 0] + 1e-09)], dim=-1)\n camera_center = camera.new_zeros([batch_size, 2])\n rot_t = torch.eye(3, device=device, dtype=points_3d.dtype).unsqueeze(0).expand(batch_size, -1, -1)\n joints_2d = perspective_projection(points_3d, rotation=rot_t, translation=cam_t, focal_length=self.focal_length, camera_center=camera_center)\n return joints_2d","def MakeCoordinates3D(self):\n\n self.points = np.concatenate((self.points, np.zeros((self.points.shape[0],1)) ), axis=1)\n self.points = np.ascontiguousarray(self.points)","def collate_fn(self, batch):\n images = list()\n targets = list()\n\n for b in batch:\n images.append(b[0])\n targets.append(b[1])\n\n # images = torch.stack(images, dim=0)\n\n return images, targets # tensor (N, 3, 300, 300), 3 lists of N tensors each","def scale_and_translate_points(points):\n x = points[0]\n y = points[1]\n center = points.mean(axis=1) # mean of each row\n cx = x - center[0] # center the points\n cy = y - center[1]\n dist = np.sqrt(np.power(cx, 2) + np.power(cy, 2))\n scale = np.sqrt(2) / dist.mean()\n norm3d = np.array([\n [scale, 0, -scale * center[0]],\n [0, scale, -scale * center[1]],\n [0, 0, 1]\n ])\n\n return np.dot(norm3d, points), norm3d","def projectToImage(pts_3D, P):\n pts_3D = np.reshape(pts_3D, (-1, 3))\n pts_3D = np.transpose(pts_3D)\n pts_3D = np.vstack([pts_3D, 1])\n pts_2D = np.matmul(P, pts_3D)\n pts_2D = pts_2D[:2]/pts_2D[-1]\n pts_2D = np.transpose(pts_2D)\n return pts_2D","def scale_on_3d(x3d, scaler):\n (n_segs, n_concat, n_freq) = x3d.shape\n x2d = x3d.reshape((n_segs * n_concat, n_freq))\n x2d = scaler.transform(x2d)\n x3d = x2d.reshape((n_segs, n_concat, n_freq))\n return x3d","def get_perspective_transform3d(src: Tensor, dst: Tensor) -> Tensor:\n if not isinstance(src, (Tensor)):\n raise TypeError(f\"Input type is not a Tensor. Got {type(src)}\")\n\n if not isinstance(dst, (Tensor)):\n raise TypeError(f\"Input type is not a Tensor. Got {type(dst)}\")\n\n if not src.shape[-2:] == (8, 3):\n raise ValueError(f\"Inputs must be a Bx8x3 tensor. Got {src.shape}\")\n\n if not src.shape == dst.shape:\n raise ValueError(f\"Inputs must have the same shape. Got {dst.shape}\")\n\n if not (src.shape[0] == dst.shape[0]):\n raise ValueError(f\"Inputs must have same batch size dimension. Expect {src.shape} but got {dst.shape}\")\n\n if not (src.device == dst.device and src.dtype == dst.dtype):\n raise AssertionError(\n f\"Expect `src` and `dst` to be in the same device (Got {src.dtype}, {dst.dtype}) \"\n f\"with the same dtype (Got {src.dtype}, {dst.dtype}).\"\n )\n\n # we build matrix A by using only 4 point correspondence. The linear\n # system is solved with the least square method, so here\n # we could even pass more correspondence\n p = []\n\n # 000, 100, 110, 101, 011\n for i in [0, 1, 2, 5, 7]:\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'x'))\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'y'))\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'z'))\n\n # A is Bx15x15\n A = stack(p, 1)\n\n # b is a Bx15x1\n b = stack(\n [\n dst[:, 0:1, 0],\n dst[:, 0:1, 1],\n dst[:, 0:1, 2],\n dst[:, 1:2, 0],\n dst[:, 1:2, 1],\n dst[:, 1:2, 2],\n dst[:, 2:3, 0],\n dst[:, 2:3, 1],\n dst[:, 2:3, 2],\n # dst[:, 3:4, 0], dst[:, 3:4, 1], dst[:, 3:4, 2],\n # dst[:, 4:5, 0], dst[:, 4:5, 1], dst[:, 4:5, 2],\n dst[:, 5:6, 0],\n dst[:, 5:6, 1],\n dst[:, 5:6, 2],\n # dst[:, 6:7, 0], dst[:, 6:7, 1], dst[:, 6:7, 2],\n dst[:, 7:8, 0],\n dst[:, 7:8, 1],\n dst[:, 7:8, 2],\n ],\n 1,\n )\n\n # solve the system Ax = b\n X: Tensor = _torch_solve_cast(A, b)\n\n # create variable to return\n batch_size: int = src.shape[0]\n M = torch.empty(batch_size, 16, device=src.device, dtype=src.dtype)\n M[..., :15] = X[..., 0]\n M[..., -1].fill_(1)\n\n return M.view(-1, 4, 4) # Bx4x4","def transform3D(x: float, y: float, z: float, R: np.array) -> np.array:\n T = np.zeros((4, 4))\n T[:3, :3] = R\n T[:, 3] = [x, y, z, 1.0]\n\n return T","def transform(vector3, matrix4x4):\n if numpy:\n return numpy.dot(matrix4x4, numpy.append(vector3, 1.))\n else:\n m0,m1,m2,m3 = matrix4x4; x,y,z = vector3\n return [\n m0[0]*x + m0[1]*y + m0[2]*z + m0[3],\n m1[0]*x + m1[1]*y + m1[2]*z + m1[3],\n m2[0]*x + m2[1]*y + m2[2]*z + m2[3],\n m3[0]*x + m3[1]*y + m3[2]*z + m3[3]\n ]","def estimate_affine_matrix_3d_to_2d(X, x):\n assert x.shape[0] == X.shape[0]\n assert x.shape[0] >= 4\n X = X.T # (3, n)\n x = x.T # (2, n)\n n = x.shape[1]\n\n ###---- 1. normalization\n ## 2d points\n mean = np.mean(x, 1) # (2, )\n x = x - np.tile(mean[:, np.newaxis], [1, n]) # (2, n)\n average_norm = np.mean(np.sqrt(np.sum(x ** 2, 0)))\n scale = np.sqrt(2) / average_norm\n x = scale * x\n\n # T = [[scale, 0, -mean * scale], \n # [ 0, scale, -mean * scale], \n # [ 0, 0, 1 ]]\n T = np.zeros((3, 3), dtype=np.float32)\n T[0, 0] = T[1, 1] = scale\n T[:2, 2] = -mean * scale\n T[2, 2] = 1\n\n ## 3d points\n X_homo = np.vstack((X, np.ones((1, n)))) # (4, n)\n mean = np.mean(X, 1) # (3, )\n X = X - np.tile(mean[:, np.newaxis], [1, n]) # (3, n)\n m = X_homo[: 3, :] - X\n average_norm = np.mean(np.sqrt(np.sum(X ** 2, 0)))\n scale = np.sqrt(3) / average_norm\n X = scale * X\n\n U = np.zeros((4, 4), dtype=np.float32)\n U[0, 0] = U[1, 1] = U[2, 2] = scale\n U[: 3, 3] = -mean * scale\n U[3, 3] = 1\n\n ###---- 2. equations\n A = np.zeros((n * 2, 8), dtype=np.float32)\n X_homo = np.vstack((X, np.ones((1, n)))).T\n A[: n, : 4] = X_homo\n A[n: , 4: ] = X_homo\n b = np.reshape(x, [-1, 1]) # (2n, 1)\n\n ###---- 3.solution\n p_8 = np.linalg.pinv(A).dot(b) # (8, 2n) x (2n, 1) -> (8, 1)\n p = np.zeros((3, 4), dtype=np.float32)\n p[0, :] = p_8[:4, 0]\n p[1, :] = p_8[4:, 0]\n p[-1, -1] = 1\n\n ###---- 4. denormalization\n P_Affine = np.linalg.inv(T).dot(p.dot(U))\n return P_Affine","def collate_fn(self, batch):\n images = list()\n boxes = list()\n labels = list()\n difficulties = list()\n\n for b in batch:\n images.append(b[0])\n boxes.append(b[1])\n labels.append(b[2])\n difficulties.append(b[3])\n\n images = torch.stack(images, dim=0)\n\n return images, boxes, labels, difficulties # tensor (N, 3, 300, 300), 3 lists of N tensors each","def apply_transform_xy(transform, xy):\n # Get number of points, store as n\n n = len(xy)\n\n # _xy is the transformed xy in inplied 3d vector form\n _xy = np.hstack([xy, np.ones([n,1])])\n\n # Apply transformation to all points\n points = transform.dot(_xy.T)\n\n return points[:2].T","def __set_transform_matrices(self):\n self.tf_matrices_list = []\n\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\n for i in range(self.joint_count):\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\n self.tf_matrices_list.append(transform_matrix)","def matmul3d(X, W):\n Xr = tf.reshape(X, [-1, tf.shape(X)[2]])\n XWr = tf.matmul(Xr, W)\n newshape = [tf.shape(X)[0], tf.shape(X)[1], tf.shape(W)[1]]\n return tf.reshape(XWr, newshape)","def matmul3d(X, W):\n Xr = tf.reshape(X, [-1, tf.shape(X)[2]])\n XWr = tf.matmul(Xr, W)\n newshape = [tf.shape(X)[0], tf.shape(X)[1], tf.shape(W)[1]]\n return tf.reshape(XWr, newshape)","def apply(self, points):\n pshape = numpy.shape(points)\n homogeneous = 1\n if len(pshape) == 1:\n if pshape[0] == 3:\n points = numpy.array(numpy.concatenate((points, numpy.ones(1, 'f')), 1))\n homogeneous = 0\n elif len(pshape) == 2:\n if pshape[1] == 3:\n points = numpy.array(numpy.concatenate(\n (numpy.array(points), numpy.ones((pshape[0], 1), 'f')), 1))\n homogeneous = 0\n mtx = self.getMatrix((4, 4), transpose=1)\n newpoints = numpy.dot(points, mtx)\n if homogeneous:\n return newpoints\n else:\n # strip the final one off the coordinates\n if len(pshape) == 1:\n return newpoints[:3]\n else:\n newpoints = [x[:3] for x in newpoints]\n return newpoints","def move_and_process_input(batch):\n x, y = batch\n x = x.to(device).float()\n y = torch.as_tensor(y).to(device)\n x = x.permute(0, -1, 1, 2, 3)\n return x, y","def TransformPoints(tFormMat,pts):\n pts = numpy.array(pts)\n nPts = len(pts)\n avgP = sum(pts)/nPts\n pts = pts - avgP\n res = [None]*nPts\n for i in range(nPts):\n res[i] = numpy.dot(tFormMat,pts[i])\n\n return res","def _flatten_batch(self, matrix_tups):\n out_vecs = []\n for t in matrix_tups:\n for v in t:\n new_shape = (v.shape[0],)\n if len(v.shape) > 1:\n new_shape = new_shape + (np.prod(v.shape[1:]),)\n out_vecs.append(v.reshape(new_shape))\n return jnp.concatenate(out_vecs, axis=1)","def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\n p1 = np.asarray(p1)\n p2 = np.asarray(p2)\n p3 = np.asarray(p3)\n\n # get vectors in plane\n v1 = p3 - p1\n v2 = p2 - p1\n\n # compute cross product\n cp = np.cross(v1, v2)\n a, b, c = cp # normal to plane is ax + by + cz\n\n # evaluate d\n d = np.dot(cp, p3)\n\n # thus, normal is given by\n plane = vtk.vtkPlane()\n origin = p1\n normal = normalize(np.array([a,b,c]))\n plane.SetOrigin(p1)\n plane.SetNormal(normal)\n\n if numpoints == 1:\n proj = [0,0,0]\n plane.ProjectPoint(points, origin, normal, proj)\n return proj\n else:\n projected_pts = np.zeros((numpoints, 3), dtype=float)\n\n for i in range(numpoints):\n proj = [0,0,0]\n plane.ProjectPoint(points[i], origin, normal, proj)\n projected_pts[i] = proj\n\n return projected_pts","def scale_point_cloud(batch_data, batch_label):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n scale_num = np.random.uniform() * 5\n rotation_matrix = np.array([[scale_num, 0, 0],\n [0, scale_num, 0],\n [0, 0, scale_num]])\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\n \n return rotated_data, rotated_label","def convert_1d_to_3d(data_X, data_Y):\n\n data_X = data_X.tocsr()\n \n data_dim_x = [] # slices along x-axis (has shape of (total_trials * dim_x, dim_z, dim_y))\n data_dim_x_label = [] # contains (total_trials * dim_x) labels\n data_dim_y = [] # slices along y-axis (has shape of (total_trials * dim_y, dim_z, dim_x))\n data_dim_y_label = [] # contains (total_trials * dim_y) labels\n data_dim_z = [] # slices along z-axis (has shape of (total_trials * dim_z, dim_y, dim_x))\n data_dim_z_label = [] # contains (total_trials * dim_z) labels\n\n for num_trial in range(data_X.shape[0]):\n label = data_Y[num_trial]\n data_1d = data_X[num_trial]\n data_3d = np.squeeze(np.asarray(data_1d.todense())).reshape((dim_z, dim_y, dim_x))\n for x in range(dim_x):\n x_slice = data_3d[:,:,x]\n # append only if the slice is not empty \n if x_slice.sum() != 0:\n data_dim_x.append(data_3d[:, :, x])\n data_dim_x_label.append(label)\n for y in range(dim_y):\n y_slice = data_3d[:, y, :]\n if y_slice.sum() != 0:\n data_dim_y.append(data_3d[:, y, :])\n data_dim_y_label.append(label)\n for z in range(dim_z):\n z_slice = data_3d[:, :, z]\n if z_slice.sum() != 0:\n data_dim_z.append(data_3d[z, :, :])\n data_dim_z_label.append(label)\n\n return np.array(data_dim_x), np.array(data_dim_x_label), \\\n np.array(data_dim_y), np.array(data_dim_y_label), \\\n np.array(data_dim_z), np.array(data_dim_z_label)","def test_3d_tranpose(): \n dic,data = ng.pipe.read_lowmem(\"common_data/3d_pipe/ft/test%03d.ft3\")\n fdic,fdata = ng.pipe.read(\"common_data/3d_pipe/ft/test%03d.ft3\")\n\n assert_array_equal(data.transpose()[0,1,2],fdata.transpose()[0,1,2])\n assert_array_equal(data.transpose((2,0,1))[0,1,2],\n fdata.transpose((2,0,1))[0,1,2])\n assert_array_equal(data.swapaxes(0,1)[0,1,2],fdata.swapaxes(0,1)[0,1,2])\n assert_array_equal(data.swapaxes(2,0)[0,1,2],fdata.swapaxes(2,0)[0,1,2])","def project_points(self, points3d, withmask=False, binary_mask=True):\n if withmask:\n return Geometry.reproject_points_to_2d(\n points3d, self.rvec, self.tvec, self.K, self.w, self.h,\n distCoef=self.distCoef, binary_mask=binary_mask)\n else:\n assert type(points3d) == np.ndarray, \"Points3d has to be a numpy array\"\n\n # Treatment for empty points\n # Add row index of None points to new list and remove the empty elements\n indexes_of_empty_points = np.unique(np.where(points3d == None)[0])\n points_to_interpolate = np.float32(points3d.copy())\n points_to_interpolate = np.delete(points_to_interpolate, indexes_of_empty_points, axis=0)\n\n # Project all the points in the camera if points_to_interpolate is not empty\n if points_to_interpolate.size != 0:\n batch_size = 1000000 \n if len(points_to_interpolate) > batch_size:\n # Create batches\n num_batches = int(len(points_to_interpolate) / batch_size)\n last_batch_length = len(points_to_interpolate) % batch_size\n\n pts2d = [] \n for i in range(num_batches):\n indices = range(i*batch_size,i*batch_size + batch_size)\n\n batch = np.take(points_to_interpolate, indices, axis=0) \n pts2d_batch, _ = cv2.projectPoints(batch, self.rvec, self.tvec, self.K, self.distCoef)\n pts2d.append(pts2d_batch)\n\n if last_batch_length > 0:\n indices = range(num_batches*batch_size,num_batches*batch_size + last_batch_length)\n batch = np.take(points_to_interpolate, indices, axis=0) \n pts2d_batch, _ = cv2.projectPoints(batch, self.rvec, self.tvec, self.K, self.distCoef)\n pts2d.append(pts2d_batch)\n\n pts2d = np.concatenate(pts2d, axis=0)\n else:\n pts2d, _ = cv2.projectPoints(points_to_interpolate,\n self.rvec,\n self.tvec,\n self.K, self.distCoef)\n else:\n pts2d = np.array([])\n\n pts2d = np.squeeze(pts2d)\n if len(pts2d.shape) == 1:\n pts2d = np.expand_dims(pts2d, axis=0)\n\n # Add empty(None) points again\n pts2d = pts2d.tolist()\n for index in indexes_of_empty_points:\n pts2d.insert(index, [None, None])\n return np.array(pts2d)","def rearrange_batch(batch):\n return list(zip(*batch))","def _preprocess_data_3d(\n self, data_batch: Dict[str, Any]) -> Tuple[tf.Tensor, tf.Tensor]:\n world2grid = data_batch['world2grid']\n uniform_samples = data_batch['uniform_samples']\n near_surface_samples = data_batch['near_surface_samples']\n if 'uniform_samples_per_camera' in data_batch:\n uniform_samples_per_camera = data_batch['uniform_samples_per_camera']\n if 'near_surface_samples_per_camera' in data_batch:\n near_surface_samples_per_camera = data_batch[\n 'near_surface_samples_per_camera']\n if 'depth_xyzn_per_camera' in data_batch:\n depth_xyzn_per_camera = data_batch['depth_xyzn_per_camera']\n\n batch_size = data_batch['near_surface_samples'].shape[0]\n spatial_dims = data_batch['grid_samples'].shape[1:4]\n\n # Assume grid size is the same in all dimensions.\n grid_size = spatial_dims[0]\n\n # Generate normalized [-1, 1] coordinates for grid samples.\n _, pixels_grid = point_sampling.sample3d_all_pixels(\n spatial_dims, normalize=True)\n pixels_grid = tf.tile(pixels_grid[None, ...], [batch_size, 1, 1, 1, 1])\n data_batch['grid_samples'] = tf.concat(\n [pixels_grid, data_batch['grid_samples']], axis=-1)\n # Tensor with shape [batch_size, dim_d, dim_h, dim_w, 4], (z, y, x).\n\n # Transform to grid space [0, 127] and map grid space [-0.5, 127.5] to\n # [-1, 1].\n uniform_samples = tf.linalg.matmul(\n world2grid[:, :3, :],\n tf.transpose(\n tf.concat([\n uniform_samples[..., :3],\n tf.ones(\n [batch_size, tf.shape(uniform_samples)[1], 1],\n dtype=tf.float32)\n ],\n axis=-1), [0, 2, 1]))\n # Tensor with shape [batch_size, 3, num_point].\n\n uniform_samples = (uniform_samples + 0.5) * 2.0 / grid_size - 1\n uniform_samples = uniform_samples[:, ::-1, :] # Convert to (z, y, x).\n uniform_samples = tf.concat([\n tf.transpose(uniform_samples, [0, 2, 1]),\n data_batch['uniform_samples'][..., 3:]\n ],\n axis=-1)\n data_batch['uniform_samples'] = uniform_samples\n\n near_surface_samples = tf.linalg.matmul(\n world2grid[:, :3, :],\n tf.transpose(\n tf.concat([\n near_surface_samples[..., :3],\n tf.ones([batch_size,\n tf.shape(near_surface_samples)[1], 1],\n dtype=tf.float32)\n ],\n axis=-1), [0, 2, 1]))\n near_surface_samples = (near_surface_samples + 0.5) * 2.0 / grid_size - 1\n near_surface_samples = near_surface_samples[:, ::-1, :]\n near_surface_samples = tf.concat([\n tf.transpose(near_surface_samples, [0, 2, 1]),\n data_batch['near_surface_samples'][..., 3:]\n ],\n axis=-1)\n data_batch['near_surface_samples'] = near_surface_samples\n\n if 'uniform_samples_per_camera' in data_batch:\n num_view = tf.shape(uniform_samples_per_camera)[1]\n num_point_per_view = tf.shape(uniform_samples_per_camera)[2]\n num_channel = tf.shape(uniform_samples_per_camera)[3]\n uniform_samples_per_camera = tf.reshape(uniform_samples_per_camera,\n [batch_size, -1, num_channel])\n uniform_samples_per_camera = tf.linalg.matmul(\n world2grid[:, :3, :],\n tf.transpose(\n tf.concat([\n uniform_samples_per_camera[..., :3],\n tf.ones(\n [batch_size,\n tf.shape(uniform_samples_per_camera)[1], 1],\n dtype=tf.float32)\n ],\n axis=-1), [0, 2, 1]))\n uniform_samples_per_camera = (uniform_samples_per_camera +\n 0.5) * 2.0 / grid_size - 1\n uniform_samples_per_camera = uniform_samples_per_camera[:, ::-1, :]\n uniform_samples_per_camera = tf.reshape(\n tf.transpose(uniform_samples_per_camera, [0, 2, 1]),\n [batch_size, num_view, num_point_per_view, -1])\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\n\n uniform_samples_per_camera = tf.concat([\n uniform_samples_per_camera,\n data_batch['uniform_samples_per_camera'][..., 3:]\n ],\n axis=-1)\n data_batch['uniform_samples_per_camera'] = uniform_samples_per_camera\n\n if 'near_surface_samples_per_camera' in data_batch:\n num_view = tf.shape(near_surface_samples_per_camera)[1]\n num_point_per_view = tf.shape(near_surface_samples_per_camera)[2]\n num_channel = tf.shape(near_surface_samples_per_camera)[3]\n near_surface_samples_per_camera = tf.reshape(\n near_surface_samples_per_camera, [batch_size, -1, num_channel])\n near_surface_samples_per_camera = tf.linalg.matmul(\n world2grid[:, :3, :],\n tf.transpose(\n tf.concat([\n near_surface_samples_per_camera[..., :3],\n tf.ones([\n batch_size,\n tf.shape(near_surface_samples_per_camera)[1], 1\n ],\n dtype=tf.float32)\n ],\n axis=-1), [0, 2, 1]))\n near_surface_samples_per_camera = (near_surface_samples_per_camera +\n 0.5) * 2.0 / grid_size - 1\n near_surface_samples_per_camera = near_surface_samples_per_camera[:, ::\n -1, :]\n near_surface_samples_per_camera = tf.reshape(\n tf.transpose(near_surface_samples_per_camera, [0, 2, 1]),\n [batch_size, num_view, num_point_per_view, -1])\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\n\n near_surface_samples_per_camera = tf.concat([\n near_surface_samples_per_camera,\n data_batch['near_surface_samples_per_camera'][..., 3:]\n ],\n axis=-1)\n data_batch[\n 'near_surface_samples_per_camera'] = near_surface_samples_per_camera\n\n if 'depth_xyzn_per_camera' in data_batch:\n num_view = tf.shape(depth_xyzn_per_camera)[1]\n num_point_per_view = tf.shape(depth_xyzn_per_camera)[2]\n num_channel = tf.shape(depth_xyzn_per_camera)[3]\n depth_xyzn_per_camera = tf.reshape(depth_xyzn_per_camera,\n [batch_size, -1, num_channel])\n depth_xyzn_per_camera = tf.linalg.matmul(\n world2grid[:, :3, :],\n tf.transpose(\n tf.concat([\n depth_xyzn_per_camera[..., :3],\n tf.ones([batch_size,\n tf.shape(depth_xyzn_per_camera)[1], 1],\n dtype=tf.float32)\n ],\n axis=-1), [0, 2, 1]))\n depth_xyzn_per_camera = (depth_xyzn_per_camera +\n 0.5) * 2.0 / grid_size - 1\n depth_xyzn_per_camera = depth_xyzn_per_camera[:, ::-1, :]\n depth_xyzn_per_camera = tf.reshape(\n tf.transpose(depth_xyzn_per_camera, [0, 2, 1]),\n [batch_size, num_view, num_point_per_view, -1])\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\n\n depth_xyzn_per_camera = tf.concat(\n [depth_xyzn_per_camera, data_batch['depth_xyzn_per_camera'][..., 3:]],\n axis=-1)\n data_batch['depth_xyzn_per_camera'] = depth_xyzn_per_camera\n\n # Scale SDF\n data_batch['grid_samples'] = data_batch['grid_samples'] * \\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, None, :]\n data_batch['uniform_samples'] = data_batch['uniform_samples'] * \\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, :]\n data_batch['near_surface_samples'] = data_batch['near_surface_samples'] * \\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, :]\n if 'uniform_samples_per_camera' in data_batch:\n data_batch['uniform_samples_per_camera'] = data_batch['uniform_samples_per_camera'] * \\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, :]\n if 'near_surface_samples_per_camera' in data_batch:\n data_batch['near_surface_samples_per_camera'] = data_batch['near_surface_samples_per_camera'] * \\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, :]\n\n input_data = data_batch['grid_samples'][..., 3:4]\n # Tensor with shape [batch_size, dim_d, dim_h, dim_w, 1].\n\n gt_data = input_data\n\n return input_data, gt_data","def transform(self, matrix: \"Matrix44\"):\n self.vertices = list(matrix.transform_vertices(self.vertices))\n return self","def to_torch(batch, **kwargs):\n x = torch.from_numpy(np.array(batch, dtype='float32'))\n return x.view(*x.size()[:2], -1).permute(2, 0, 1)","def TransformPoints(tFormMat, pts):\n pts = numpy.array(pts)\n nPts = len(pts)\n avgP = sum(pts) / nPts\n pts = pts - avgP\n res = [None] * nPts\n for i in range(nPts):\n res[i] = numpy.dot(tFormMat, pts[i])\n\n return res","def transform(self, data):\n self.cube = self.trf.transform(data)","def project_points(points, cam_matrix, trans, rot):\n\n # STEP 1: Transform pointcloud into new reference frame.\n points = np.dot(rot, points) + trans[:, None]\n\n # STEP 2: Project new pointcloud onto image frame using K matrix.\n # gives a 3 x N array of image plane coordinates in homogenous coordinates.\n homo_pixel_coords = np.dot(cam_matrix, points)\n\n # STEP 3: Convert homogenous coordinates to regular 2D coordinates.\n # To do this, you need to divide the first two coordinates of homo_pixel_coords\n # by the third coordinate.\n pixel_coords = homo_pixel_coords[:2] / homo_pixel_coords[2]\n\n # STEP 4: Convert to integers. Take the floor of pixel_coords then cast it\n # to an integer type, like numpy.int32\n pixel_coords = np.int32(np.floor(pixel_coords))\n\n return pixel_coords","def transform(self, matrix: Matrix3D):\n transform = self._local_transform\n transform.transformBy(matrix)\n self._reset_cache()\n return self","def transformation_matrix(self, s1, s2, s3, t1, t2, t3):\n\n s1 = np.array(s1)\n s2 = np.array(s2)\n s3 = np.array(s3)\n t1 = np.array(t1)\n t2 = np.array(t2)\n t3 = np.array(t3)\n\n Q = np.array(\n [\n [t2[0] - t1[0], t2[1] - t1[1], t2[2] - t1[2]],\n [t3[0] - t1[0], t3[1] - t1[1], t3[2] - t1[2]],\n ]\n )\n\n P = np.array([[s2[0] - s1[0], s2[1] - s1[1]], [s3[0] - s1[0], s3[1] - s1[1]]])\n\n try:\n # Invert the P matrix\n Pinv = inv(P)\n\n # Build the dot product\n T = np.dot(Pinv, Q)\n\n # Offset\n V0 = np.subtract(t2, np.transpose(s2[0:2]).dot(T))\n except Exception as e:\n self.log.error(\"An error occured during the transformation.\", exc_info=True)\n return -1, -1\n\n return T, V0","def projectToImage_kitti(pts_3D, P):\n # project in image\n mat = np.vstack((pts_3D, np.ones((pts_3D.shape[1]))))\n\n pts_2D = np.dot(P, mat)\n\n # scale projected points\n pts_2D[0, :] = pts_2D[0, :] / pts_2D[2, :]\n pts_2D[1, :] = pts_2D[1, :] / pts_2D[2, :]\n pts_2D = np.delete(pts_2D, 2, 0)\n\n return pts_2D","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 rotate_point_cloud(batch_data):\r\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\r\n for k in range(batch_data.shape[0]):\r\n rotation_angle = np.random.uniform() * 2 * np.pi\r\n cosval = np.cos(rotation_angle)\r\n sinval = np.sin(rotation_angle)\r\n rotation_matrix = np.array([[cosval, 0, sinval],\r\n [0, 1, 0],\r\n [-sinval, 0, cosval]])\r\n shape_pc = batch_data[k, ...]\r\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\r\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud_z(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, sinval, 0],\n [-sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","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","def apply_T(T, points):\n flipped = False\n if points.shape[0] != 3:\n assert points.shape[1] == 3, \"Points must be 3xN or Nx3\"\n points = points.T\n flipped = True\n points_h = np.vstack((points, np.ones_like(points[0, :])))\n points_transformed_h = np.dot(T, points_h)\n points_transformed = points_transformed_h[:-1]\n if flipped:\n return points_transformed.T\n return points_transformed","def rigid_transform_3d(xs,ys):\n assert xs.shape == ys.shape\n assert xs.shape[0] == 3, 'The points must be of dimmensionality 3'\n\n # find centroids and H\n x_centroid = np.mean(xs, axis=1)[:, np.newaxis]\n y_centroid = np.mean(ys, axis=1)[:, np.newaxis]\n \n H = (xs - x_centroid)@(ys - y_centroid).T\n\n # find rotation\n U, S, Vt = np.linalg.svd(H)\n rotation = Vt.T@U.T\n\n # handling reflection\n if np.linalg.det(rotation) < 0:\n Vt[2, :] *= -1\n rotation = np.dot(Vt.T, U.T)\n \n # find translation\n translation = y_centroid - rotation@x_centroid\n \n return translation, rotation","def transform(self, transformer):\n\t\tnew_matrix = Matrix(self.dims)\n\t\tnew_matrix.data = [transformer(copy.deepcopy(c)) for c in self.data]\n\t\treturn new_matrix","def cvt2array(tuples):\n rc = []\n for t in tuples:\n rc.append(point3d(np.float32(t[X]), np.float32(t[Y]), np.float32(t[Z])))\n return rc","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","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 points_to_matrix(points):\n points_matrix = np.matrix(points, dtype=np.float64).transpose()\n omega = np.ones(len(points), dtype=np.float64)\n points_matrix = np.matrix(np.vstack((points_matrix, omega)))\n return points_matrix","def rotate_point_cloud(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n for k in np.arange(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, 0, sinval],\n [0, 1, 0],\n [-sinval, 0, cosval]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def apply_translate( triangles, translate_tris=(0,0,0) ):\n checkShapeValidity( triangles )\n \n for i in range(len(triangles)): # each tri in triangles\n for j in range(len(triangles[i])): # each point in a tri\n for k in range(len(translate_tris)): # each axis in a point\n triangles[i][j][k] = float(triangles[i][j][k]) + float(translate_tris[k])","def translate(self, x=0, y=0, z=0):\n\t\ttranslation = np.identity(4)\n\t\ttranslation[0, 3] += x\n\t\ttranslation[1, 3] += y\n\t\ttranslation[2, 3] += z\n\t\t\n\t\tself.matrix = np.matmul(self.matrix, translation)","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 transform(self, X):\n\n t0 = time.perf_counter()\n check_is_fitted(self)\n self.check_external_components_modified()#[WARN] in d3m, primitives can \"restore\" private class variables...\n X = self._validate_data(X, accept_sparse=[\"csr\", \"csc\"], reset=False)\n t1 = time.perf_counter()\n\n if X.shape[1] != self.components_af_.shape[1]:\n raise ValueError(\n \"Impossible to perform projection:\"\n \"X at fit stage had a different number of features. \"\n \"(%s != %s)\" % (X.shape[1], self.components_af_.shape[1])\n )\n\n #X_new = safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)\n #import pdb; pdb.set_trace()\n X_af = af.interop.from_ndarray(X).as_type(self.components_af_.dtype())\n X_new = af.matmulNT(X_af, self.components_af_)\n X_new = X_new.to_ndarray()\n t2 = time.perf_counter()\n return X_new","def batch_collate_fn(batch):\n images = []\n masks = []\n \n for (image, trimap, mask) in batch:\n mask = mask.unsqueeze(0)\n trimap = trimap.unsqueeze(0)\n image = torch.cat([image, trimap], 0).unsqueeze(0)\n \n images.append(image)\n masks.append(mask)\n\n images = torch.cat(images, 0)\n masks = torch.cat(masks, 0)\n\n return (images, masks)","def collate_fn(batch):\r\n transposed = zip(*batch)\r\n lbd = lambda batch:torch.cat([torch.from_numpy(b).long() for b in batch])\r\n return [lbd(samples) for samples in transposed]","def Reproject(points, tm, rm):\n proj_cuboid = np.array(points)\n\n rmat = np.identity(3)\n rmat[0:2] = rm\n tmat = np.identity(3)\n tmat[0:2] = tm\n\n new_cuboid = np.matmul(\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\n new_cuboid = np.matmul(tmat, new_cuboid)\n new_cuboid = new_cuboid[0:2].T\n\n return new_cuboid","def Reproject(points,tm, rm):\n proj_cuboid = np.array(points)\n\n rmat = np.identity(3)\n rmat[0:2] = rm\n tmat = np.identity(3)\n tmat[0:2] = tm\n\n new_cuboid = np.matmul(\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\n new_cuboid = np.matmul(tmat, new_cuboid)\n new_cuboid = new_cuboid[0:2].T\n\n return new_cuboid","def transl(x, y, z):\n displace_vector = [[x],\n [y],\n [z]]\n return np.matrix(displace_vector)","def batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):\n joints = torch.unsqueeze(joints, dim=-1)\n rel_joints = joints.clone()\n rel_joints[:, 1:] -= joints[:, parents[1:]]\n transforms_mat = transform_mat(rot_mats.reshape(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4)\n transform_chain = [transforms_mat[:, 0]]\n for i in range(1, parents.shape[0]):\n curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i])\n transform_chain.append(curr_res)\n transforms = torch.stack(transform_chain, dim=1)\n posed_joints = transforms[:, :, :3, 3]\n joints_homogen = F.pad(joints, [0, 0, 0, 1])\n rel_transforms = transforms - F.pad(torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0])\n return posed_joints, rel_transforms","def _collate_fn(batch):\r\n batch = list(zip(*batch))\r\n batch[0] = torch.stack(batch[0])\r\n batch[1] = list(batch[1])\r\n batch[2] = torch.stack(batch[2])\r\n return tuple(batch)","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 batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):\n joints = torch.unsqueeze(joints, dim=-1)\n rel_joints = joints.clone()\n rel_joints[:, 1:] -= joints[:, parents[1:]]\n transforms_mat = transform_mat(rot_mats.view(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4)\n transform_chain = [transforms_mat[:, 0]]\n for i in range(1, parents.shape[0]):\n curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i])\n transform_chain.append(curr_res)\n transforms = torch.stack(transform_chain, dim=1)\n posed_joints = transforms[:, :, :3, 3]\n posed_joints = transforms[:, :, :3, 3]\n joints_homogen = F.pad(joints, [0, 0, 0, 1])\n rel_transforms = transforms - F.pad(torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0])\n return posed_joints, rel_transforms","def transformation(T,M):\n\n n = len(M) # Nb de lignes\n p = len(M[0]) # Nb de colonnes\n\n x1, y1 = vecteur_image(T,0,n)\n x2, y2 = vecteur_image(T,p,n)\n x3, y3 = vecteur_image(T,p,0)\n\n xmin = round(min(0,x1,x2,x3))\n xmax = round(max(0,x1,x2,x3))\n ymin = round(min(0,y1,y2,y3))\n ymax = round(max(0,y1,y2,y3))\n\n pp = xmax-xmin\n nn = ymax-ymin\n\n Tinv = inverse_matrice(T)\n\n N = [[0 for jj in range(pp)] for ii in range(nn)]\n for ii in range(nn):\n for jj in range(pp):\n j, i = vecteur_image(Tinv,jj+xmin,ii+ymin)\n j, i = floor(j), floor(i)\n if (0 <= i < n) and (0 <= j < p):\n N[ii][jj] = M[i][j] \n else:\n N[ii][jj] = 0\n\n return N","def forward(self, \n point_features,\n point_coordinates,\n keypoint_indices,\n set_indices):\n\n #print(f\"point_features: {point_features.shape}\")\n #print(f\"point_coordinates: {point_coordinates.shape}\")\n #print(f\"keypoint_indices: {keypoint_indices.shape}\")\n #print(f\"set_indices: {set_indices.shape}\")\n\n # Gather the points in a set\n point_set_features = point_features[set_indices[:, 0]]\n point_set_coordinates = point_coordinates[set_indices[:, 0]]\n point_set_keypoint_indices = keypoint_indices[set_indices[:, 1]]\n\n #point_set_keypoint_coordinates_1 = point_features[point_set_keypoint_indices[:, 0]]\n point_set_keypoint_coordinates = point_coordinates[point_set_keypoint_indices[:, 0]]\n\n point_set_coordinates = point_set_coordinates - point_set_keypoint_coordinates\n point_set_features = torch.cat([point_set_features, point_set_coordinates], axis=-1)\n\n # Step 1: Extract all vertex_features\n extracted_features = self.point_linears(point_set_features) # N x 64\n\n # Step 2: Aggerate features using scatter max method.\n #index = set_indices[:, 1].unsqueeze(-1).expand(-1, extracted_features.shape[-1]) # N x 64\n #set_features = torch.zeros((len(keypoint_indices), extracted_features.shape[-1]), device=extracted_features.device).permute(1,0).contiguous() # len x 64\n #set_features, argmax = scatter_max(extracted_features.permute(1,0), index.permute(1,0), out=set_features)\n #set_features = set_features.permute(1,0)\n\n set_features = max_aggregation_fn(extracted_features, set_indices[:, 1], len(keypoint_indices))\n\n # Step 3: MLP for set_features\n set_features = self.out_linears(set_features)\n return set_features","def poses_to_transforms(poses: Union[np.ndarray, List[np.ndarray]]):\n transformations = copy.deepcopy(poses)\n for i in range(len(poses)):\n if i == 0:\n transformations[i] = np.eye(4)\n else:\n transformations[i] = np.linalg.inv(poses[i - 1]).dot(poses[i])\n return transformations","def transform(self, images):\n return np.array([self.transform_single(i) for i in images])","def forward(self, x: torch.Tensor) -> torch.Tensor:\r\n output = torch.Tensor(x.shape[0], 3, x.shape[2], x.shape[3])\r\n\r\n for i in range(0, x.shape[0]):\r\n I_x = x[i][0,:,:]\r\n I_y = x[i][1,:,:]\r\n I_xx = torch.mul( x[i][0,:,:], x[i][0,:,:] )\r\n I_yy = torch.mul( x[i][1,:,:], x[i][1,:,:] )\r\n I_xy = torch.mul( x[i][0,:,:], x[i][1,:,:] )\r\n output[i,:,:,:] = torch.stack([I_xx, I_yy, I_xy]).unsqueeze(0)\r\n\r\n return output","def transform(dataset):\n\n from tomviz import utils\n import scipy.ndimage\n import numpy as np\n import warnings\n\n array = dataset.active_scalars\n\n zoom = (0.5, 0.5, 1)\n result_shape = utils.zoom_shape(array, zoom)\n result = np.empty(result_shape, array.dtype, order='F')\n # Downsample the dataset x2 using order 1 spline (linear)\n warnings.filterwarnings('ignore', '.*output shape of zoom.*')\n scipy.ndimage.interpolation.zoom(array, zoom,\n output=result,\n order=1,\n mode='constant',\n cval=0.0, prefilter=False)\n\n # Set the result as the new scalars.\n dataset.active_scalars = result","def transform_batch(self, inputs_batch, target_ids_batch, targets_batch):\n # extract one-hot encoded feature vectors and reshape them\n # so we can feed them to the RNN\n batch_inputs = inputs_batch.toarray()\n batch_inputs = batch_inputs.reshape(\n self.batch_size, self.max_num_ans, self.encoding_dim)\n # targets_batch is a list of lists, which we need to flatten\n batch_targets = [i for sublist in targets_batch for i in sublist]\n batch_targets = np.array(batch_targets, dtype=np.float32)\n # during learning, the data for each student in a batch gets shuffled together\n # hence, we need a vector of indices to locate their predictions after learning\n batch_target_ids = target_ids_batch.toarray()\n batch_target_ids = np.array(\n batch_target_ids.reshape(-1),\n dtype=np.int32)\n\n return batch_inputs, batch_target_ids, batch_targets","def transl(x, y=None, z=None):\n \n if y == None and z == None:\n x = mat(x)\n try:\n if ishomog(x):\n return x[0:3, 3].reshape(3, 1)\n else:\n return concatenate((concatenate((eye(3), x.reshape(3, 1)), 1), mat([0, 0, 0, 1])))\n except AttributeError:\n n = len(x)\n r = [[], [], []]\n for i in range(n):\n r = concatenate((r, x[i][0:3, 3]), 1)\n return r\n elif y != None and z != None:\n return concatenate((concatenate((eye(3), mat([x, y, z]).T), 1), mat([0, 0, 0, 1])))","def patches_from_3d_points(self, points, patch_size):\n patch_centers = np.round(project(self.camera.P, points.T)).astype(int)\n\n patches = self.patches(patch_centers, patch_size)\n return patches","def three_vec3_to_mat3(f: vec3, l: vec3, u: vec3) -> mat3:\r\n return mat3(f[0], l[0], u[0], f[1], l[1], u[1], f[2], l[2], u[2])","def prepare_data(cameras, frame_points_3d, frame_points_2d, keyframe_idx):\n camera_params = np.empty((0, 9))\n for c in cameras:\n R, _ = cv2.Rodrigues(c.R_mat)\n camera = build_camera(R, c.t)\n camera_params = np.append(camera_params, [camera], axis=0)\n\n camera_indices = []\n point_indices = []\n points_2d = np.empty((0, 2))\n points_3d = np.empty((0, 3))\n\n camera_id = 0\n pt_id_counter = 0\n for k, pts_2d in enumerate(frame_points_2d):\n if k > 0:\n halfway_idx = keyframe_idx[k] - keyframe_idx[k - 1] - 1\n points_2d = np.vstack((points_2d, frame_points_2d[k-1][halfway_idx]))\n points_3d = np.vstack((points_3d, frame_points_3d[k-1][halfway_idx]))\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-1][halfway_idx]))]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-1][halfway_idx]))]\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-1][halfway_idx])\n\n if k > 1:\n end_idx = keyframe_idx[k + 1] - keyframe_idx[k - 1] - 3\n points_2d = np.vstack((points_2d, frame_points_2d[k-2][end_idx]))\n points_3d = np.vstack((points_3d, frame_points_3d[k-2][end_idx]))\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-2][end_idx]))]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-2][end_idx]))]\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-2][end_idx])\n\n points_2d = np.vstack((points_2d, frame_points_2d[k][0]))\n points_3d = np.vstack((points_3d, frame_points_3d[k][0]))\n camera_indices += [camera_id for _ in range(pts_2d.shape[1])]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + pts_2d.shape[1])]\n\n camera_id += 1\n pt_id_counter = pt_id_counter + pts_2d.shape[1]\n\n return camera_params, np.asarray(camera_indices), np.asarray(point_indices), points_3d, points_2d","def map(self, obj):\n if isinstance(obj, np.ndarray) and obj.ndim >= 2 and obj.shape[0] in (2,3):\n return fn.transformCoordinates(self, obj)\n else:\n return QtGui.QMatrix4x4.map(self, obj)","def collate_fn(self, batch):\n images, boxes, categories = [], [], []\n\n for b in batch:\n images.append(b['img'])\n boxes.append(b['box'])\n categories.append(b['category'])\n\n images = torch.stack(images, dim=0)\n\n # tensor (N, 3, 300, 300), 3 lists of N tensors each\n return {\n 'imgs': images,\n 'boxes': boxes,\n 'categories': categories\n }","def rotate_point_cloud_in_plane(batch_data):\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\n #rotation_angle = np.random.uniform() * 2 * np.pi\n #cosval = np.cos(rotation_angle)\n #sinval = np.sin(rotation_angle)\n for k in range(batch_data.shape[0]):\n rotation_angle = np.random.uniform() * 2 * np.pi\n cosval = np.cos(rotation_angle)\n sinval = np.sin(rotation_angle)\n rotation_matrix = np.array([[cosval, -sinval, 0],\n [sinval, cosval, 0],\n [0, 0, 1]])\n shape_pc = batch_data[k, ...]\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\n return rotated_data","def transform(self, R, t, scale = 1):\n\n # Build 4-by-4 projection matrix from args ----------------------------\n # This is what we are doing internally:\n # Proj = np.r_[ scale * np.c_[R, t], [[0, 0, 0, 1]] ]\n # InvProj = np.r_[ scale * np.c_[R.T, -np.dot(R.T, t)], [[0,0,0,scale]] ]\n Proj = tf_format.tf_format('4x4', R, t)\n Proj[:-1,:] *= scale\n InvProj = tf_format.tf_format('i4x4', R, t) * scale\n \n \n # Apply transformation to pts3D ---------------------------------------\n if self.pts3D is not None and self.pts3D.shape[1] > 0:\n # Use homogeneous coords\n pts3D = np.r_[self.pts3D, np.ones((1, self.pts3D.shape[1]))]\n pts3D = np.dot(Proj, pts3D)\n self.pts3D = pts3D[:3, :]\n\n # Apply transformation to cameras -------------------------------------\n # Camera poses are stored using camera-to-world transformations, we \n # need to invert the projection matrix for this to work --> \n # we use InvProj\n\n cposes = self.cam_poses\n for i in range(cposes.shape[1]):\n\n # Extract camera projection matrix\n p_cam = tf_format.tf_format('4x4', cposes[:, i])\n\n # Transform camera projection matrix\n new_p_cam = np.dot(p_cam, InvProj)\n \n # Make sure it's a true rotation!\n [u, s, vT] = np.linalg.svd(new_p_cam[:3,:3])\n cposes[:3, i] = tf_format.rodrigues( np.dot(u,vT) ).ravel()\n cposes[3:, i] = new_p_cam[:3, 3]\n\n self.cam_poses = cposes","def transform(self, x: Array2D) -> Array2D:","def transformation_2d(vertices, kernels=KERNELS):\n\t# calculate the transpose matrix of vertices\n\ttranspose = vertices.transpose()\n\t# insert a row of ones in the transpose matrix's end, then insert the result in 'matrices' list\n\tkernels.append(np.append(transpose, [np.ones(len(transpose[0]))], axis=0))\n\t# multiply matrices into 'kernels' list,\n\t# remove the last row (of ones) and calculate the transpose matrix of the result\n\tfinal_transformation_result = np.delete(np.linalg.multi_dot(kernels), 2, 0).transpose()\n\tKERNELS.clear()\n\treturn final_transformation_result"],"string":"[\n \"def apply_transformation(self, points):\\n assert (points.shape[0] == 3)\\n n = points.shape[1]\\n points_ = np.vstack((points, np.ones((1, n))))\\n points_trans_ = np.matmul(self.pose_mat, points_)\\n points_transformed = np.true_divide(points_trans_[:3, :], points_trans_[[-1], :])\\n return points_transformed\",\n \"def rotate_point_cloud_by_matrices(batch_data, rotation_matrices):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n shape_pc = batch_data[k, ...]\\n rotation_matrix = rotation_matrices[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def transform_points(points, transf_matrix):\\n if points.shape[0] not in [3, 4]:\\n raise Exception(\\n \\\"Points input should be (3,N) or (4,N) shape, received {}\\\".format(\\n points.shape\\n )\\n )\\n return transf_matrix.dot(np.vstack((points[:3, :], np.ones(points.shape[1]))))[\\n :3, :\\n ]\",\n \"def transform_points(transf_matrix, points):\\n if(type(points)==list):\\n temp_pts = [np.array([x[0],x[1],x[2],1]) for x in points]\\n newpts = []\\n for pt in temp_pts:\\n newpts.append((transf_matrix@pt)[:3])\\n else:\\n temp_pts = np.array([points[0],points[1],points[2],1])\\n newpts=(transf_matrix@temp_pts)[:3]\\n return newpts\",\n \"def transform_points(self, points3d: np.ndarray) -> np.ndarray:\\n assert self._r is not None\\n assert self._t is not None\\n assert isinstance(points3d, np.ndarray)\\n\\n if points3d.shape[1] == 6: # expunge RGB\\n points3d = points3d[:, 0:3]\\n points3d = points3d.transpose()\\n rotation_matrix = np.empty((3, 3), dtype=float)\\n rotation_as_np = np.array([self.r.w, self.r.x, self.r.y, self.r.z])\\n _as_rotation_matrix_njit(rotation_as_np, rotation_matrix)\\n points3d = np.add(np.matmul(rotation_matrix, points3d), self.t)\\n return points3d.transpose()\",\n \"def transform_pt_array(point_array,M):\\n \\n original_shape = point_array.shape\\n \\n num_points = int(np.size(point_array,0)*np.size(point_array,1)/2)\\n # resize array into N x 2 array\\n reshaped = point_array.reshape((num_points,2)) \\n \\n # add third row\\n ones = np.ones([num_points,1])\\n points3d = np.concatenate((reshaped,ones),1)\\n \\n # transform points\\n tf_points3d = np.transpose(np.matmul(M,np.transpose(points3d)))\\n \\n # condense to two-dimensional coordinates\\n tf_points = np.zeros([num_points,2])\\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\\n \\n tf_point_array = tf_points.reshape(original_shape)\\n \\n return tf_point_array\",\n \"def transform_pc3d(pcl_c3d, Ts, seq_n, K_cur, batch_n):\\n\\n ## need to transform: flat.uvb, flat.feature['xyz'], flat.feature['normal']\\n ## no need to transform grid features\\n \\n assert batch_n % seq_n == 0 # mode==0\\n n_group = batch_n // seq_n\\n\\n ## get relative pose\\n T, R, t, target_id = relative_T(Ts, seq_n, batch_n)\\n\\n ## get accumulative length\\n nb = pcl_c3d.flat.nb\\n acc_b = []\\n acc = 0\\n acc_b.append( acc )\\n for ib in range(batch_n):\\n acc = acc + nb[ib]\\n acc_b.append( acc )\\n\\n ## process flat features\\n flat_xyz = pcl_c3d.flat.feature['xyz'] # 1*C*NB\\n flat_normal = pcl_c3d.flat.feature['normal']\\n trans_normal_list = []\\n trans_xyz_list = []\\n uvb_list = []\\n new_nb = []\\n for ib in range(batch_n):\\n ## xyz\\n trans_xyz = torch.matmul(R[ib], flat_xyz[:, :, acc_b[ib]:acc_b[ib+1]]) + t[ib]\\n mask_positive = trans_xyz[0, 2, :] > 0\\n trans_xyz = trans_xyz[:, :, mask_positive]\\n trans_xyz_list.append(trans_xyz)\\n new_nb.append(trans_xyz.shape[2])\\n\\n ## normal\\n trans_normal = torch.matmul(R[ib], flat_normal[:, :, acc_b[ib]:acc_b[ib+1]])\\n trans_normal = trans_normal[:, :, mask_positive]\\n trans_normal_list.append(trans_normal)\\n\\n ## project to uv, add b\\n uvb = torch.matmul(K_cur[ib], trans_xyz)\\n uvb[:, :2] = uvb[:, :2] / uvb[:, [2]] #- 1 , commented because in dataset_read.py there is a K_mat2py() function converting K from matlab to python coordinate\\n uvb[:, 2, :] = target_id[ib]\\n uvb_list.append(uvb)\\n\\n ## construct the new object\\n tr_pcl_c3d = PCL_C3D_Flat()\\n tr_pcl_c3d.feature['xyz'] = torch.cat(trans_xyz_list, dim=2)\\n tr_pcl_c3d.feature['normal'] = torch.cat(trans_normal_list, dim=2)\\n tr_pcl_c3d.uvb = torch.cat(uvb_list, dim=2)\\n tr_pcl_c3d.nb = new_nb\\n\\n for feat_key in pcl_c3d.flat.feature:\\n if feat_key not in ['xyz', 'normal']:\\n tr_pcl_c3d.feature[feat_key] = pcl_c3d.flat.feature[feat_key]\\n\\n return tr_pcl_c3d\",\n \"def fun(params,n_cameras,n_points,camera_indices,point_indices,points_3d , points_2d):\\n camera_params = params[:n_cameras * 6].reshape((n_cameras, 6))\\n # points_3d = points_3d.T\\n # points_3d = params[n_cameras * 7:].reshape((n_points, 3))\\n # print(point_indices)\\n points_proj = project(points_3d[point_indices], camera_params[camera_indices])\\n return (points_proj - points_2d).ravel()\",\n \"def transform_obj_list(object_list,M,M2 = None):\\n \\n for i, obj in enumerate(object_list):\\n points = obj.all\\n num_points = len(points)\\n \\n \\n # add third row\\n ones = np.ones([num_points,1])\\n points3d = np.concatenate((points,ones),1)\\n points3d = points3d[:,[0,1,4]]\\n # transform points\\n tf_points3d = np.transpose(np.matmul(M,np.transpose(points3d)))\\n \\n # condense to two-dimensional coordinates\\n tf_points = np.zeros([num_points,2])\\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\\n \\n object_list[i].all_world = tf_points\\n \\n if M2 is not None:\\n tf_points3d = np.transpose(np.matmul(M2,np.transpose(points3d)))\\n \\n # condense to two-dimensional coordinates\\n tf_points = np.zeros([num_points,2])\\n tf_points[:,0] = tf_points3d[:,0]/tf_points3d[:,2]\\n tf_points[:,1] = tf_points3d[:,1]/tf_points3d[:,2]\\n \\n object_list[i].all_gps = tf_points\\n \\n return object_list\",\n \"def transform( self, matrix3 ):\\n self._coords = matrix3._matrix * self._coords\\n return self\",\n \"def _transform(self, matrix):\\n for x in list(self.keys()):\\n ar = self[x]\\n if len(ar.shape) == 2 and ar.shape[1] == 3:\\n self[x] = np.dot(matrix, ar.transpose()).transpose()\",\n \"def matrix_apply_to_3d_3x3(vol, matrix: np.matrix):\\n from scipy import mgrid\\n\\n cx = vol.shape[0]/2\\n cy = vol.shape[1]/2\\n cz = vol.shape[2]/2\\n\\n # Calculate the new coordinates of every point\\n grid = mgrid[-cx:vol.shape[0]-cx, -cy:vol.shape[1]-cy, -cz:vol.shape[2]-cz]\\n temp = grid.reshape((3, grid.size / 3))\\n # Add the fourth dimension (just 1s but needed for the computations)\\n # Use the matrix to calculate the new positions of every point\\n temp = np.dot(matrix, temp)\\n # Delete the fourth dimension\\n temp = np.array(temp)\\n grid = np.reshape(temp, (3, vol.shape[0], vol.shape[1], vol.shape[2]))\\n\\n grid[0] += cx\\n grid[1] += cy\\n grid[2] += cz\\n\\n from scipy.ndimage.interpolation import map_coordinates\\n d = map_coordinates(vol, grid, order=3)\\n\\n return d\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def trans_to_coordinates(T, pts):\\n p = []\\n for i in range(len(pts)):\\n \\n p_b = [pts[i][0], pts[i][1], pts[i][2], 1]\\n p_a = np.matmul(T, p_b).tolist()\\n p.append(p_a[0:3])\\n\\n return p\",\n \"def transform(self, X):\\n X = check_tensor(X, dtype=np.float32, n_dim=4)\\n if self.batch_size is None:\\n if self.force_reshape:\\n return self.transform_function(X.transpose(\\n *self.transpose_order))[0].reshape((len(X), -1))\\n else:\\n return self.transform_function(\\n X.transpose(*self.transpose_order))\\n else:\\n XT = X.transpose(*self.transpose_order)\\n n_samples = XT.shape[0]\\n for i in range(0, n_samples, self.batch_size):\\n transformed_batch = self.transform_function(\\n XT[i:i + self.batch_size])\\n # at first iteration, initialize output arrays to correct size\\n if i == 0:\\n shapes = [(n_samples,) + t.shape[1:] for t in\\n transformed_batch]\\n ravelled_shapes = [np.prod(shp[1:]) for shp in shapes]\\n if self.force_reshape:\\n output_width = np.sum(ravelled_shapes)\\n output = np.empty((n_samples, output_width),\\n dtype=transformed_batch[0].dtype)\\n break_points = np.r_([0], np.cumsum(ravelled_shapes))\\n raw_output = [\\n output[:, start:stop] for start, stop in\\n zip(break_points[:-1], break_points[1:])]\\n else:\\n output = [np.empty(shape,\\n dtype=transformed_batch.dtype)\\n for shape in shapes]\\n raw_output = [arr.reshape(n_samples, -1)\\n for arr in output]\\n\\n for transformed, out in zip(transformed_batch, raw_output):\\n out[i:i + batch_size] = transformed\\n return output\",\n \"def apply_transform_on_3d_image(image: torch.Tensor, transforms: List[Callable]) -> torch.Tensor:\\n for z in range(image.shape[0]):\\n pil = TF.to_pil_image(image[z])\\n for transform_fn in transforms:\\n pil = transform_fn(pil)\\n image[z] = TF.to_tensor(pil).squeeze()\\n return image\",\n \"def transform_points(points, T):\\n\\n homo_points = np.array([(x, y, 1) for (y, x) in points])\\n t_points = np.array([T.dot(v) for v in homo_points ])\\n swap = np.array([(x,y) for (y,x,z) in t_points])\\n return swap\",\n \"def get_perspective_transform(points_src: Tensor, points_dst: Tensor) -> Tensor:\\n KORNIA_CHECK_SHAPE(points_src, [\\\"B\\\", \\\"4\\\", \\\"2\\\"])\\n KORNIA_CHECK_SHAPE(points_dst, [\\\"B\\\", \\\"4\\\", \\\"2\\\"])\\n KORNIA_CHECK(points_src.shape == points_dst.shape, \\\"Source data shape must match Destination data shape.\\\")\\n KORNIA_CHECK(points_src.dtype == points_dst.dtype, \\\"Source data type must match Destination data type.\\\")\\n\\n # we build matrix A by using only 4 point correspondence. The linear\\n # system is solved with the least square method, so here\\n # we could even pass more correspondence\\n\\n # create the lhs tensor with shape # Bx8x8\\n B: int = points_src.shape[0] # batch_size\\n\\n A = torch.empty(B, 8, 8, device=points_src.device, dtype=points_src.dtype)\\n\\n # we need to perform in batch\\n _zeros = zeros(B, device=points_src.device, dtype=points_src.dtype)\\n _ones = torch.ones(B, device=points_src.device, dtype=points_src.dtype)\\n\\n for i in range(4):\\n x1, y1 = points_src[..., i, 0], points_src[..., i, 1] # Bx4\\n x2, y2 = points_dst[..., i, 0], points_dst[..., i, 1] # Bx4\\n\\n A[:, 2 * i] = stack([x1, y1, _ones, _zeros, _zeros, _zeros, -x1 * x2, -y1 * x2], -1)\\n A[:, 2 * i + 1] = stack([_zeros, _zeros, _zeros, x1, y1, _ones, -x1 * y2, -y1 * y2], -1)\\n\\n # the rhs tensor\\n b = points_dst.view(-1, 8, 1)\\n\\n # solve the system Ax = b\\n X: Tensor = _torch_solve_cast(A, b)\\n\\n # create variable to return the Bx3x3 transform\\n M = torch.empty(B, 9, device=points_src.device, dtype=points_src.dtype)\\n M[..., :8] = X[..., 0] # Bx8\\n M[..., -1].fill_(1)\\n\\n return M.view(-1, 3, 3) # Bx3x3\",\n \"def TransformPoint(transform, x, y, z):\\n result = np.matmul(transform, np.array([x, y, z, 1.]))\\n return result[0], result[1], result[2]\",\n \"def batch_affine_warp3d(imgs, theta):\\n n_batch = tf.shape(imgs)[0]\\n xlen = int(imgs.shape[1])\\n ylen = int(imgs.shape[2])\\n zlen = int(imgs.shape[3])\\n theta = tf.reshape(theta, [-1, 3, 4])\\n matrix = tf.slice(theta, [0, 0, 0], [-1, -1, 3])\\n t = tf.slice(theta, [0, 0, 3], [-1, -1, -1])\\n\\n grids = batch_mgrid(n_batch, xlen, ylen, zlen)\\n grids = tf.reshape(grids, [n_batch, 3, -1])\\n\\n ### TODO: This code has been changed from batch_matmul to matmul.\\n T_g = tf.matmul(matrix, grids) + t\\n T_g = tf.reshape(T_g, [n_batch, 3, xlen, ylen, zlen])\\n output = batch_warp3d(imgs, T_g)\\n return output\",\n \"def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])\",\n \"def project_points(self, points_3d, camera):\\n batch_size = points_3d.shape[0]\\n device = points_3d.device\\n cam_t = torch.stack([camera[:, 1], camera[:, 2], 2 * self.focal_length / (self.img_res * camera[:, 0] + 1e-09)], dim=-1)\\n camera_center = camera.new_zeros([batch_size, 2])\\n rot_t = torch.eye(3, device=device, dtype=points_3d.dtype).unsqueeze(0).expand(batch_size, -1, -1)\\n joints_2d = perspective_projection(points_3d, rotation=rot_t, translation=cam_t, focal_length=self.focal_length, camera_center=camera_center)\\n return joints_2d\",\n \"def MakeCoordinates3D(self):\\n\\n self.points = np.concatenate((self.points, np.zeros((self.points.shape[0],1)) ), axis=1)\\n self.points = np.ascontiguousarray(self.points)\",\n \"def collate_fn(self, batch):\\n images = list()\\n targets = list()\\n\\n for b in batch:\\n images.append(b[0])\\n targets.append(b[1])\\n\\n # images = torch.stack(images, dim=0)\\n\\n return images, targets # tensor (N, 3, 300, 300), 3 lists of N tensors each\",\n \"def scale_and_translate_points(points):\\n x = points[0]\\n y = points[1]\\n center = points.mean(axis=1) # mean of each row\\n cx = x - center[0] # center the points\\n cy = y - center[1]\\n dist = np.sqrt(np.power(cx, 2) + np.power(cy, 2))\\n scale = np.sqrt(2) / dist.mean()\\n norm3d = np.array([\\n [scale, 0, -scale * center[0]],\\n [0, scale, -scale * center[1]],\\n [0, 0, 1]\\n ])\\n\\n return np.dot(norm3d, points), norm3d\",\n \"def projectToImage(pts_3D, P):\\n pts_3D = np.reshape(pts_3D, (-1, 3))\\n pts_3D = np.transpose(pts_3D)\\n pts_3D = np.vstack([pts_3D, 1])\\n pts_2D = np.matmul(P, pts_3D)\\n pts_2D = pts_2D[:2]/pts_2D[-1]\\n pts_2D = np.transpose(pts_2D)\\n return pts_2D\",\n \"def scale_on_3d(x3d, scaler):\\n (n_segs, n_concat, n_freq) = x3d.shape\\n x2d = x3d.reshape((n_segs * n_concat, n_freq))\\n x2d = scaler.transform(x2d)\\n x3d = x2d.reshape((n_segs, n_concat, n_freq))\\n return x3d\",\n \"def get_perspective_transform3d(src: Tensor, dst: Tensor) -> Tensor:\\n if not isinstance(src, (Tensor)):\\n raise TypeError(f\\\"Input type is not a Tensor. Got {type(src)}\\\")\\n\\n if not isinstance(dst, (Tensor)):\\n raise TypeError(f\\\"Input type is not a Tensor. Got {type(dst)}\\\")\\n\\n if not src.shape[-2:] == (8, 3):\\n raise ValueError(f\\\"Inputs must be a Bx8x3 tensor. Got {src.shape}\\\")\\n\\n if not src.shape == dst.shape:\\n raise ValueError(f\\\"Inputs must have the same shape. Got {dst.shape}\\\")\\n\\n if not (src.shape[0] == dst.shape[0]):\\n raise ValueError(f\\\"Inputs must have same batch size dimension. Expect {src.shape} but got {dst.shape}\\\")\\n\\n if not (src.device == dst.device and src.dtype == dst.dtype):\\n raise AssertionError(\\n f\\\"Expect `src` and `dst` to be in the same device (Got {src.dtype}, {dst.dtype}) \\\"\\n f\\\"with the same dtype (Got {src.dtype}, {dst.dtype}).\\\"\\n )\\n\\n # we build matrix A by using only 4 point correspondence. The linear\\n # system is solved with the least square method, so here\\n # we could even pass more correspondence\\n p = []\\n\\n # 000, 100, 110, 101, 011\\n for i in [0, 1, 2, 5, 7]:\\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'x'))\\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'y'))\\n p.append(_build_perspective_param3d(src[:, i], dst[:, i], 'z'))\\n\\n # A is Bx15x15\\n A = stack(p, 1)\\n\\n # b is a Bx15x1\\n b = stack(\\n [\\n dst[:, 0:1, 0],\\n dst[:, 0:1, 1],\\n dst[:, 0:1, 2],\\n dst[:, 1:2, 0],\\n dst[:, 1:2, 1],\\n dst[:, 1:2, 2],\\n dst[:, 2:3, 0],\\n dst[:, 2:3, 1],\\n dst[:, 2:3, 2],\\n # dst[:, 3:4, 0], dst[:, 3:4, 1], dst[:, 3:4, 2],\\n # dst[:, 4:5, 0], dst[:, 4:5, 1], dst[:, 4:5, 2],\\n dst[:, 5:6, 0],\\n dst[:, 5:6, 1],\\n dst[:, 5:6, 2],\\n # dst[:, 6:7, 0], dst[:, 6:7, 1], dst[:, 6:7, 2],\\n dst[:, 7:8, 0],\\n dst[:, 7:8, 1],\\n dst[:, 7:8, 2],\\n ],\\n 1,\\n )\\n\\n # solve the system Ax = b\\n X: Tensor = _torch_solve_cast(A, b)\\n\\n # create variable to return\\n batch_size: int = src.shape[0]\\n M = torch.empty(batch_size, 16, device=src.device, dtype=src.dtype)\\n M[..., :15] = X[..., 0]\\n M[..., -1].fill_(1)\\n\\n return M.view(-1, 4, 4) # Bx4x4\",\n \"def transform3D(x: float, y: float, z: float, R: np.array) -> np.array:\\n T = np.zeros((4, 4))\\n T[:3, :3] = R\\n T[:, 3] = [x, y, z, 1.0]\\n\\n return T\",\n \"def transform(vector3, matrix4x4):\\n if numpy:\\n return numpy.dot(matrix4x4, numpy.append(vector3, 1.))\\n else:\\n m0,m1,m2,m3 = matrix4x4; x,y,z = vector3\\n return [\\n m0[0]*x + m0[1]*y + m0[2]*z + m0[3],\\n m1[0]*x + m1[1]*y + m1[2]*z + m1[3],\\n m2[0]*x + m2[1]*y + m2[2]*z + m2[3],\\n m3[0]*x + m3[1]*y + m3[2]*z + m3[3]\\n ]\",\n \"def estimate_affine_matrix_3d_to_2d(X, x):\\n assert x.shape[0] == X.shape[0]\\n assert x.shape[0] >= 4\\n X = X.T # (3, n)\\n x = x.T # (2, n)\\n n = x.shape[1]\\n\\n ###---- 1. normalization\\n ## 2d points\\n mean = np.mean(x, 1) # (2, )\\n x = x - np.tile(mean[:, np.newaxis], [1, n]) # (2, n)\\n average_norm = np.mean(np.sqrt(np.sum(x ** 2, 0)))\\n scale = np.sqrt(2) / average_norm\\n x = scale * x\\n\\n # T = [[scale, 0, -mean * scale], \\n # [ 0, scale, -mean * scale], \\n # [ 0, 0, 1 ]]\\n T = np.zeros((3, 3), dtype=np.float32)\\n T[0, 0] = T[1, 1] = scale\\n T[:2, 2] = -mean * scale\\n T[2, 2] = 1\\n\\n ## 3d points\\n X_homo = np.vstack((X, np.ones((1, n)))) # (4, n)\\n mean = np.mean(X, 1) # (3, )\\n X = X - np.tile(mean[:, np.newaxis], [1, n]) # (3, n)\\n m = X_homo[: 3, :] - X\\n average_norm = np.mean(np.sqrt(np.sum(X ** 2, 0)))\\n scale = np.sqrt(3) / average_norm\\n X = scale * X\\n\\n U = np.zeros((4, 4), dtype=np.float32)\\n U[0, 0] = U[1, 1] = U[2, 2] = scale\\n U[: 3, 3] = -mean * scale\\n U[3, 3] = 1\\n\\n ###---- 2. equations\\n A = np.zeros((n * 2, 8), dtype=np.float32)\\n X_homo = np.vstack((X, np.ones((1, n)))).T\\n A[: n, : 4] = X_homo\\n A[n: , 4: ] = X_homo\\n b = np.reshape(x, [-1, 1]) # (2n, 1)\\n\\n ###---- 3.solution\\n p_8 = np.linalg.pinv(A).dot(b) # (8, 2n) x (2n, 1) -> (8, 1)\\n p = np.zeros((3, 4), dtype=np.float32)\\n p[0, :] = p_8[:4, 0]\\n p[1, :] = p_8[4:, 0]\\n p[-1, -1] = 1\\n\\n ###---- 4. denormalization\\n P_Affine = np.linalg.inv(T).dot(p.dot(U))\\n return P_Affine\",\n \"def collate_fn(self, batch):\\n images = list()\\n boxes = list()\\n labels = list()\\n difficulties = list()\\n\\n for b in batch:\\n images.append(b[0])\\n boxes.append(b[1])\\n labels.append(b[2])\\n difficulties.append(b[3])\\n\\n images = torch.stack(images, dim=0)\\n\\n return images, boxes, labels, difficulties # tensor (N, 3, 300, 300), 3 lists of N tensors each\",\n \"def apply_transform_xy(transform, xy):\\n # Get number of points, store as n\\n n = len(xy)\\n\\n # _xy is the transformed xy in inplied 3d vector form\\n _xy = np.hstack([xy, np.ones([n,1])])\\n\\n # Apply transformation to all points\\n points = transform.dot(_xy.T)\\n\\n return points[:2].T\",\n \"def __set_transform_matrices(self):\\n self.tf_matrices_list = []\\n\\n transform_matrix = eye(4) # creates a unit matrix via passing argument.\\n for i in range(self.joint_count):\\n transform_matrix = transform_matrix * self.__create_tf_matrix(self.alpha[i], self.a[i], self.d[i], self.q[i]).subs(self.dh_params)\\n self.tf_matrices_list.append(transform_matrix)\",\n \"def matmul3d(X, W):\\n Xr = tf.reshape(X, [-1, tf.shape(X)[2]])\\n XWr = tf.matmul(Xr, W)\\n newshape = [tf.shape(X)[0], tf.shape(X)[1], tf.shape(W)[1]]\\n return tf.reshape(XWr, newshape)\",\n \"def matmul3d(X, W):\\n Xr = tf.reshape(X, [-1, tf.shape(X)[2]])\\n XWr = tf.matmul(Xr, W)\\n newshape = [tf.shape(X)[0], tf.shape(X)[1], tf.shape(W)[1]]\\n return tf.reshape(XWr, newshape)\",\n \"def apply(self, points):\\n pshape = numpy.shape(points)\\n homogeneous = 1\\n if len(pshape) == 1:\\n if pshape[0] == 3:\\n points = numpy.array(numpy.concatenate((points, numpy.ones(1, 'f')), 1))\\n homogeneous = 0\\n elif len(pshape) == 2:\\n if pshape[1] == 3:\\n points = numpy.array(numpy.concatenate(\\n (numpy.array(points), numpy.ones((pshape[0], 1), 'f')), 1))\\n homogeneous = 0\\n mtx = self.getMatrix((4, 4), transpose=1)\\n newpoints = numpy.dot(points, mtx)\\n if homogeneous:\\n return newpoints\\n else:\\n # strip the final one off the coordinates\\n if len(pshape) == 1:\\n return newpoints[:3]\\n else:\\n newpoints = [x[:3] for x in newpoints]\\n return newpoints\",\n \"def move_and_process_input(batch):\\n x, y = batch\\n x = x.to(device).float()\\n y = torch.as_tensor(y).to(device)\\n x = x.permute(0, -1, 1, 2, 3)\\n return x, y\",\n \"def TransformPoints(tFormMat,pts):\\n pts = numpy.array(pts)\\n nPts = len(pts)\\n avgP = sum(pts)/nPts\\n pts = pts - avgP\\n res = [None]*nPts\\n for i in range(nPts):\\n res[i] = numpy.dot(tFormMat,pts[i])\\n\\n return res\",\n \"def _flatten_batch(self, matrix_tups):\\n out_vecs = []\\n for t in matrix_tups:\\n for v in t:\\n new_shape = (v.shape[0],)\\n if len(v.shape) > 1:\\n new_shape = new_shape + (np.prod(v.shape[1:]),)\\n out_vecs.append(v.reshape(new_shape))\\n return jnp.concatenate(out_vecs, axis=1)\",\n \"def project_3d_points_to_plane(points, p1, p2 ,p3, numpoints):\\n p1 = np.asarray(p1)\\n p2 = np.asarray(p2)\\n p3 = np.asarray(p3)\\n\\n # get vectors in plane\\n v1 = p3 - p1\\n v2 = p2 - p1\\n\\n # compute cross product\\n cp = np.cross(v1, v2)\\n a, b, c = cp # normal to plane is ax + by + cz\\n\\n # evaluate d\\n d = np.dot(cp, p3)\\n\\n # thus, normal is given by\\n plane = vtk.vtkPlane()\\n origin = p1\\n normal = normalize(np.array([a,b,c]))\\n plane.SetOrigin(p1)\\n plane.SetNormal(normal)\\n\\n if numpoints == 1:\\n proj = [0,0,0]\\n plane.ProjectPoint(points, origin, normal, proj)\\n return proj\\n else:\\n projected_pts = np.zeros((numpoints, 3), dtype=float)\\n\\n for i in range(numpoints):\\n proj = [0,0,0]\\n plane.ProjectPoint(points[i], origin, normal, proj)\\n projected_pts[i] = proj\\n\\n return projected_pts\",\n \"def scale_point_cloud(batch_data, batch_label):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n scale_num = np.random.uniform() * 5\\n rotation_matrix = np.array([[scale_num, 0, 0],\\n [0, scale_num, 0],\\n [0, 0, scale_num]])\\n shape_pc, shape_label = batch_data[k, ...], batch_label[k]\\n rotated_data[k, ...], rotated_label[k] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix), np.dot(shape_label, rotation_matrix)\\n \\n return rotated_data, rotated_label\",\n \"def convert_1d_to_3d(data_X, data_Y):\\n\\n data_X = data_X.tocsr()\\n \\n data_dim_x = [] # slices along x-axis (has shape of (total_trials * dim_x, dim_z, dim_y))\\n data_dim_x_label = [] # contains (total_trials * dim_x) labels\\n data_dim_y = [] # slices along y-axis (has shape of (total_trials * dim_y, dim_z, dim_x))\\n data_dim_y_label = [] # contains (total_trials * dim_y) labels\\n data_dim_z = [] # slices along z-axis (has shape of (total_trials * dim_z, dim_y, dim_x))\\n data_dim_z_label = [] # contains (total_trials * dim_z) labels\\n\\n for num_trial in range(data_X.shape[0]):\\n label = data_Y[num_trial]\\n data_1d = data_X[num_trial]\\n data_3d = np.squeeze(np.asarray(data_1d.todense())).reshape((dim_z, dim_y, dim_x))\\n for x in range(dim_x):\\n x_slice = data_3d[:,:,x]\\n # append only if the slice is not empty \\n if x_slice.sum() != 0:\\n data_dim_x.append(data_3d[:, :, x])\\n data_dim_x_label.append(label)\\n for y in range(dim_y):\\n y_slice = data_3d[:, y, :]\\n if y_slice.sum() != 0:\\n data_dim_y.append(data_3d[:, y, :])\\n data_dim_y_label.append(label)\\n for z in range(dim_z):\\n z_slice = data_3d[:, :, z]\\n if z_slice.sum() != 0:\\n data_dim_z.append(data_3d[z, :, :])\\n data_dim_z_label.append(label)\\n\\n return np.array(data_dim_x), np.array(data_dim_x_label), \\\\\\n np.array(data_dim_y), np.array(data_dim_y_label), \\\\\\n np.array(data_dim_z), np.array(data_dim_z_label)\",\n \"def test_3d_tranpose(): \\n dic,data = ng.pipe.read_lowmem(\\\"common_data/3d_pipe/ft/test%03d.ft3\\\")\\n fdic,fdata = ng.pipe.read(\\\"common_data/3d_pipe/ft/test%03d.ft3\\\")\\n\\n assert_array_equal(data.transpose()[0,1,2],fdata.transpose()[0,1,2])\\n assert_array_equal(data.transpose((2,0,1))[0,1,2],\\n fdata.transpose((2,0,1))[0,1,2])\\n assert_array_equal(data.swapaxes(0,1)[0,1,2],fdata.swapaxes(0,1)[0,1,2])\\n assert_array_equal(data.swapaxes(2,0)[0,1,2],fdata.swapaxes(2,0)[0,1,2])\",\n \"def project_points(self, points3d, withmask=False, binary_mask=True):\\n if withmask:\\n return Geometry.reproject_points_to_2d(\\n points3d, self.rvec, self.tvec, self.K, self.w, self.h,\\n distCoef=self.distCoef, binary_mask=binary_mask)\\n else:\\n assert type(points3d) == np.ndarray, \\\"Points3d has to be a numpy array\\\"\\n\\n # Treatment for empty points\\n # Add row index of None points to new list and remove the empty elements\\n indexes_of_empty_points = np.unique(np.where(points3d == None)[0])\\n points_to_interpolate = np.float32(points3d.copy())\\n points_to_interpolate = np.delete(points_to_interpolate, indexes_of_empty_points, axis=0)\\n\\n # Project all the points in the camera if points_to_interpolate is not empty\\n if points_to_interpolate.size != 0:\\n batch_size = 1000000 \\n if len(points_to_interpolate) > batch_size:\\n # Create batches\\n num_batches = int(len(points_to_interpolate) / batch_size)\\n last_batch_length = len(points_to_interpolate) % batch_size\\n\\n pts2d = [] \\n for i in range(num_batches):\\n indices = range(i*batch_size,i*batch_size + batch_size)\\n\\n batch = np.take(points_to_interpolate, indices, axis=0) \\n pts2d_batch, _ = cv2.projectPoints(batch, self.rvec, self.tvec, self.K, self.distCoef)\\n pts2d.append(pts2d_batch)\\n\\n if last_batch_length > 0:\\n indices = range(num_batches*batch_size,num_batches*batch_size + last_batch_length)\\n batch = np.take(points_to_interpolate, indices, axis=0) \\n pts2d_batch, _ = cv2.projectPoints(batch, self.rvec, self.tvec, self.K, self.distCoef)\\n pts2d.append(pts2d_batch)\\n\\n pts2d = np.concatenate(pts2d, axis=0)\\n else:\\n pts2d, _ = cv2.projectPoints(points_to_interpolate,\\n self.rvec,\\n self.tvec,\\n self.K, self.distCoef)\\n else:\\n pts2d = np.array([])\\n\\n pts2d = np.squeeze(pts2d)\\n if len(pts2d.shape) == 1:\\n pts2d = np.expand_dims(pts2d, axis=0)\\n\\n # Add empty(None) points again\\n pts2d = pts2d.tolist()\\n for index in indexes_of_empty_points:\\n pts2d.insert(index, [None, None])\\n return np.array(pts2d)\",\n \"def rearrange_batch(batch):\\n return list(zip(*batch))\",\n \"def _preprocess_data_3d(\\n self, data_batch: Dict[str, Any]) -> Tuple[tf.Tensor, tf.Tensor]:\\n world2grid = data_batch['world2grid']\\n uniform_samples = data_batch['uniform_samples']\\n near_surface_samples = data_batch['near_surface_samples']\\n if 'uniform_samples_per_camera' in data_batch:\\n uniform_samples_per_camera = data_batch['uniform_samples_per_camera']\\n if 'near_surface_samples_per_camera' in data_batch:\\n near_surface_samples_per_camera = data_batch[\\n 'near_surface_samples_per_camera']\\n if 'depth_xyzn_per_camera' in data_batch:\\n depth_xyzn_per_camera = data_batch['depth_xyzn_per_camera']\\n\\n batch_size = data_batch['near_surface_samples'].shape[0]\\n spatial_dims = data_batch['grid_samples'].shape[1:4]\\n\\n # Assume grid size is the same in all dimensions.\\n grid_size = spatial_dims[0]\\n\\n # Generate normalized [-1, 1] coordinates for grid samples.\\n _, pixels_grid = point_sampling.sample3d_all_pixels(\\n spatial_dims, normalize=True)\\n pixels_grid = tf.tile(pixels_grid[None, ...], [batch_size, 1, 1, 1, 1])\\n data_batch['grid_samples'] = tf.concat(\\n [pixels_grid, data_batch['grid_samples']], axis=-1)\\n # Tensor with shape [batch_size, dim_d, dim_h, dim_w, 4], (z, y, x).\\n\\n # Transform to grid space [0, 127] and map grid space [-0.5, 127.5] to\\n # [-1, 1].\\n uniform_samples = tf.linalg.matmul(\\n world2grid[:, :3, :],\\n tf.transpose(\\n tf.concat([\\n uniform_samples[..., :3],\\n tf.ones(\\n [batch_size, tf.shape(uniform_samples)[1], 1],\\n dtype=tf.float32)\\n ],\\n axis=-1), [0, 2, 1]))\\n # Tensor with shape [batch_size, 3, num_point].\\n\\n uniform_samples = (uniform_samples + 0.5) * 2.0 / grid_size - 1\\n uniform_samples = uniform_samples[:, ::-1, :] # Convert to (z, y, x).\\n uniform_samples = tf.concat([\\n tf.transpose(uniform_samples, [0, 2, 1]),\\n data_batch['uniform_samples'][..., 3:]\\n ],\\n axis=-1)\\n data_batch['uniform_samples'] = uniform_samples\\n\\n near_surface_samples = tf.linalg.matmul(\\n world2grid[:, :3, :],\\n tf.transpose(\\n tf.concat([\\n near_surface_samples[..., :3],\\n tf.ones([batch_size,\\n tf.shape(near_surface_samples)[1], 1],\\n dtype=tf.float32)\\n ],\\n axis=-1), [0, 2, 1]))\\n near_surface_samples = (near_surface_samples + 0.5) * 2.0 / grid_size - 1\\n near_surface_samples = near_surface_samples[:, ::-1, :]\\n near_surface_samples = tf.concat([\\n tf.transpose(near_surface_samples, [0, 2, 1]),\\n data_batch['near_surface_samples'][..., 3:]\\n ],\\n axis=-1)\\n data_batch['near_surface_samples'] = near_surface_samples\\n\\n if 'uniform_samples_per_camera' in data_batch:\\n num_view = tf.shape(uniform_samples_per_camera)[1]\\n num_point_per_view = tf.shape(uniform_samples_per_camera)[2]\\n num_channel = tf.shape(uniform_samples_per_camera)[3]\\n uniform_samples_per_camera = tf.reshape(uniform_samples_per_camera,\\n [batch_size, -1, num_channel])\\n uniform_samples_per_camera = tf.linalg.matmul(\\n world2grid[:, :3, :],\\n tf.transpose(\\n tf.concat([\\n uniform_samples_per_camera[..., :3],\\n tf.ones(\\n [batch_size,\\n tf.shape(uniform_samples_per_camera)[1], 1],\\n dtype=tf.float32)\\n ],\\n axis=-1), [0, 2, 1]))\\n uniform_samples_per_camera = (uniform_samples_per_camera +\\n 0.5) * 2.0 / grid_size - 1\\n uniform_samples_per_camera = uniform_samples_per_camera[:, ::-1, :]\\n uniform_samples_per_camera = tf.reshape(\\n tf.transpose(uniform_samples_per_camera, [0, 2, 1]),\\n [batch_size, num_view, num_point_per_view, -1])\\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\\n\\n uniform_samples_per_camera = tf.concat([\\n uniform_samples_per_camera,\\n data_batch['uniform_samples_per_camera'][..., 3:]\\n ],\\n axis=-1)\\n data_batch['uniform_samples_per_camera'] = uniform_samples_per_camera\\n\\n if 'near_surface_samples_per_camera' in data_batch:\\n num_view = tf.shape(near_surface_samples_per_camera)[1]\\n num_point_per_view = tf.shape(near_surface_samples_per_camera)[2]\\n num_channel = tf.shape(near_surface_samples_per_camera)[3]\\n near_surface_samples_per_camera = tf.reshape(\\n near_surface_samples_per_camera, [batch_size, -1, num_channel])\\n near_surface_samples_per_camera = tf.linalg.matmul(\\n world2grid[:, :3, :],\\n tf.transpose(\\n tf.concat([\\n near_surface_samples_per_camera[..., :3],\\n tf.ones([\\n batch_size,\\n tf.shape(near_surface_samples_per_camera)[1], 1\\n ],\\n dtype=tf.float32)\\n ],\\n axis=-1), [0, 2, 1]))\\n near_surface_samples_per_camera = (near_surface_samples_per_camera +\\n 0.5) * 2.0 / grid_size - 1\\n near_surface_samples_per_camera = near_surface_samples_per_camera[:, ::\\n -1, :]\\n near_surface_samples_per_camera = tf.reshape(\\n tf.transpose(near_surface_samples_per_camera, [0, 2, 1]),\\n [batch_size, num_view, num_point_per_view, -1])\\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\\n\\n near_surface_samples_per_camera = tf.concat([\\n near_surface_samples_per_camera,\\n data_batch['near_surface_samples_per_camera'][..., 3:]\\n ],\\n axis=-1)\\n data_batch[\\n 'near_surface_samples_per_camera'] = near_surface_samples_per_camera\\n\\n if 'depth_xyzn_per_camera' in data_batch:\\n num_view = tf.shape(depth_xyzn_per_camera)[1]\\n num_point_per_view = tf.shape(depth_xyzn_per_camera)[2]\\n num_channel = tf.shape(depth_xyzn_per_camera)[3]\\n depth_xyzn_per_camera = tf.reshape(depth_xyzn_per_camera,\\n [batch_size, -1, num_channel])\\n depth_xyzn_per_camera = tf.linalg.matmul(\\n world2grid[:, :3, :],\\n tf.transpose(\\n tf.concat([\\n depth_xyzn_per_camera[..., :3],\\n tf.ones([batch_size,\\n tf.shape(depth_xyzn_per_camera)[1], 1],\\n dtype=tf.float32)\\n ],\\n axis=-1), [0, 2, 1]))\\n depth_xyzn_per_camera = (depth_xyzn_per_camera +\\n 0.5) * 2.0 / grid_size - 1\\n depth_xyzn_per_camera = depth_xyzn_per_camera[:, ::-1, :]\\n depth_xyzn_per_camera = tf.reshape(\\n tf.transpose(depth_xyzn_per_camera, [0, 2, 1]),\\n [batch_size, num_view, num_point_per_view, -1])\\n # Tensor with shape [batch_size, num_view, num_point_per_view, 3].\\n\\n depth_xyzn_per_camera = tf.concat(\\n [depth_xyzn_per_camera, data_batch['depth_xyzn_per_camera'][..., 3:]],\\n axis=-1)\\n data_batch['depth_xyzn_per_camera'] = depth_xyzn_per_camera\\n\\n # Scale SDF\\n data_batch['grid_samples'] = data_batch['grid_samples'] * \\\\\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, None, :]\\n data_batch['uniform_samples'] = data_batch['uniform_samples'] * \\\\\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, :]\\n data_batch['near_surface_samples'] = data_batch['near_surface_samples'] * \\\\\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, :]\\n if 'uniform_samples_per_camera' in data_batch:\\n data_batch['uniform_samples_per_camera'] = data_batch['uniform_samples_per_camera'] * \\\\\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, :]\\n if 'near_surface_samples_per_camera' in data_batch:\\n data_batch['near_surface_samples_per_camera'] = data_batch['near_surface_samples_per_camera'] * \\\\\\n tf.constant([1, 1, 1, self._sdf_scale], dtype=tf.float32)[None, None, None, :]\\n\\n input_data = data_batch['grid_samples'][..., 3:4]\\n # Tensor with shape [batch_size, dim_d, dim_h, dim_w, 1].\\n\\n gt_data = input_data\\n\\n return input_data, gt_data\",\n \"def transform(self, matrix: \\\"Matrix44\\\"):\\n self.vertices = list(matrix.transform_vertices(self.vertices))\\n return self\",\n \"def to_torch(batch, **kwargs):\\n x = torch.from_numpy(np.array(batch, dtype='float32'))\\n return x.view(*x.size()[:2], -1).permute(2, 0, 1)\",\n \"def TransformPoints(tFormMat, pts):\\n pts = numpy.array(pts)\\n nPts = len(pts)\\n avgP = sum(pts) / nPts\\n pts = pts - avgP\\n res = [None] * nPts\\n for i in range(nPts):\\n res[i] = numpy.dot(tFormMat, pts[i])\\n\\n return res\",\n \"def transform(self, data):\\n self.cube = self.trf.transform(data)\",\n \"def project_points(points, cam_matrix, trans, rot):\\n\\n # STEP 1: Transform pointcloud into new reference frame.\\n points = np.dot(rot, points) + trans[:, None]\\n\\n # STEP 2: Project new pointcloud onto image frame using K matrix.\\n # gives a 3 x N array of image plane coordinates in homogenous coordinates.\\n homo_pixel_coords = np.dot(cam_matrix, points)\\n\\n # STEP 3: Convert homogenous coordinates to regular 2D coordinates.\\n # To do this, you need to divide the first two coordinates of homo_pixel_coords\\n # by the third coordinate.\\n pixel_coords = homo_pixel_coords[:2] / homo_pixel_coords[2]\\n\\n # STEP 4: Convert to integers. Take the floor of pixel_coords then cast it\\n # to an integer type, like numpy.int32\\n pixel_coords = np.int32(np.floor(pixel_coords))\\n\\n return pixel_coords\",\n \"def transform(self, matrix: Matrix3D):\\n transform = self._local_transform\\n transform.transformBy(matrix)\\n self._reset_cache()\\n return self\",\n \"def transformation_matrix(self, s1, s2, s3, t1, t2, t3):\\n\\n s1 = np.array(s1)\\n s2 = np.array(s2)\\n s3 = np.array(s3)\\n t1 = np.array(t1)\\n t2 = np.array(t2)\\n t3 = np.array(t3)\\n\\n Q = np.array(\\n [\\n [t2[0] - t1[0], t2[1] - t1[1], t2[2] - t1[2]],\\n [t3[0] - t1[0], t3[1] - t1[1], t3[2] - t1[2]],\\n ]\\n )\\n\\n P = np.array([[s2[0] - s1[0], s2[1] - s1[1]], [s3[0] - s1[0], s3[1] - s1[1]]])\\n\\n try:\\n # Invert the P matrix\\n Pinv = inv(P)\\n\\n # Build the dot product\\n T = np.dot(Pinv, Q)\\n\\n # Offset\\n V0 = np.subtract(t2, np.transpose(s2[0:2]).dot(T))\\n except Exception as e:\\n self.log.error(\\\"An error occured during the transformation.\\\", exc_info=True)\\n return -1, -1\\n\\n return T, V0\",\n \"def projectToImage_kitti(pts_3D, P):\\n # project in image\\n mat = np.vstack((pts_3D, np.ones((pts_3D.shape[1]))))\\n\\n pts_2D = np.dot(P, mat)\\n\\n # scale projected points\\n pts_2D[0, :] = pts_2D[0, :] / pts_2D[2, :]\\n pts_2D[1, :] = pts_2D[1, :] / pts_2D[2, :]\\n pts_2D = np.delete(pts_2D, 2, 0)\\n\\n return pts_2D\",\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 rotate_point_cloud(batch_data):\\r\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\r\\n for k in range(batch_data.shape[0]):\\r\\n rotation_angle = np.random.uniform() * 2 * np.pi\\r\\n cosval = np.cos(rotation_angle)\\r\\n sinval = np.sin(rotation_angle)\\r\\n rotation_matrix = np.array([[cosval, 0, sinval],\\r\\n [0, 1, 0],\\r\\n [-sinval, 0, cosval]])\\r\\n shape_pc = batch_data[k, ...]\\r\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\r\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud_z(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, sinval, 0],\\n [-sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\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 apply_T(T, points):\\n flipped = False\\n if points.shape[0] != 3:\\n assert points.shape[1] == 3, \\\"Points must be 3xN or Nx3\\\"\\n points = points.T\\n flipped = True\\n points_h = np.vstack((points, np.ones_like(points[0, :])))\\n points_transformed_h = np.dot(T, points_h)\\n points_transformed = points_transformed_h[:-1]\\n if flipped:\\n return points_transformed.T\\n return points_transformed\",\n \"def rigid_transform_3d(xs,ys):\\n assert xs.shape == ys.shape\\n assert xs.shape[0] == 3, 'The points must be of dimmensionality 3'\\n\\n # find centroids and H\\n x_centroid = np.mean(xs, axis=1)[:, np.newaxis]\\n y_centroid = np.mean(ys, axis=1)[:, np.newaxis]\\n \\n H = (xs - x_centroid)@(ys - y_centroid).T\\n\\n # find rotation\\n U, S, Vt = np.linalg.svd(H)\\n rotation = Vt.T@U.T\\n\\n # handling reflection\\n if np.linalg.det(rotation) < 0:\\n Vt[2, :] *= -1\\n rotation = np.dot(Vt.T, U.T)\\n \\n # find translation\\n translation = y_centroid - rotation@x_centroid\\n \\n return translation, rotation\",\n \"def transform(self, transformer):\\n\\t\\tnew_matrix = Matrix(self.dims)\\n\\t\\tnew_matrix.data = [transformer(copy.deepcopy(c)) for c in self.data]\\n\\t\\treturn new_matrix\",\n \"def cvt2array(tuples):\\n rc = []\\n for t in tuples:\\n rc.append(point3d(np.float32(t[X]), np.float32(t[Y]), np.float32(t[Z])))\\n return rc\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\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 points_to_matrix(points):\\n points_matrix = np.matrix(points, dtype=np.float64).transpose()\\n omega = np.ones(len(points), dtype=np.float64)\\n points_matrix = np.matrix(np.vstack((points_matrix, omega)))\\n return points_matrix\",\n \"def rotate_point_cloud(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n for k in np.arange(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, 0, sinval],\\n [0, 1, 0],\\n [-sinval, 0, cosval]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def apply_translate( triangles, translate_tris=(0,0,0) ):\\n checkShapeValidity( triangles )\\n \\n for i in range(len(triangles)): # each tri in triangles\\n for j in range(len(triangles[i])): # each point in a tri\\n for k in range(len(translate_tris)): # each axis in a point\\n triangles[i][j][k] = float(triangles[i][j][k]) + float(translate_tris[k])\",\n \"def translate(self, x=0, y=0, z=0):\\n\\t\\ttranslation = np.identity(4)\\n\\t\\ttranslation[0, 3] += x\\n\\t\\ttranslation[1, 3] += y\\n\\t\\ttranslation[2, 3] += z\\n\\t\\t\\n\\t\\tself.matrix = np.matmul(self.matrix, translation)\",\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 transform(self, X):\\n\\n t0 = time.perf_counter()\\n check_is_fitted(self)\\n self.check_external_components_modified()#[WARN] in d3m, primitives can \\\"restore\\\" private class variables...\\n X = self._validate_data(X, accept_sparse=[\\\"csr\\\", \\\"csc\\\"], reset=False)\\n t1 = time.perf_counter()\\n\\n if X.shape[1] != self.components_af_.shape[1]:\\n raise ValueError(\\n \\\"Impossible to perform projection:\\\"\\n \\\"X at fit stage had a different number of features. \\\"\\n \\\"(%s != %s)\\\" % (X.shape[1], self.components_af_.shape[1])\\n )\\n\\n #X_new = safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)\\n #import pdb; pdb.set_trace()\\n X_af = af.interop.from_ndarray(X).as_type(self.components_af_.dtype())\\n X_new = af.matmulNT(X_af, self.components_af_)\\n X_new = X_new.to_ndarray()\\n t2 = time.perf_counter()\\n return X_new\",\n \"def batch_collate_fn(batch):\\n images = []\\n masks = []\\n \\n for (image, trimap, mask) in batch:\\n mask = mask.unsqueeze(0)\\n trimap = trimap.unsqueeze(0)\\n image = torch.cat([image, trimap], 0).unsqueeze(0)\\n \\n images.append(image)\\n masks.append(mask)\\n\\n images = torch.cat(images, 0)\\n masks = torch.cat(masks, 0)\\n\\n return (images, masks)\",\n \"def collate_fn(batch):\\r\\n transposed = zip(*batch)\\r\\n lbd = lambda batch:torch.cat([torch.from_numpy(b).long() for b in batch])\\r\\n return [lbd(samples) for samples in transposed]\",\n \"def Reproject(points, tm, rm):\\n proj_cuboid = np.array(points)\\n\\n rmat = np.identity(3)\\n rmat[0:2] = rm\\n tmat = np.identity(3)\\n tmat[0:2] = tm\\n\\n new_cuboid = np.matmul(\\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\\n new_cuboid = np.matmul(tmat, new_cuboid)\\n new_cuboid = new_cuboid[0:2].T\\n\\n return new_cuboid\",\n \"def Reproject(points,tm, rm):\\n proj_cuboid = np.array(points)\\n\\n rmat = np.identity(3)\\n rmat[0:2] = rm\\n tmat = np.identity(3)\\n tmat[0:2] = tm\\n\\n new_cuboid = np.matmul(\\n rmat, np.vstack((proj_cuboid.T, np.ones(len(points)))))\\n new_cuboid = np.matmul(tmat, new_cuboid)\\n new_cuboid = new_cuboid[0:2].T\\n\\n return new_cuboid\",\n \"def transl(x, y, z):\\n displace_vector = [[x],\\n [y],\\n [z]]\\n return np.matrix(displace_vector)\",\n \"def batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):\\n joints = torch.unsqueeze(joints, dim=-1)\\n rel_joints = joints.clone()\\n rel_joints[:, 1:] -= joints[:, parents[1:]]\\n transforms_mat = transform_mat(rot_mats.reshape(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4)\\n transform_chain = [transforms_mat[:, 0]]\\n for i in range(1, parents.shape[0]):\\n curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i])\\n transform_chain.append(curr_res)\\n transforms = torch.stack(transform_chain, dim=1)\\n posed_joints = transforms[:, :, :3, 3]\\n joints_homogen = F.pad(joints, [0, 0, 0, 1])\\n rel_transforms = transforms - F.pad(torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0])\\n return posed_joints, rel_transforms\",\n \"def _collate_fn(batch):\\r\\n batch = list(zip(*batch))\\r\\n batch[0] = torch.stack(batch[0])\\r\\n batch[1] = list(batch[1])\\r\\n batch[2] = torch.stack(batch[2])\\r\\n return tuple(batch)\",\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 batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32):\\n joints = torch.unsqueeze(joints, dim=-1)\\n rel_joints = joints.clone()\\n rel_joints[:, 1:] -= joints[:, parents[1:]]\\n transforms_mat = transform_mat(rot_mats.view(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4)\\n transform_chain = [transforms_mat[:, 0]]\\n for i in range(1, parents.shape[0]):\\n curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i])\\n transform_chain.append(curr_res)\\n transforms = torch.stack(transform_chain, dim=1)\\n posed_joints = transforms[:, :, :3, 3]\\n posed_joints = transforms[:, :, :3, 3]\\n joints_homogen = F.pad(joints, [0, 0, 0, 1])\\n rel_transforms = transforms - F.pad(torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0])\\n return posed_joints, rel_transforms\",\n \"def transformation(T,M):\\n\\n n = len(M) # Nb de lignes\\n p = len(M[0]) # Nb de colonnes\\n\\n x1, y1 = vecteur_image(T,0,n)\\n x2, y2 = vecteur_image(T,p,n)\\n x3, y3 = vecteur_image(T,p,0)\\n\\n xmin = round(min(0,x1,x2,x3))\\n xmax = round(max(0,x1,x2,x3))\\n ymin = round(min(0,y1,y2,y3))\\n ymax = round(max(0,y1,y2,y3))\\n\\n pp = xmax-xmin\\n nn = ymax-ymin\\n\\n Tinv = inverse_matrice(T)\\n\\n N = [[0 for jj in range(pp)] for ii in range(nn)]\\n for ii in range(nn):\\n for jj in range(pp):\\n j, i = vecteur_image(Tinv,jj+xmin,ii+ymin)\\n j, i = floor(j), floor(i)\\n if (0 <= i < n) and (0 <= j < p):\\n N[ii][jj] = M[i][j] \\n else:\\n N[ii][jj] = 0\\n\\n return N\",\n \"def forward(self, \\n point_features,\\n point_coordinates,\\n keypoint_indices,\\n set_indices):\\n\\n #print(f\\\"point_features: {point_features.shape}\\\")\\n #print(f\\\"point_coordinates: {point_coordinates.shape}\\\")\\n #print(f\\\"keypoint_indices: {keypoint_indices.shape}\\\")\\n #print(f\\\"set_indices: {set_indices.shape}\\\")\\n\\n # Gather the points in a set\\n point_set_features = point_features[set_indices[:, 0]]\\n point_set_coordinates = point_coordinates[set_indices[:, 0]]\\n point_set_keypoint_indices = keypoint_indices[set_indices[:, 1]]\\n\\n #point_set_keypoint_coordinates_1 = point_features[point_set_keypoint_indices[:, 0]]\\n point_set_keypoint_coordinates = point_coordinates[point_set_keypoint_indices[:, 0]]\\n\\n point_set_coordinates = point_set_coordinates - point_set_keypoint_coordinates\\n point_set_features = torch.cat([point_set_features, point_set_coordinates], axis=-1)\\n\\n # Step 1: Extract all vertex_features\\n extracted_features = self.point_linears(point_set_features) # N x 64\\n\\n # Step 2: Aggerate features using scatter max method.\\n #index = set_indices[:, 1].unsqueeze(-1).expand(-1, extracted_features.shape[-1]) # N x 64\\n #set_features = torch.zeros((len(keypoint_indices), extracted_features.shape[-1]), device=extracted_features.device).permute(1,0).contiguous() # len x 64\\n #set_features, argmax = scatter_max(extracted_features.permute(1,0), index.permute(1,0), out=set_features)\\n #set_features = set_features.permute(1,0)\\n\\n set_features = max_aggregation_fn(extracted_features, set_indices[:, 1], len(keypoint_indices))\\n\\n # Step 3: MLP for set_features\\n set_features = self.out_linears(set_features)\\n return set_features\",\n \"def poses_to_transforms(poses: Union[np.ndarray, List[np.ndarray]]):\\n transformations = copy.deepcopy(poses)\\n for i in range(len(poses)):\\n if i == 0:\\n transformations[i] = np.eye(4)\\n else:\\n transformations[i] = np.linalg.inv(poses[i - 1]).dot(poses[i])\\n return transformations\",\n \"def transform(self, images):\\n return np.array([self.transform_single(i) for i in images])\",\n \"def forward(self, x: torch.Tensor) -> torch.Tensor:\\r\\n output = torch.Tensor(x.shape[0], 3, x.shape[2], x.shape[3])\\r\\n\\r\\n for i in range(0, x.shape[0]):\\r\\n I_x = x[i][0,:,:]\\r\\n I_y = x[i][1,:,:]\\r\\n I_xx = torch.mul( x[i][0,:,:], x[i][0,:,:] )\\r\\n I_yy = torch.mul( x[i][1,:,:], x[i][1,:,:] )\\r\\n I_xy = torch.mul( x[i][0,:,:], x[i][1,:,:] )\\r\\n output[i,:,:,:] = torch.stack([I_xx, I_yy, I_xy]).unsqueeze(0)\\r\\n\\r\\n return output\",\n \"def transform(dataset):\\n\\n from tomviz import utils\\n import scipy.ndimage\\n import numpy as np\\n import warnings\\n\\n array = dataset.active_scalars\\n\\n zoom = (0.5, 0.5, 1)\\n result_shape = utils.zoom_shape(array, zoom)\\n result = np.empty(result_shape, array.dtype, order='F')\\n # Downsample the dataset x2 using order 1 spline (linear)\\n warnings.filterwarnings('ignore', '.*output shape of zoom.*')\\n scipy.ndimage.interpolation.zoom(array, zoom,\\n output=result,\\n order=1,\\n mode='constant',\\n cval=0.0, prefilter=False)\\n\\n # Set the result as the new scalars.\\n dataset.active_scalars = result\",\n \"def transform_batch(self, inputs_batch, target_ids_batch, targets_batch):\\n # extract one-hot encoded feature vectors and reshape them\\n # so we can feed them to the RNN\\n batch_inputs = inputs_batch.toarray()\\n batch_inputs = batch_inputs.reshape(\\n self.batch_size, self.max_num_ans, self.encoding_dim)\\n # targets_batch is a list of lists, which we need to flatten\\n batch_targets = [i for sublist in targets_batch for i in sublist]\\n batch_targets = np.array(batch_targets, dtype=np.float32)\\n # during learning, the data for each student in a batch gets shuffled together\\n # hence, we need a vector of indices to locate their predictions after learning\\n batch_target_ids = target_ids_batch.toarray()\\n batch_target_ids = np.array(\\n batch_target_ids.reshape(-1),\\n dtype=np.int32)\\n\\n return batch_inputs, batch_target_ids, batch_targets\",\n \"def transl(x, y=None, z=None):\\n \\n if y == None and z == None:\\n x = mat(x)\\n try:\\n if ishomog(x):\\n return x[0:3, 3].reshape(3, 1)\\n else:\\n return concatenate((concatenate((eye(3), x.reshape(3, 1)), 1), mat([0, 0, 0, 1])))\\n except AttributeError:\\n n = len(x)\\n r = [[], [], []]\\n for i in range(n):\\n r = concatenate((r, x[i][0:3, 3]), 1)\\n return r\\n elif y != None and z != None:\\n return concatenate((concatenate((eye(3), mat([x, y, z]).T), 1), mat([0, 0, 0, 1])))\",\n \"def patches_from_3d_points(self, points, patch_size):\\n patch_centers = np.round(project(self.camera.P, points.T)).astype(int)\\n\\n patches = self.patches(patch_centers, patch_size)\\n return patches\",\n \"def three_vec3_to_mat3(f: vec3, l: vec3, u: vec3) -> mat3:\\r\\n return mat3(f[0], l[0], u[0], f[1], l[1], u[1], f[2], l[2], u[2])\",\n \"def prepare_data(cameras, frame_points_3d, frame_points_2d, keyframe_idx):\\n camera_params = np.empty((0, 9))\\n for c in cameras:\\n R, _ = cv2.Rodrigues(c.R_mat)\\n camera = build_camera(R, c.t)\\n camera_params = np.append(camera_params, [camera], axis=0)\\n\\n camera_indices = []\\n point_indices = []\\n points_2d = np.empty((0, 2))\\n points_3d = np.empty((0, 3))\\n\\n camera_id = 0\\n pt_id_counter = 0\\n for k, pts_2d in enumerate(frame_points_2d):\\n if k > 0:\\n halfway_idx = keyframe_idx[k] - keyframe_idx[k - 1] - 1\\n points_2d = np.vstack((points_2d, frame_points_2d[k-1][halfway_idx]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k-1][halfway_idx]))\\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-1][halfway_idx]))]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-1][halfway_idx]))]\\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-1][halfway_idx])\\n\\n if k > 1:\\n end_idx = keyframe_idx[k + 1] - keyframe_idx[k - 1] - 3\\n points_2d = np.vstack((points_2d, frame_points_2d[k-2][end_idx]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k-2][end_idx]))\\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-2][end_idx]))]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-2][end_idx]))]\\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-2][end_idx])\\n\\n points_2d = np.vstack((points_2d, frame_points_2d[k][0]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k][0]))\\n camera_indices += [camera_id for _ in range(pts_2d.shape[1])]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + pts_2d.shape[1])]\\n\\n camera_id += 1\\n pt_id_counter = pt_id_counter + pts_2d.shape[1]\\n\\n return camera_params, np.asarray(camera_indices), np.asarray(point_indices), points_3d, points_2d\",\n \"def map(self, obj):\\n if isinstance(obj, np.ndarray) and obj.ndim >= 2 and obj.shape[0] in (2,3):\\n return fn.transformCoordinates(self, obj)\\n else:\\n return QtGui.QMatrix4x4.map(self, obj)\",\n \"def collate_fn(self, batch):\\n images, boxes, categories = [], [], []\\n\\n for b in batch:\\n images.append(b['img'])\\n boxes.append(b['box'])\\n categories.append(b['category'])\\n\\n images = torch.stack(images, dim=0)\\n\\n # tensor (N, 3, 300, 300), 3 lists of N tensors each\\n return {\\n 'imgs': images,\\n 'boxes': boxes,\\n 'categories': categories\\n }\",\n \"def rotate_point_cloud_in_plane(batch_data):\\n rotated_data = np.zeros(batch_data.shape, dtype=np.float32)\\n #rotated_label = np.zeros(batch_label.shape, dtype=np.float32)\\n #rotation_angle = np.random.uniform() * 2 * np.pi\\n #cosval = np.cos(rotation_angle)\\n #sinval = np.sin(rotation_angle)\\n for k in range(batch_data.shape[0]):\\n rotation_angle = np.random.uniform() * 2 * np.pi\\n cosval = np.cos(rotation_angle)\\n sinval = np.sin(rotation_angle)\\n rotation_matrix = np.array([[cosval, -sinval, 0],\\n [sinval, cosval, 0],\\n [0, 0, 1]])\\n shape_pc = batch_data[k, ...]\\n rotated_data[k, ...] = np.dot(shape_pc.reshape((-1, 3)), rotation_matrix)\\n return rotated_data\",\n \"def transform(self, R, t, scale = 1):\\n\\n # Build 4-by-4 projection matrix from args ----------------------------\\n # This is what we are doing internally:\\n # Proj = np.r_[ scale * np.c_[R, t], [[0, 0, 0, 1]] ]\\n # InvProj = np.r_[ scale * np.c_[R.T, -np.dot(R.T, t)], [[0,0,0,scale]] ]\\n Proj = tf_format.tf_format('4x4', R, t)\\n Proj[:-1,:] *= scale\\n InvProj = tf_format.tf_format('i4x4', R, t) * scale\\n \\n \\n # Apply transformation to pts3D ---------------------------------------\\n if self.pts3D is not None and self.pts3D.shape[1] > 0:\\n # Use homogeneous coords\\n pts3D = np.r_[self.pts3D, np.ones((1, self.pts3D.shape[1]))]\\n pts3D = np.dot(Proj, pts3D)\\n self.pts3D = pts3D[:3, :]\\n\\n # Apply transformation to cameras -------------------------------------\\n # Camera poses are stored using camera-to-world transformations, we \\n # need to invert the projection matrix for this to work --> \\n # we use InvProj\\n\\n cposes = self.cam_poses\\n for i in range(cposes.shape[1]):\\n\\n # Extract camera projection matrix\\n p_cam = tf_format.tf_format('4x4', cposes[:, i])\\n\\n # Transform camera projection matrix\\n new_p_cam = np.dot(p_cam, InvProj)\\n \\n # Make sure it's a true rotation!\\n [u, s, vT] = np.linalg.svd(new_p_cam[:3,:3])\\n cposes[:3, i] = tf_format.rodrigues( np.dot(u,vT) ).ravel()\\n cposes[3:, i] = new_p_cam[:3, 3]\\n\\n self.cam_poses = cposes\",\n \"def transform(self, x: Array2D) -> Array2D:\",\n \"def transformation_2d(vertices, kernels=KERNELS):\\n\\t# calculate the transpose matrix of vertices\\n\\ttranspose = vertices.transpose()\\n\\t# insert a row of ones in the transpose matrix's end, then insert the result in 'matrices' list\\n\\tkernels.append(np.append(transpose, [np.ones(len(transpose[0]))], axis=0))\\n\\t# multiply matrices into 'kernels' list,\\n\\t# remove the last row (of ones) and calculate the transpose matrix of the result\\n\\tfinal_transformation_result = np.delete(np.linalg.multi_dot(kernels), 2, 0).transpose()\\n\\tKERNELS.clear()\\n\\treturn final_transformation_result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68185866","0.6803297","0.67199254","0.66627663","0.63769263","0.63079566","0.62875766","0.62417156","0.6226377","0.61661714","0.6095978","0.60583246","0.6042413","0.6042413","0.6038547","0.60366297","0.5996688","0.59671736","0.59586704","0.59217936","0.5850457","0.583458","0.5810653","0.5789412","0.5764324","0.5748576","0.5746073","0.57433766","0.5728391","0.5724807","0.57095194","0.56995976","0.5670716","0.56693274","0.5664242","0.5664242","0.56344485","0.5630801","0.5630347","0.5627058","0.56172353","0.5589097","0.5579397","0.55763227","0.5568432","0.555948","0.5555647","0.5544319","0.55405086","0.55402523","0.5521982","0.5519772","0.55133015","0.55081934","0.5498707","0.54919577","0.54864955","0.5485912","0.5485912","0.5485632","0.54853845","0.5481743","0.5476999","0.54676366","0.5465076","0.5465076","0.5465076","0.54516196","0.5446712","0.5439356","0.543044","0.54243845","0.54222244","0.54217124","0.541987","0.54117197","0.5396283","0.53931785","0.5380903","0.5373242","0.53730756","0.536792","0.5364532","0.53593373","0.5358156","0.53500515","0.53460723","0.5341772","0.5339321","0.5337749","0.53193176","0.5316645","0.53156745","0.5312826","0.5312819","0.53127897","0.5308739","0.5305818","0.53033304","0.5297635"],"string":"[\n \"0.68185866\",\n \"0.6803297\",\n \"0.67199254\",\n \"0.66627663\",\n \"0.63769263\",\n \"0.63079566\",\n \"0.62875766\",\n \"0.62417156\",\n \"0.6226377\",\n \"0.61661714\",\n \"0.6095978\",\n \"0.60583246\",\n \"0.6042413\",\n \"0.6042413\",\n \"0.6038547\",\n \"0.60366297\",\n \"0.5996688\",\n \"0.59671736\",\n \"0.59586704\",\n \"0.59217936\",\n \"0.5850457\",\n \"0.583458\",\n \"0.5810653\",\n \"0.5789412\",\n \"0.5764324\",\n \"0.5748576\",\n \"0.5746073\",\n \"0.57433766\",\n \"0.5728391\",\n \"0.5724807\",\n \"0.57095194\",\n \"0.56995976\",\n \"0.5670716\",\n \"0.56693274\",\n \"0.5664242\",\n \"0.5664242\",\n \"0.56344485\",\n \"0.5630801\",\n \"0.5630347\",\n \"0.5627058\",\n \"0.56172353\",\n \"0.5589097\",\n \"0.5579397\",\n \"0.55763227\",\n \"0.5568432\",\n \"0.555948\",\n \"0.5555647\",\n \"0.5544319\",\n \"0.55405086\",\n \"0.55402523\",\n \"0.5521982\",\n \"0.5519772\",\n \"0.55133015\",\n \"0.55081934\",\n \"0.5498707\",\n \"0.54919577\",\n \"0.54864955\",\n \"0.5485912\",\n \"0.5485912\",\n \"0.5485632\",\n \"0.54853845\",\n \"0.5481743\",\n \"0.5476999\",\n \"0.54676366\",\n \"0.5465076\",\n \"0.5465076\",\n \"0.5465076\",\n \"0.54516196\",\n \"0.5446712\",\n \"0.5439356\",\n \"0.543044\",\n \"0.54243845\",\n \"0.54222244\",\n \"0.54217124\",\n \"0.541987\",\n \"0.54117197\",\n \"0.5396283\",\n \"0.53931785\",\n \"0.5380903\",\n \"0.5373242\",\n \"0.53730756\",\n \"0.536792\",\n \"0.5364532\",\n \"0.53593373\",\n \"0.5358156\",\n \"0.53500515\",\n \"0.53460723\",\n \"0.5341772\",\n \"0.5339321\",\n \"0.5337749\",\n \"0.53193176\",\n \"0.5316645\",\n \"0.53156745\",\n \"0.5312826\",\n \"0.5312819\",\n \"0.53127897\",\n \"0.5308739\",\n \"0.5305818\",\n \"0.53033304\",\n \"0.5297635\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58872557"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":84686,"cells":{"query":{"kind":"string","value":"Transforms a single 3D mesh."},"document":{"kind":"string","value":"def transform_mesh(mesh: InputTensor, matrix: InputTensor,\n vertices_are_points=True) -> t.Tensor:\n mesh = util.to_tensor(mesh, dtype=t.float32)\n matrix = util.to_tensor(matrix, dtype=t.float32)\n\n assert mesh.shape[-2:] == (3, 3)\n assert matrix.shape[-2:] == (4, 4)\n assert mesh.shape[:-3] == matrix.shape[:-2]\n\n original_shape = mesh.shape\n mesh = mesh.reshape([-1, mesh.shape[-3] * 3, 3])\n matrix = matrix.reshape([-1, 4, 4])\n w = 1 if vertices_are_points else 0\n mesh = transform_points_homogeneous(mesh, matrix, w=w)\n if vertices_are_points:\n mesh = mesh[..., :3] / mesh[..., 3:4]\n else:\n mesh = mesh[..., :3]\n\n return mesh.reshape(original_shape)"},"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 transform(self, data):\n self.cube = self.trf.transform(data)","def GetTransform(self, *args) -> \"itkTransformD33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_GetTransform(self, *args)","def GetTransform(self, *args) -> \"itkTransformF33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_GetTransform(self, *args)","def transform(mesh, translation_scale=1000.0):\n # rotate and translate randomly\n matrix = transformations.random_rotation_matrix(\n translate=translation_scale)\n\n # randomly re-order triangles\n triangles = np.random.permutation(mesh.triangles).reshape((-1, 3))\n # apply rigid transform\n triangles = transformations.transform_points(triangles, matrix)\n\n # extract the class from the input object\n mesh_type = util.type_named(mesh, 'Trimesh')\n # generate a new mesh from the permutated data\n permutated = mesh_type(\n **triangles_module.to_kwargs(triangles.reshape((-1, 3, 3))))\n\n return permutated","def transform_mesh_filter(*args, **kwargs):\n import itk\n instance = itk.TransformMeshFilter.New(*args, **kwargs)\n return instance.__internal_call__()","def CreateSurface2DMeshfrom3DMesh(self):\n\n self.__do_memebers_exist__()\n\n p = self.InferPolynomialDegree()\n mm = Mesh()\n if self.element_type == \"hex\":\n mm.element_type = \"quad\"\n elif self.element_type == \"tet\":\n mm.element_type = \"tri\"\n else:\n raise ValueError(\"Cannot make a 2D mesh from the 3D mesh of type {}\".format(self.element_type))\n\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\n mm.points = self.points[unique_faces,:]\n mm.nnode = mm.points.shape[0]\n aranger = np.arange(mm.nnode)\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\n mm.nelem = mm.elements.shape[0]\n mm.GetBoundaryEdges()\n\n return mm","def from_trimesh(mesh):\n vformat = p3d.GeomVertexFormat.get_v3n3()\n vertices = np.column_stack((mesh.vertices, mesh.vertex_normals))\n # TODO: uvs\n return Mesh._make(vformat, vertices, mesh.faces)","def itkTranslationTransformD3_cast(*args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_cast(*args)","def test_3d_tranpose(): \n dic,data = ng.pipe.read_lowmem(\"common_data/3d_pipe/ft/test%03d.ft3\")\n fdic,fdata = ng.pipe.read(\"common_data/3d_pipe/ft/test%03d.ft3\")\n\n assert_array_equal(data.transpose()[0,1,2],fdata.transpose()[0,1,2])\n assert_array_equal(data.transpose((2,0,1))[0,1,2],\n fdata.transpose((2,0,1))[0,1,2])\n assert_array_equal(data.swapaxes(0,1)[0,1,2],fdata.swapaxes(0,1)[0,1,2])\n assert_array_equal(data.swapaxes(2,0)[0,1,2],fdata.swapaxes(2,0)[0,1,2])","def SetTransform(self, _arg: 'itkTransformF33') -> \"void\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_SetTransform(self, _arg)","def SetTransform(self, _arg: 'itkTransformD33') -> \"void\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_SetTransform(self, _arg)","def rescale_and_translate_mesh(data, meshname,\n mesh_new_origin=np.array([0.,0.,0.]),\n mesh_new_size=np.array([1.,1.,1.])):\n # get mesh nodes as hdf5 node (directly in memory data)\n # and rescale mesh\n nodes = data.get_mesh_nodes(meshname, as_numpy=False)\n # Translate mesh to origin 0,0,0\n nodes[:,0] = nodes[:,0] - nodes[:,0].min()\n nodes[:,1] = nodes[:,1] - nodes[:,1].min()\n if nodes.shape[1] == 3:\n nodes[:,2] = nodes[:,2] - nodes[:,2].min()\n # Get mesh new X,Y and Z sizes\n X_new_size = mesh_new_size[0]\n Y_new_size = mesh_new_size[1]\n if nodes.shape[1] == 3:\n Z_new_size = mesh_new_size[2]\n # Compute old mesh corrdinate range for each dimension\n X_size = nodes[:,0].max() - nodes[:,0].min()\n Y_size = nodes[:,1].max() - nodes[:,1].min()\n if nodes.shape[1] == 3:\n Z_size = nodes[:,2].max() - nodes[:,2].min()\n # Dilate mesh along each dimension to new mesh size\n nodes[:,0] = (nodes[:,0]/X_size)*X_new_size\n nodes[:,1] = (nodes[:,1]/Y_size)*Y_new_size\n if nodes.shape[1] == 3:\n nodes[:,2] = (nodes[:,2]/Z_size)*Z_new_size\n # Translate mesh\n nodes[:,0] = nodes[:,0] + mesh_new_origin[0]\n nodes[:,1] = nodes[:,1] + mesh_new_origin[1]\n if nodes.shape[1] == 3:\n nodes[:,2] = nodes[:,2] + mesh_new_origin[2]\n # flush new nodes in memory\n nodes.flush()\n return","def itkTransformMeshFilterMF3MF3TF33_cast(obj: 'itkLightObject') -> \"itkTransformMeshFilterMF3MF3TF33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_cast(obj)","def BackTransform(self, *args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_BackTransform(self, *args)","def ProjectToPlane(self):\n\n self.__do_essential_memebers_exist__()\n if self.element_type != \"tri\":\n raise ValueError(\"Project to plane is only applicable to triangles\")\n\n imesh = deepcopy(self)\n coordinates = []\n connectivities = []\n for counter, elem in enumerate(imesh.elements):\n\n elementCoordinates = imesh.points[elem,:]\n\n A = elementCoordinates[0,:]\n B = elementCoordinates[1,:]\n C = elementCoordinates[2,:]\n\n X = (B - A); X /= np.linalg.norm(X)\n Z = np.cross(X, C - A); Z /= np.linalg.norm(Z)\n Y = np.cross(Z, X)\n\n # PROJECT THE TRIANGLE TO THIS BASES\n a = [0., 0.]\n b = [np.linalg.norm((B - A)), 0.]\n c = [(C - A).dot(X), (C - A).dot(Y)]\n\n coordinates.append(a)\n coordinates.append(b)\n coordinates.append(c)\n\n elementConnectivity = [3 * counter, 3 * counter + 1, 3 * counter + 2]\n connectivities.append(elementConnectivity)\n\n coordinates = np.array(coordinates)\n connectivities = np.array(connectivities)\n imesh.points = coordinates\n imesh.elements = connectivities\n imesh.nelem = imesh.elements.shape[0]\n imesh.nnode = imesh.points.shape[0]\n\n return imesh","def transform3D(a, f):\n return f[0].dot(a) + f[1]","def cast(*args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_cast(*args)","def transform( self, matrix3 ):\n self._coords = matrix3._matrix * self._coords\n return self","def itkTransformMeshFilterMF3MF3TD33_cast(obj: 'itkLightObject') -> \"itkTransformMeshFilterMF3MF3TD33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_cast(obj)","def rotate_mesh(mesh):\n rot_90_z = np.transpose(np.array([[0,1,0],[-1,0,0],[0,0,1]]))\n rot_90_x = np.transpose(np.array([[1,0,0],[0,0,1],[0,-1,0]]))\n rot_90_y = np.transpose(np.array([[0,0,1],[0,1,0],[-1,0,0]]))\n angle = np.radians(-30)\n angle2 = np.radians(10)\n rot_angle_x = np.array([[1,0,0],[0,np.cos(angle2),-np.sin(angle2)],[0,np.sin(angle2),np.cos(angle2)]])\n rot_angle_y = np.array([[np.cos(angle),0,-np.sin(angle)],[0,1,0],[np.sin(angle),0,np.cos(angle)]])\n for j in range(len(mesh.vertices)):\n mesh.vertices[j] = (mesh.vertices[j]@rot_90_y)@(np.transpose(rot_90_z))@rot_angle_y@rot_angle_x\n #mesh.vertices[j]*=3","def TransformVector(self, *args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_TransformVector(self, *args)","def transform3D(x: float, y: float, z: float, R: np.array) -> np.array:\n T = np.zeros((4, 4))\n T[:3, :3] = R\n T[:, 3] = [x, y, z, 1.0]\n\n return T","def itkMeshSourceMF3_cast(obj: 'itkLightObject') -> \"itkMeshSourceMF3 *\":\n return _itkMeshSourcePython.itkMeshSourceMF3_cast(obj)","def Compose(self, *args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_Compose(self, *args)","def transform(self, matrix: Matrix3D):\n transform = self._local_transform\n transform.transformBy(matrix)\n self._reset_cache()\n return self","def get_3d_joints_from_mesh(self, vertices):\n return torch.matmul(self.joints_regressor, vertices)","def Translate(self, *args):\n return _itkTranslationTransformPython.itkTranslationTransformD3_Translate(self, *args)","def apply_dof_transformation_to_transpose_tetrahedron(\n entity_transformations, entity_dofs, data, cell_info\n):\n apply_dof_transformation_to_transpose(3, 6, 4, entity_transformations, entity_dofs,\n data, cell_info, List([\"triangle\"] * 4))","def b_transform_cube(b_obj):\n \n b_scale_object()\n b_scale_single_face(b_obj)","def euler_3d_transform(initialize=False, fixed=None, moments=True) :\n \n transform = itk.Euler3DTransform[itk.D].New()\n \n if initialize :\n fixed_itk = medipy.itk.medipy_image_to_itk_image(fixed, False)\n #moving_itk = medipy.itk.medipy_image_to_itk_image(moving, False)\n\n fixedIndex = fixed_itk.GetLargestPossibleRegion().GetIndex()\n fixedSize = fixed_itk.GetLargestPossibleRegion().GetSize()\n\n centerIndex = (int(fixedIndex[0] + fixedSize[0] / 2.0), \\\n int(fixedIndex[1] + fixedSize[1] / 2.0), \\\n int(fixedIndex[2] + fixedSize[2] / 2.0))\n\n rotationCenter = fixed_itk.TransformIndexToPhysicalPoint(centerIndex)\n\n transform.SetIdentity()\n transform.SetCenter(rotationCenter)\n \n #initial_transform = itk.VersorRigid3DTransform[itk.D].New()\n #initializer = itk.CenteredTransformInitializer[\n # initial_transform, fixed_itk, moving_itk].New(\n # Transform=initial_transform, FixedImage=fixed_itk, MovingImage=moving_itk) \n #if moments :\n # initializer.MomentsOn()\n #else :\n # initializer.GeometryOn()\n #initializer.InitializeTransform()\n #transform.SetCenter(initial_transform.GetCenter())\n #transform.SetOffset(initial_transform.GetOffset())\n \n return transform","def convert_coordinate_system_3d(x, y, z):\n\n return x, -z, y","def from_mesh_data(mesh):\n if len(mesh.normals) > 0 and len(mesh.uvs) > 0:\n vformat = p3d.GeomVertexFormat.get_v3n3t2()\n vertices = np.column_stack((mesh.vertices, mesh.normals, mesh.uvs))\n elif len(mesh.normals) > 0:\n vformat = p3d.GeomVertexFormat.get_v3n3()\n vertices = np.column_stack((mesh.vertices, mesh.normals))\n elif len(mesh.uvs) > 0:\n vformat = p3d.GeomVertexFormat.get_v3t2()\n vertices = np.column_stack((mesh.vertices, mesh.uvs))\n else:\n vformat = p3d.GeomVertexFormat.get_v3()\n vertices = mesh.vertices\n return Mesh._make(vformat, vertices, mesh.faces)","def itkMeshSourceMUS3_cast(obj: 'itkLightObject') -> \"itkMeshSourceMUS3 *\":\n return _itkMeshSourcePython.itkMeshSourceMUS3_cast(obj)","def trimesh_to_vrml(mesh, output_file):\n\n with open(output_file, 'w') as f:\n f.write('#VRML V2.0 utf8\\n')\n f.write('Transform {\\n'\n ' children [\\n'\n ' Shape {\\n'\n ' geometry IndexedFaceSet {\\n'\n ' coord Coordinate {\\n'\n ' point[\\n')\n for v in mesh.vertices:\n f.write(' {:0.6f} {:0.6f} {:0.6f},\\n'.format(*v.tolist()))\n f.write(' ] # end of points\\n'\n ' } # end of Coordinate\\n'\n ' coordIndex [\\n')\n\n for face in mesh.faces:\n f.write(' {:d}, {:d}, {:d}, -1,\\n'.format(*face.tolist()))\n\n f.write(' ] # end of coordIndex\\n'\n ' } # end of geometry\\n'\n ' appearance Appearance {\\n'\n ' material Material {\\n'\n ' diffuseColor 0.7 0.7 0.7\\n'\n ' emissiveColor 0.05 0.05 0.05\\n'\n ' specularColor 1.0 1.0 1.0\\n'\n ' ambientIntensity 0.2\\n'\n ' shininess 0.2\\n'\n ' transparency 0.0\\n'\n ' } #end of material\\n'\n ' } #end of appearance\\n'\n ' } # end of Shape\\n'\n ' ] # end of children\\n'\n '}\\n')","def GetTransform(self, *args) -> \"itkTransformF22 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TF22_GetTransform(self, *args)","def d3transf_df3(self,f):\r\n raise NotImplementedError","def matrix_apply_to_3d_3x3(vol, matrix: np.matrix):\n from scipy import mgrid\n\n cx = vol.shape[0]/2\n cy = vol.shape[1]/2\n cz = vol.shape[2]/2\n\n # Calculate the new coordinates of every point\n grid = mgrid[-cx:vol.shape[0]-cx, -cy:vol.shape[1]-cy, -cz:vol.shape[2]-cz]\n temp = grid.reshape((3, grid.size / 3))\n # Add the fourth dimension (just 1s but needed for the computations)\n # Use the matrix to calculate the new positions of every point\n temp = np.dot(matrix, temp)\n # Delete the fourth dimension\n temp = np.array(temp)\n grid = np.reshape(temp, (3, vol.shape[0], vol.shape[1], vol.shape[2]))\n\n grid[0] += cx\n grid[1] += cy\n grid[2] += cz\n\n from scipy.ndimage.interpolation import map_coordinates\n d = map_coordinates(vol, grid, order=3)\n\n return d","def Get3dConversion(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_Get3dConversion(self, *args)","def itkMeshSourceMD3Q_cast(*args):\n return _itkMeshSourcePython.itkMeshSourceMD3Q_cast(*args)","def transform_cube(self,\n cube: xr.Dataset,\n gm: GridMapping,\n cube_config: CubeConfig) -> TransformedCube:","def scale_on_3d(x3d, scaler):\n (n_segs, n_concat, n_freq) = x3d.shape\n x2d = x3d.reshape((n_segs * n_concat, n_freq))\n x2d = scaler.transform(x2d)\n x3d = x2d.reshape((n_segs, n_concat, n_freq))\n return x3d","def Set3dConversion(self, *args):\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_Set3dConversion(self, *args)","def GetTransform(self, *args) -> \"itkTransformD22 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetTransform(self, *args)","def cast(obj: 'itkLightObject') -> \"itkMeshSourceMF3 *\":\n return _itkMeshSourcePython.itkMeshSourceMF3_cast(obj)","def draw_stl_from_mesh(m):\n plt.ion()\n # Create a new plot\n figure = plt.figure()\n axes = mplot3d.Axes3D(figure)\n\n # Render the cube faces\n #for m in meshes:\n axes.add_collection3d(mplot3d.art3d.Poly3DCollection(m.vectors))\n\n # Auto scale to the mesh size\n scale = m.points.flatten(-1)\n axes.auto_scale_xyz(scale, scale, scale)","def new_mesh_set(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = []\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if not isinstance(all_meshes, list):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n self.all_meshes = all_meshes\n\n # Remove previous actors from the scene\n for actor in self.mesh_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.mesh_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtkPoints()\n for i, mesh in enumerate(self.all_meshes):\n if mesh.time.size != 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n points = vtkPoints()\n for j in range(mesh.channel.size):\n # points.InsertNextPoint([0, 0, 0])\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\n\n # Create an array for each triangle\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\n if draw_patch:\n poly_type = vtkPolygon\n n_ids = 3\n color = self.patch_color[i]\n else:\n poly_type = vtkPolyLine\n n_ids = 4\n color = self.mesh_color\n cells = vtkCellArray()\n\n # Create the polygons\n for j in range(mesh.triangles.shape[1]):\n poly = poly_type()\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\n for k in range(len(mesh.triangles[:, j])):\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\n if not draw_patch:\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\n cells.InsertNextCell(poly)\n\n poly_data = vtkPolyData()\n poly_data.SetPoints(points)\n if draw_patch:\n poly_data.SetPolys(cells)\n else:\n poly_data.SetLines(cells)\n\n mapper = vtkPolyDataMapper()\n mapper.SetInputData(poly_data)\n\n # Create an actor\n self.mesh_actors.append(vtkActor())\n self.mesh_actors[i].SetMapper(mapper)\n self.mesh_actors[i].GetProperty().SetColor(color)\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\n\n self.parent_window.ren.AddActor(self.mesh_actors[i])\n\n # Update marker position\n self.update_mesh(self.all_meshes)","def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])","def apply_dof_transformation_to_transpose_prism(\n entity_transformations, entity_dofs, data, cell_info\n):\n apply_dof_transformation_to_transpose(3, 9, 5, entity_transformations, entity_dofs,\n data, cell_info, List([\"triangle\"] + [\"quadrilateral\"] * 4 + [\"triangle\"]))","def _project(self):\n ghosts_w = self.input_field.topology.ghosts()\n self.input_field.data[0], self.input_field.data[1], \\\n self.input_field.data[2] = \\\n fftw2py.projection_om_3d(self.input_field.data[0],\n self.input_field.data[1],\n self.input_field.data[2], ghosts_w)","def as_mesh(scene_or_mesh):\n if isinstance(scene_or_mesh, trimesh.Scene):\n if len(scene_or_mesh.geometry) == 0:\n mesh = None # empty scene\n else:\n # we lose texture information here\n mesh = trimesh.util.concatenate(\n tuple(trimesh.Trimesh(vertices=g.vertices, faces=g.faces)\n for g in scene_or_mesh.geometry.values()))\n else:\n assert(isinstance(scene_or_mesh, trimesh.Trimesh))\n mesh = scene_or_mesh\n return mesh","def test_convert_MeshVTK():\n mesh = MeshVTK(\n path=join(TEST_DATA_DIR, \"StructElmer\"), name=\"case_t0001\", format=\"vtu\"\n )\n\n meshmat = mesh.convert(meshtype=\"MeshMat\", scale=1)\n\n # meshsol = MeshSolution(mesh=[meshmat])\n # meshsol.plot_mesh(is_show_fig=False)","def cast(obj: 'itkLightObject') -> \"itkTransformMeshFilterMF3MF3TF33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_cast(obj)","def cast(*args):\n return _itkMeshSourcePython.itkMeshSourceMD3Q_cast(*args)","def Compute3d(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_Compute3d(self, *args)","def cast(obj: 'itkLightObject') -> \"itkMeshSourceMUS3 *\":\n return _itkMeshSourcePython.itkMeshSourceMUS3_cast(obj)","def itkMeshSourceMUC3_cast(obj: 'itkLightObject') -> \"itkMeshSourceMUC3 *\":\n return _itkMeshSourcePython.itkMeshSourceMUC3_cast(obj)","def manifold_and_triangulate():\n # Switch in edit mode \n bpy.ops.object.mode_set(mode='EDIT')\n\n # Deselect everything\n bpy.ops.mesh.select_all(action=\"DESELECT\")\n\n # Pass in vertices selection\n bpy.ops.mesh.select_mode(type=\"VERT\")\n\n # Select non manifold vertices\n bpy.ops.mesh.select_non_manifold()\n\n # Add an edge or face to selected vertices\n bpy.ops.mesh.edge_face_add()\n\n # Pass in faces selection\n bpy.ops.mesh.select_mode(type=\"FACE\")\n\n # Select all the faces\n bpy.ops.mesh.select_all(action='SELECT')\n \n # Triangulate the faces\n bpy.ops.mesh.quads_convert_to_tris(quad_method='FIXED_ALTERNATE', ngon_method='CLIP')\n\n # Switch in object mode \n bpy.ops.object.mode_set(mode='OBJECT')","def as_mesh(scene_or_mesh):\n if isinstance(scene_or_mesh, trimesh.Scene):\n if len(scene_or_mesh.geometry) == 0:\n mesh = None # empty scene\n else:\n # we lose texture information here\n mesh = trimesh.util.concatenate(\n tuple(trimesh.Trimesh(vertices=g.vertices, faces=g.faces)\n for g in scene_or_mesh.geometry.values()))\n else:\n mesh = scene_or_mesh\n assert(isinstance(mesh, trimesh.Trimesh))\n return mesh","def cast(obj: 'itkLightObject') -> \"itkTransformMeshFilterMF3MF3TD33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_cast(obj)","def compose_transform3(phi1,theta1,psi1,sx1,sy1,sz1,scale1,phi2,theta2,psi2,sx2,sy2,sz2,scale2):\n\n\tR1 = Transform({\"type\":\"spider\",\"phi\":float(phi1),\"theta\":float(theta1),\"psi\":float(psi1),\"tx\":float(sx1),\"ty\":float(sy1),\"tz\":float(sz1),\"mirror\":0,\"scale\":float(scale1)})\n\tR2 = Transform({\"type\":\"spider\",\"phi\":float(phi2),\"theta\":float(theta2),\"psi\":float(psi2),\"tx\":float(sx2),\"ty\":float(sy2),\"tz\":float(sz2),\"mirror\":0,\"scale\":float(scale2)})\n\tRcomp=R2*R1\n\td = Rcomp.get_params(\"spider\")\n\treturn d[\"phi\"],d[\"theta\"],d[\"psi\"],d[\"tx\"],d[\"ty\"],d[\"tz\"],d[\"scale\"]","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:])","def rigid_transform_3d(v, mapping, alpha = 1):\r\n p_wgt = vec3(0, 0, 0)\r\n q_wgt = vec3(0, 0, 0)\r\n w = len(mapping)*[None]\r\n w_sum = 0\r\n for i in range(len(mapping)):\r\n mp = mapping[i]\r\n x = mp[0].x - v.x\r\n y = mp[0].y - v.y\r\n z = mp[0].z - v.z\r\n if (x == 0 and y == 0 and z == 0): return mp[1]\r\n w[i] = 1/((x*x + y*y + z*z) ** alpha)\r\n p_wgt += mp[0]*w[i]\r\n q_wgt += mp[1]*w[i]\r\n w_sum += w[i]\r\n p_wgt /= w_sum\r\n q_wgt /= w_sum\r\n A = mat3(0)\r\n for i in range(len(mapping)):\r\n mp = mapping[i]\r\n p_adj = mp[0] - p_wgt\r\n q_adj = mp[1] - q_wgt\r\n A += w[i]*p_adj.transpose_multiply(q_adj)\r\n A_arr = np.array(A.matrix).reshape(3, 3)\r\n U, S, V = np.linalg.svd(A_arr)\r\n M_arr = np.matmul(np.transpose(V), np.transpose(U))\r\n M = mat3(M_arr.ravel().tolist())\r\n v_out = M*(v - p_wgt) + q_wgt\r\n return v_out","def mesh(self):\n self._ensure_mesh()\n return self._mesh","def itkMeshSourceMSS3_cast(obj: 'itkLightObject') -> \"itkMeshSourceMSS3 *\":\n return _itkMeshSourcePython.itkMeshSourceMSS3_cast(obj)","def to_se3(self, state: Vector) -> RigidTransform:\n return (state[:9],state[9:12])","def GetModifiableTransform(self) -> \"itkTransformF33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_GetModifiableTransform(self)","def _triangular_mesh_to_three_geometry(vertices, faces, vertex_colors=None):\n context = _js_builder.Js(mode=_js_builder.PERSISTENT)\n vertices = context.Float32Array.new_object(vertices.ravel().tolist())\n faces = context.Uint32Array.new_object(faces.ravel().tolist())\n geometry = context.THREE.BufferGeometry.new_object()\n geometry.addAttribute('position',\n context.THREE.BufferAttribute.new_object(vertices, 3))\n geometry.setIndex(context.THREE.BufferAttribute.new_object(faces, 1))\n geometry.computeVertexNormals()\n if vertex_colors is not None:\n vertex_colors = context.Float32Array.new_object(\n vertex_colors.ravel().tolist())\n geometry.addAttribute(\n 'color', context.THREE.BufferAttribute.new_object(vertex_colors, 3))\n\n return geometry","def mrtrix_mesh2vox(surface_path, template_path, temp_dir, output_prefix):\n # Adapt affine translation using metadata\n template = nib.load(template_path)\n _, _, meta = read_geometry(surface_path, read_metadata=True)\n\n template = nib.as_closest_canonical(template)\n affine = template.affine.copy()\n affine[:-1, -1] = template.affine[:-1, -1] - meta['cras']\n\n new_template = nib.Nifti1Image(template.dataobj, affine)\n new_template_path = temp_dir / 'template.mgz'\n nib.save(new_template, new_template_path)\n\n # Reconstruct volume from mesh\n subprocess.run(['mesh2voxel', surface_path, new_template_path, temp_dir / f'{output_prefix}_output.mgz'])\n\n # Save the reconstructed volume with the right affine\n output = nib.load(temp_dir / f'{output_prefix}_output.mgz')\n new_output = nib.Nifti1Image(output.dataobj, template.affine)\n # nib.save(new_output, output_path)\n\n return new_output","def itkMeshSourcePSF3_cast(obj: 'itkLightObject') -> \"itkMeshSourcePSF3 *\":\n return _itkMeshSourcePython.itkMeshSourcePSF3_cast(obj)","def apply_dof_transformation_to_transpose_hexahedron(\n entity_transformations, entity_dofs, data, cell_info\n):\n apply_dof_transformation_to_transpose(3, 12, 6, entity_transformations, entity_dofs,\n data, cell_info, List([\"quadrilateral\"] * 6))","def project_on_trans(self, F):\r\n\r\n x0 = self.x1\r\n y0 = self.y1\r\n self.z1 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)\r\n\r\n x0 = self.x2\r\n y0 = self.y2\r\n self.z2 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)\r\n\r\n x0 = self.x3\r\n y0 = self.y3\r\n self.z3 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)","def transform(self, matrix: \"Matrix44\"):\n self.vertices = list(matrix.transform_vertices(self.vertices))\n return self","def cast(obj: 'itkLightObject') -> \"itkMeshSourceMUC3 *\":\n return _itkMeshSourcePython.itkMeshSourceMUC3_cast(obj)","def GetModifiableTransform(self) -> \"itkTransformD33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_GetModifiableTransform(self)","def apply_dof_transformation_tetrahedron(\n entity_transformations, entity_dofs, data, cell_info\n):\n apply_dof_transformation(3, 6, 4, entity_transformations, entity_dofs,\n data, cell_info, List([\"triangle\"] * 4))","def itkMeshSourceMD3_cast(obj: 'itkLightObject') -> \"itkMeshSourceMD3 *\":\n return _itkMeshSourcePython.itkMeshSourceMD3_cast(obj)","def scale3d(p, a=1, b=1, c=1):\n translation_mat = np.matrix([\n [a,0,0,0],\n [0,b,0,0],\n [0,0,c,0],\n [0,0,0,1],\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def cast(*args):\n return _itkFixedCenterOfRotationAffineTransformPython.itkFixedCenterOfRotationAffineTransformD3_cast(*args)","def itkMeshSourcePSD3_cast(obj: 'itkLightObject') -> \"itkMeshSourcePSD3 *\":\n return _itkMeshSourcePython.itkMeshSourcePSD3_cast(obj)","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 translate3d(p, a=0, b=0, c=0):\n translation_mat = np.matrix([\n [1,0,0,0],\n [0,1,0,0],\n [0,0,1,0],\n [a,b,c,1]\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def reshape_tensor3d(self, x):\n if self.dim_ordering == 'th':\n tx = K.reshape(x, (-1, self.nb_filter, self.cols * self.rows))\n else:\n tx = K.reshape(x, (-1, self.cols * self.rows, self.nb_filter))\n tx = K.transpose(tx, (0,2,1))\n if self.cov_mode == 'channel' or self.cov_mode =='mean' or self.cov_mode =='pmean':\n return tx\n else:\n return K.transpose(tx, (0,2,1))","def itkMeshSourcePSSS3_cast(obj: 'itkLightObject') -> \"itkMeshSourcePSSS3 *\":\n return _itkMeshSourcePython.itkMeshSourcePSSS3_cast(obj)","def create_mesh(self):\n print(\"create_mesh\")\n faces = self.get_faces()\n print(\"num faces: {}\".format(len(faces)))\n\n # TODO: perform face filtering to remove long edges in Z direction\n # filtered_faces = self.get_filtered_faces(faces)\n # print(\"num filtered faces: {}\".format(len(filtered_faces)))\n\n vertices = self.xyz_points.T\n\n # handle texture mappings\n vertex_index_to_texture = []\n for j in range(0, self.height):\n for i in range(0, self.width):\n # vertex_index = (j * self.width) + ij\n w = i / self.width\n h = (self.height - j - 1) / self.height\n vertex_index_to_texture.append(\n (w, h)\n )\n\n # Create material.\n # TODO: make the string/filename randomly generated and unique\n file0 = open(os.path.join(self.args.path, \"triangle_mesh.obj.mtl\"), \"w\") # write mode\n file0.write(\"newmtl material_0\\n\")\n # Save image here.\n cv2.imwrite(os.path.join(self.args.path, \"triangle_mesh.png\"), self.bgr)\n file0.write(\"map_Kd triangle_mesh.png\\n\")\n file0.close()\n\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\n obj_path = os.path.join(self.args.path, \"triangle_mesh.obj\")\n file1 = open(obj_path, \"w\") # write mode\n file1.write(\"mtllib ./triangle_mesh.obj.mtl\\n\")\n for vertex in vertices:\n x, y, z = vertex\n file1.write(\"v {} {} {}\\n\".format(x, y, z))\n file1.write(\"usemtl material_0\\n\")\n for w, h in vertex_index_to_texture:\n file1.write(\"vt {} {}\\n\".format(w, h))\n for face in faces:\n a, b, c = face\n a += 1\n b += 1\n c += 1\n file1.write(\"f {}/{} {}/{} {}/{}\\n\".format(\n a, a, b, b, c, c\n )\n )\n file1.close()\n\n # Load the trimesh from OBJ file.\n trimesh_mesh = trimesh.load(obj_path)\n # trimesh_mesh.show()\n\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\n\n camera = pyrender.IntrinsicsCamera(\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\n )\n self.camera_pose = np.array([\n [1.0, 0.0, 0.0, 0.0],\n [0.0, 1.0, 0.0, 0.0],\n [0.0, 0.0, 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ])\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\n r = R.from_rotvec(np.array([0, np.pi, 0]))\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\n matrix = r.as_matrix()\n self.camera_pose[:3, :3] = matrix\n\n light = pyrender.PointLight(\n color=[1.0, 1.0, 1.0],\n intensity=0.0\n )\n\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\n self.scene.add_node(self.nm)\n self.scene.add_node(self.nl)\n self.scene.add_node(self.nc)\n\n # Set the pose and show the image.\n temppose = self.extrinsics @ self.camera_pose\n self.scene.set_pose(self.nl, pose=temppose)\n self.scene.set_pose(self.nc, pose=temppose)\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\n viewport_size=(self.width, self.height))","def apply_transform_on_3d_image(image: torch.Tensor, transforms: List[Callable]) -> torch.Tensor:\n for z in range(image.shape[0]):\n pil = TF.to_pil_image(image[z])\n for transform_fn in transforms:\n pil = transform_fn(pil)\n image[z] = TF.to_tensor(pil).squeeze()\n return image","def cast(obj: 'itkLightObject') -> \"itkMeshSourceMSS3 *\":\n return _itkMeshSourcePython.itkMeshSourceMSS3_cast(obj)","def GetOutput(self, *args) -> \"itkMeshF3 *\":\n return _itkMeshSourcePython.itkMeshSourceMF3_GetOutput(self, *args)","def new_mesh_set(self, all_meshes):\n if isinstance(all_meshes, Mesh):\n mesh_tp = MeshCollection()\n mesh_tp.append(all_meshes)\n all_meshes = mesh_tp\n\n if all_meshes.get_num_frames() is not 1:\n raise IndexError(\"Mesh should be from one frame only\")\n\n if not isinstance(all_meshes, MeshCollection):\n raise TypeError(\"Please send a list of mesh to update_mesh\")\n self.all_meshes = all_meshes\n\n # Remove previous actors from the scene\n for actor in self.mesh_actors:\n self.parent_window.ren.RemoveActor(actor)\n self.mesh_actors = list()\n\n # Create the geometry of a point (the coordinate) points = vtkPoints()\n for (i, mesh) in enumerate(self.all_meshes):\n points = vtkPoints()\n for j in range(mesh.get_num_vertex()):\n points.InsertNextPoint([0, 0, 0])\n\n # Create an array for each triangle\n cell = vtkCellArray()\n for j in range(mesh.get_num_triangles()): # For each triangle\n line = vtkPolyLine()\n line.GetPointIds().SetNumberOfIds(4)\n for k in range(len(mesh.triangles[j])): # For each index\n line.GetPointIds().SetId(k, mesh.triangles[j, k])\n line.GetPointIds().SetId(3, mesh.triangles[j, 0]) # Close the triangle\n cell.InsertNextCell(line)\n poly_line = vtkPolyData()\n poly_line.SetPoints(points)\n poly_line.SetLines(cell)\n\n # Create a mapper\n mapper = vtkPolyDataMapper()\n mapper.SetInputData(poly_line)\n\n # Create an actor\n self.mesh_actors.append(vtkActor())\n self.mesh_actors[i].SetMapper(mapper)\n\n self.parent_window.ren.AddActor(self.mesh_actors[i])\n self.parent_window.ren.ResetCamera()\n\n # Update marker position\n self.update_mesh(self.all_meshes)","def reshape_tensor3d(self, x):\n if self.dim_ordering == 'th':\n tx = K.reshape(x, (-1, self.nb_filter, self.cols * self.rows))\n else:\n tx = K.reshape(x, (-1, self.cols * self.rows, self.nb_filter))\n tx = K.transpose(tx, (0, 2, 1))\n if self.bilinear_mode == 'channel' or self.bilinear_mode == 'mean' or self.bilinear_mode == 'pmean':\n return tx\n else:\n return K.transpose(tx, (0, 2, 1))","def cast(obj: 'itkLightObject') -> \"itkMeshSourcePSF3 *\":\n return _itkMeshSourcePython.itkMeshSourcePSF3_cast(obj)","def cast(obj: 'itkLightObject') -> \"itkMeshSourceMD3 *\":\n return _itkMeshSourcePython.itkMeshSourceMD3_cast(obj)","def mesh(self):\n return self._mesh","def mesh(self):\n return self._mesh","def mesh(self):\n return self._mesh","def mesh(self):\n return self._mesh","def unwrap3D(matrix):\n\n dtype = matrix.dtype\n dims = matrix.shape\n\n if len(dims) > 3:\n raise ValueError(\"matrix has too many dimensions to unwrap\")\n elif len(dims) < 3:\n dims = (1, ) * (3 - len(dims)) + dims\n\n in_phase = numpy.reshape(matrix, dims).astype(numpy.float32)\n \n # actually this seems better pre-masked (confirm??)\n ret = _punwrap3D.Unwrap3D(in_phase).astype(dtype)\n return numpy.reshape(ret, matrix.shape)","def recalculate_transform(self):\n bias_mat = wireframe.translationMatrix(*self.bias)\n rot_mat = wireframe.rotateMatrix(*self.view_angle)\n scale_mat = wireframe.scaleMatrix(*self.scale)\n\n self.tf_wireframe.nodes = (self.wireframe.nodes - self._center_half) @ \\\n rot_mat @ scale_mat @ bias_mat","def cast(obj: 'itkLightObject') -> \"itkMeshSourcePSD3 *\":\n return _itkMeshSourcePython.itkMeshSourcePSD3_cast(obj)","def _Transform(obj, jac=None, offset=(0.,0.), flux_ratio=1.):\n ret = Transformation.__new__(Transformation)\n ret._gsparams = obj.gsparams\n ret._propagate_gsparams = True\n ret._jac = jac\n ret._dx, ret._dy = offset\n if isinstance(obj, Transformation):\n if obj._has_offset:\n if jac is None:\n dx1, dy1 = obj._dx, obj._dy\n else:\n dx1, dy1 = ret._fwd_normal(obj._dx, obj._dy)\n ret._dx += dx1\n ret._dy += dy1\n if jac is None:\n ret._jac = obj._jac\n else:\n ret._jac = ret._jac if obj._jac is None else ret._jac.dot(obj.jac)\n ret._flux_ratio = flux_ratio * obj._flux_ratio\n ret._original = obj._original\n else:\n ret._flux_ratio = flux_ratio\n ret._original = obj\n ret._has_offset = (ret._dx != 0. or ret._dy != 0.)\n return ret","def imshow_mesh_3d(img, vertices, faces, camera_center, focal_length, colors=(76, 76, 204)):\n H, W, C = img.shape\n if not has_pyrender:\n warnings.warn('pyrender package is not installed.')\n return img\n if not has_trimesh:\n warnings.warn('trimesh package is not installed.')\n return img\n try:\n renderer = pyrender.OffscreenRenderer(viewport_width=W, viewport_height=H)\n except (ImportError, RuntimeError):\n warnings.warn('pyrender package is not installed correctly.')\n return img\n if not isinstance(colors, list):\n colors = [colors for _ in range(len(vertices))]\n colors = [color_val(c) for c in colors]\n depth_map = np.ones([H, W]) * np.inf\n output_img = img\n for idx in range(len(vertices)):\n color = colors[idx]\n color = [(c / 255.0) for c in color]\n color.append(1.0)\n vert = vertices[idx]\n face = faces[idx]\n material = pyrender.MetallicRoughnessMaterial(metallicFactor=0.2, alphaMode='OPAQUE', baseColorFactor=color)\n mesh = trimesh.Trimesh(vert, face)\n rot = trimesh.transformations.rotation_matrix(np.radians(180), [1, 0, 0])\n mesh.apply_transform(rot)\n mesh = pyrender.Mesh.from_trimesh(mesh, material=material)\n scene = pyrender.Scene(ambient_light=(0.5, 0.5, 0.5))\n scene.add(mesh, 'mesh')\n camera_pose = np.eye(4)\n camera = pyrender.IntrinsicsCamera(fx=focal_length[0], fy=focal_length[1], cx=camera_center[0], cy=camera_center[1], zfar=100000.0)\n scene.add(camera, pose=camera_pose)\n light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=1)\n light_pose = np.eye(4)\n light_pose[:3, 3] = np.array([0, -1, 1])\n scene.add(light, pose=light_pose)\n light_pose[:3, 3] = np.array([0, 1, 1])\n scene.add(light, pose=light_pose)\n light_pose[:3, 3] = np.array([1, 1, 2])\n scene.add(light, pose=light_pose)\n color, rend_depth = renderer.render(scene, flags=pyrender.RenderFlags.RGBA)\n valid_mask = (rend_depth < depth_map) * (rend_depth > 0)\n depth_map[valid_mask] = rend_depth[valid_mask]\n valid_mask = valid_mask[:, :, None]\n output_img = valid_mask * color[:, :, :3] + (1 - valid_mask) * output_img\n return output_img"],"string":"[\n \"def transform(self, data):\\n self.cube = self.trf.transform(data)\",\n \"def GetTransform(self, *args) -> \\\"itkTransformD33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_GetTransform(self, *args)\",\n \"def GetTransform(self, *args) -> \\\"itkTransformF33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_GetTransform(self, *args)\",\n \"def transform(mesh, translation_scale=1000.0):\\n # rotate and translate randomly\\n matrix = transformations.random_rotation_matrix(\\n translate=translation_scale)\\n\\n # randomly re-order triangles\\n triangles = np.random.permutation(mesh.triangles).reshape((-1, 3))\\n # apply rigid transform\\n triangles = transformations.transform_points(triangles, matrix)\\n\\n # extract the class from the input object\\n mesh_type = util.type_named(mesh, 'Trimesh')\\n # generate a new mesh from the permutated data\\n permutated = mesh_type(\\n **triangles_module.to_kwargs(triangles.reshape((-1, 3, 3))))\\n\\n return permutated\",\n \"def transform_mesh_filter(*args, **kwargs):\\n import itk\\n instance = itk.TransformMeshFilter.New(*args, **kwargs)\\n return instance.__internal_call__()\",\n \"def CreateSurface2DMeshfrom3DMesh(self):\\n\\n self.__do_memebers_exist__()\\n\\n p = self.InferPolynomialDegree()\\n mm = Mesh()\\n if self.element_type == \\\"hex\\\":\\n mm.element_type = \\\"quad\\\"\\n elif self.element_type == \\\"tet\\\":\\n mm.element_type = \\\"tri\\\"\\n else:\\n raise ValueError(\\\"Cannot make a 2D mesh from the 3D mesh of type {}\\\".format(self.element_type))\\n\\n unique_faces, inv_faces = np.unique(self.faces,return_inverse=True)\\n mm.points = self.points[unique_faces,:]\\n mm.nnode = mm.points.shape[0]\\n aranger = np.arange(mm.nnode)\\n mm.elements = aranger[inv_faces].reshape(self.faces.shape)\\n mm.nelem = mm.elements.shape[0]\\n mm.GetBoundaryEdges()\\n\\n return mm\",\n \"def from_trimesh(mesh):\\n vformat = p3d.GeomVertexFormat.get_v3n3()\\n vertices = np.column_stack((mesh.vertices, mesh.vertex_normals))\\n # TODO: uvs\\n return Mesh._make(vformat, vertices, mesh.faces)\",\n \"def itkTranslationTransformD3_cast(*args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_cast(*args)\",\n \"def test_3d_tranpose(): \\n dic,data = ng.pipe.read_lowmem(\\\"common_data/3d_pipe/ft/test%03d.ft3\\\")\\n fdic,fdata = ng.pipe.read(\\\"common_data/3d_pipe/ft/test%03d.ft3\\\")\\n\\n assert_array_equal(data.transpose()[0,1,2],fdata.transpose()[0,1,2])\\n assert_array_equal(data.transpose((2,0,1))[0,1,2],\\n fdata.transpose((2,0,1))[0,1,2])\\n assert_array_equal(data.swapaxes(0,1)[0,1,2],fdata.swapaxes(0,1)[0,1,2])\\n assert_array_equal(data.swapaxes(2,0)[0,1,2],fdata.swapaxes(2,0)[0,1,2])\",\n \"def SetTransform(self, _arg: 'itkTransformF33') -> \\\"void\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_SetTransform(self, _arg)\",\n \"def SetTransform(self, _arg: 'itkTransformD33') -> \\\"void\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_SetTransform(self, _arg)\",\n \"def rescale_and_translate_mesh(data, meshname,\\n mesh_new_origin=np.array([0.,0.,0.]),\\n mesh_new_size=np.array([1.,1.,1.])):\\n # get mesh nodes as hdf5 node (directly in memory data)\\n # and rescale mesh\\n nodes = data.get_mesh_nodes(meshname, as_numpy=False)\\n # Translate mesh to origin 0,0,0\\n nodes[:,0] = nodes[:,0] - nodes[:,0].min()\\n nodes[:,1] = nodes[:,1] - nodes[:,1].min()\\n if nodes.shape[1] == 3:\\n nodes[:,2] = nodes[:,2] - nodes[:,2].min()\\n # Get mesh new X,Y and Z sizes\\n X_new_size = mesh_new_size[0]\\n Y_new_size = mesh_new_size[1]\\n if nodes.shape[1] == 3:\\n Z_new_size = mesh_new_size[2]\\n # Compute old mesh corrdinate range for each dimension\\n X_size = nodes[:,0].max() - nodes[:,0].min()\\n Y_size = nodes[:,1].max() - nodes[:,1].min()\\n if nodes.shape[1] == 3:\\n Z_size = nodes[:,2].max() - nodes[:,2].min()\\n # Dilate mesh along each dimension to new mesh size\\n nodes[:,0] = (nodes[:,0]/X_size)*X_new_size\\n nodes[:,1] = (nodes[:,1]/Y_size)*Y_new_size\\n if nodes.shape[1] == 3:\\n nodes[:,2] = (nodes[:,2]/Z_size)*Z_new_size\\n # Translate mesh\\n nodes[:,0] = nodes[:,0] + mesh_new_origin[0]\\n nodes[:,1] = nodes[:,1] + mesh_new_origin[1]\\n if nodes.shape[1] == 3:\\n nodes[:,2] = nodes[:,2] + mesh_new_origin[2]\\n # flush new nodes in memory\\n nodes.flush()\\n return\",\n \"def itkTransformMeshFilterMF3MF3TF33_cast(obj: 'itkLightObject') -> \\\"itkTransformMeshFilterMF3MF3TF33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_cast(obj)\",\n \"def BackTransform(self, *args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_BackTransform(self, *args)\",\n \"def ProjectToPlane(self):\\n\\n self.__do_essential_memebers_exist__()\\n if self.element_type != \\\"tri\\\":\\n raise ValueError(\\\"Project to plane is only applicable to triangles\\\")\\n\\n imesh = deepcopy(self)\\n coordinates = []\\n connectivities = []\\n for counter, elem in enumerate(imesh.elements):\\n\\n elementCoordinates = imesh.points[elem,:]\\n\\n A = elementCoordinates[0,:]\\n B = elementCoordinates[1,:]\\n C = elementCoordinates[2,:]\\n\\n X = (B - A); X /= np.linalg.norm(X)\\n Z = np.cross(X, C - A); Z /= np.linalg.norm(Z)\\n Y = np.cross(Z, X)\\n\\n # PROJECT THE TRIANGLE TO THIS BASES\\n a = [0., 0.]\\n b = [np.linalg.norm((B - A)), 0.]\\n c = [(C - A).dot(X), (C - A).dot(Y)]\\n\\n coordinates.append(a)\\n coordinates.append(b)\\n coordinates.append(c)\\n\\n elementConnectivity = [3 * counter, 3 * counter + 1, 3 * counter + 2]\\n connectivities.append(elementConnectivity)\\n\\n coordinates = np.array(coordinates)\\n connectivities = np.array(connectivities)\\n imesh.points = coordinates\\n imesh.elements = connectivities\\n imesh.nelem = imesh.elements.shape[0]\\n imesh.nnode = imesh.points.shape[0]\\n\\n return imesh\",\n \"def transform3D(a, f):\\n return f[0].dot(a) + f[1]\",\n \"def cast(*args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_cast(*args)\",\n \"def transform( self, matrix3 ):\\n self._coords = matrix3._matrix * self._coords\\n return self\",\n \"def itkTransformMeshFilterMF3MF3TD33_cast(obj: 'itkLightObject') -> \\\"itkTransformMeshFilterMF3MF3TD33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_cast(obj)\",\n \"def rotate_mesh(mesh):\\n rot_90_z = np.transpose(np.array([[0,1,0],[-1,0,0],[0,0,1]]))\\n rot_90_x = np.transpose(np.array([[1,0,0],[0,0,1],[0,-1,0]]))\\n rot_90_y = np.transpose(np.array([[0,0,1],[0,1,0],[-1,0,0]]))\\n angle = np.radians(-30)\\n angle2 = np.radians(10)\\n rot_angle_x = np.array([[1,0,0],[0,np.cos(angle2),-np.sin(angle2)],[0,np.sin(angle2),np.cos(angle2)]])\\n rot_angle_y = np.array([[np.cos(angle),0,-np.sin(angle)],[0,1,0],[np.sin(angle),0,np.cos(angle)]])\\n for j in range(len(mesh.vertices)):\\n mesh.vertices[j] = (mesh.vertices[j]@rot_90_y)@(np.transpose(rot_90_z))@rot_angle_y@rot_angle_x\\n #mesh.vertices[j]*=3\",\n \"def TransformVector(self, *args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_TransformVector(self, *args)\",\n \"def transform3D(x: float, y: float, z: float, R: np.array) -> np.array:\\n T = np.zeros((4, 4))\\n T[:3, :3] = R\\n T[:, 3] = [x, y, z, 1.0]\\n\\n return T\",\n \"def itkMeshSourceMF3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMF3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMF3_cast(obj)\",\n \"def Compose(self, *args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_Compose(self, *args)\",\n \"def transform(self, matrix: Matrix3D):\\n transform = self._local_transform\\n transform.transformBy(matrix)\\n self._reset_cache()\\n return self\",\n \"def get_3d_joints_from_mesh(self, vertices):\\n return torch.matmul(self.joints_regressor, vertices)\",\n \"def Translate(self, *args):\\n return _itkTranslationTransformPython.itkTranslationTransformD3_Translate(self, *args)\",\n \"def apply_dof_transformation_to_transpose_tetrahedron(\\n entity_transformations, entity_dofs, data, cell_info\\n):\\n apply_dof_transformation_to_transpose(3, 6, 4, entity_transformations, entity_dofs,\\n data, cell_info, List([\\\"triangle\\\"] * 4))\",\n \"def b_transform_cube(b_obj):\\n \\n b_scale_object()\\n b_scale_single_face(b_obj)\",\n \"def euler_3d_transform(initialize=False, fixed=None, moments=True) :\\n \\n transform = itk.Euler3DTransform[itk.D].New()\\n \\n if initialize :\\n fixed_itk = medipy.itk.medipy_image_to_itk_image(fixed, False)\\n #moving_itk = medipy.itk.medipy_image_to_itk_image(moving, False)\\n\\n fixedIndex = fixed_itk.GetLargestPossibleRegion().GetIndex()\\n fixedSize = fixed_itk.GetLargestPossibleRegion().GetSize()\\n\\n centerIndex = (int(fixedIndex[0] + fixedSize[0] / 2.0), \\\\\\n int(fixedIndex[1] + fixedSize[1] / 2.0), \\\\\\n int(fixedIndex[2] + fixedSize[2] / 2.0))\\n\\n rotationCenter = fixed_itk.TransformIndexToPhysicalPoint(centerIndex)\\n\\n transform.SetIdentity()\\n transform.SetCenter(rotationCenter)\\n \\n #initial_transform = itk.VersorRigid3DTransform[itk.D].New()\\n #initializer = itk.CenteredTransformInitializer[\\n # initial_transform, fixed_itk, moving_itk].New(\\n # Transform=initial_transform, FixedImage=fixed_itk, MovingImage=moving_itk) \\n #if moments :\\n # initializer.MomentsOn()\\n #else :\\n # initializer.GeometryOn()\\n #initializer.InitializeTransform()\\n #transform.SetCenter(initial_transform.GetCenter())\\n #transform.SetOffset(initial_transform.GetOffset())\\n \\n return transform\",\n \"def convert_coordinate_system_3d(x, y, z):\\n\\n return x, -z, y\",\n \"def from_mesh_data(mesh):\\n if len(mesh.normals) > 0 and len(mesh.uvs) > 0:\\n vformat = p3d.GeomVertexFormat.get_v3n3t2()\\n vertices = np.column_stack((mesh.vertices, mesh.normals, mesh.uvs))\\n elif len(mesh.normals) > 0:\\n vformat = p3d.GeomVertexFormat.get_v3n3()\\n vertices = np.column_stack((mesh.vertices, mesh.normals))\\n elif len(mesh.uvs) > 0:\\n vformat = p3d.GeomVertexFormat.get_v3t2()\\n vertices = np.column_stack((mesh.vertices, mesh.uvs))\\n else:\\n vformat = p3d.GeomVertexFormat.get_v3()\\n vertices = mesh.vertices\\n return Mesh._make(vformat, vertices, mesh.faces)\",\n \"def itkMeshSourceMUS3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMUS3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMUS3_cast(obj)\",\n \"def trimesh_to_vrml(mesh, output_file):\\n\\n with open(output_file, 'w') as f:\\n f.write('#VRML V2.0 utf8\\\\n')\\n f.write('Transform {\\\\n'\\n ' children [\\\\n'\\n ' Shape {\\\\n'\\n ' geometry IndexedFaceSet {\\\\n'\\n ' coord Coordinate {\\\\n'\\n ' point[\\\\n')\\n for v in mesh.vertices:\\n f.write(' {:0.6f} {:0.6f} {:0.6f},\\\\n'.format(*v.tolist()))\\n f.write(' ] # end of points\\\\n'\\n ' } # end of Coordinate\\\\n'\\n ' coordIndex [\\\\n')\\n\\n for face in mesh.faces:\\n f.write(' {:d}, {:d}, {:d}, -1,\\\\n'.format(*face.tolist()))\\n\\n f.write(' ] # end of coordIndex\\\\n'\\n ' } # end of geometry\\\\n'\\n ' appearance Appearance {\\\\n'\\n ' material Material {\\\\n'\\n ' diffuseColor 0.7 0.7 0.7\\\\n'\\n ' emissiveColor 0.05 0.05 0.05\\\\n'\\n ' specularColor 1.0 1.0 1.0\\\\n'\\n ' ambientIntensity 0.2\\\\n'\\n ' shininess 0.2\\\\n'\\n ' transparency 0.0\\\\n'\\n ' } #end of material\\\\n'\\n ' } #end of appearance\\\\n'\\n ' } # end of Shape\\\\n'\\n ' ] # end of children\\\\n'\\n '}\\\\n')\",\n \"def GetTransform(self, *args) -> \\\"itkTransformF22 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TF22_GetTransform(self, *args)\",\n \"def d3transf_df3(self,f):\\r\\n raise NotImplementedError\",\n \"def matrix_apply_to_3d_3x3(vol, matrix: np.matrix):\\n from scipy import mgrid\\n\\n cx = vol.shape[0]/2\\n cy = vol.shape[1]/2\\n cz = vol.shape[2]/2\\n\\n # Calculate the new coordinates of every point\\n grid = mgrid[-cx:vol.shape[0]-cx, -cy:vol.shape[1]-cy, -cz:vol.shape[2]-cz]\\n temp = grid.reshape((3, grid.size / 3))\\n # Add the fourth dimension (just 1s but needed for the computations)\\n # Use the matrix to calculate the new positions of every point\\n temp = np.dot(matrix, temp)\\n # Delete the fourth dimension\\n temp = np.array(temp)\\n grid = np.reshape(temp, (3, vol.shape[0], vol.shape[1], vol.shape[2]))\\n\\n grid[0] += cx\\n grid[1] += cy\\n grid[2] += cz\\n\\n from scipy.ndimage.interpolation import map_coordinates\\n d = map_coordinates(vol, grid, order=3)\\n\\n return d\",\n \"def Get3dConversion(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_Get3dConversion(self, *args)\",\n \"def itkMeshSourceMD3Q_cast(*args):\\n return _itkMeshSourcePython.itkMeshSourceMD3Q_cast(*args)\",\n \"def transform_cube(self,\\n cube: xr.Dataset,\\n gm: GridMapping,\\n cube_config: CubeConfig) -> TransformedCube:\",\n \"def scale_on_3d(x3d, scaler):\\n (n_segs, n_concat, n_freq) = x3d.shape\\n x2d = x3d.reshape((n_segs * n_concat, n_freq))\\n x2d = scaler.transform(x2d)\\n x3d = x2d.reshape((n_segs, n_concat, n_freq))\\n return x3d\",\n \"def Set3dConversion(self, *args):\\n return _ShapeUpgrade.ShapeUpgrade_ShapeConvertToBezier_Set3dConversion(self, *args)\",\n \"def GetTransform(self, *args) -> \\\"itkTransformD22 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetTransform(self, *args)\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMF3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMF3_cast(obj)\",\n \"def draw_stl_from_mesh(m):\\n plt.ion()\\n # Create a new plot\\n figure = plt.figure()\\n axes = mplot3d.Axes3D(figure)\\n\\n # Render the cube faces\\n #for m in meshes:\\n axes.add_collection3d(mplot3d.art3d.Poly3DCollection(m.vectors))\\n\\n # Auto scale to the mesh size\\n scale = m.points.flatten(-1)\\n axes.auto_scale_xyz(scale, scale, scale)\",\n \"def new_mesh_set(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = []\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if not isinstance(all_meshes, list):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n self.all_meshes = all_meshes\\n\\n # Remove previous actors from the scene\\n for actor in self.mesh_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.mesh_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtkPoints()\\n for i, mesh in enumerate(self.all_meshes):\\n if mesh.time.size != 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n points = vtkPoints()\\n for j in range(mesh.channel.size):\\n # points.InsertNextPoint([0, 0, 0])\\n points.InsertNextPoint(mesh.data[:3, j, 0].tolist())\\n\\n # Create an array for each triangle\\n draw_patch = not mesh.automatic_triangles and not self.force_wireframe\\n if draw_patch:\\n poly_type = vtkPolygon\\n n_ids = 3\\n color = self.patch_color[i]\\n else:\\n poly_type = vtkPolyLine\\n n_ids = 4\\n color = self.mesh_color\\n cells = vtkCellArray()\\n\\n # Create the polygons\\n for j in range(mesh.triangles.shape[1]):\\n poly = poly_type()\\n poly.GetPointIds().SetNumberOfIds(n_ids) # make a tri\\n for k in range(len(mesh.triangles[:, j])):\\n poly.GetPointIds().SetId(k, mesh.triangles[k, j])\\n if not draw_patch:\\n poly.GetPointIds().SetId(3, mesh.triangles[0, j]) # Close the triangle\\n cells.InsertNextCell(poly)\\n\\n poly_data = vtkPolyData()\\n poly_data.SetPoints(points)\\n if draw_patch:\\n poly_data.SetPolys(cells)\\n else:\\n poly_data.SetLines(cells)\\n\\n mapper = vtkPolyDataMapper()\\n mapper.SetInputData(poly_data)\\n\\n # Create an actor\\n self.mesh_actors.append(vtkActor())\\n self.mesh_actors[i].SetMapper(mapper)\\n self.mesh_actors[i].GetProperty().SetColor(color)\\n self.mesh_actors[i].GetProperty().SetOpacity(self.mesh_opacity)\\n\\n self.parent_window.ren.AddActor(self.mesh_actors[i])\\n\\n # Update marker position\\n self.update_mesh(self.all_meshes)\",\n \"def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])\",\n \"def apply_dof_transformation_to_transpose_prism(\\n entity_transformations, entity_dofs, data, cell_info\\n):\\n apply_dof_transformation_to_transpose(3, 9, 5, entity_transformations, entity_dofs,\\n data, cell_info, List([\\\"triangle\\\"] + [\\\"quadrilateral\\\"] * 4 + [\\\"triangle\\\"]))\",\n \"def _project(self):\\n ghosts_w = self.input_field.topology.ghosts()\\n self.input_field.data[0], self.input_field.data[1], \\\\\\n self.input_field.data[2] = \\\\\\n fftw2py.projection_om_3d(self.input_field.data[0],\\n self.input_field.data[1],\\n self.input_field.data[2], ghosts_w)\",\n \"def as_mesh(scene_or_mesh):\\n if isinstance(scene_or_mesh, trimesh.Scene):\\n if len(scene_or_mesh.geometry) == 0:\\n mesh = None # empty scene\\n else:\\n # we lose texture information here\\n mesh = trimesh.util.concatenate(\\n tuple(trimesh.Trimesh(vertices=g.vertices, faces=g.faces)\\n for g in scene_or_mesh.geometry.values()))\\n else:\\n assert(isinstance(scene_or_mesh, trimesh.Trimesh))\\n mesh = scene_or_mesh\\n return mesh\",\n \"def test_convert_MeshVTK():\\n mesh = MeshVTK(\\n path=join(TEST_DATA_DIR, \\\"StructElmer\\\"), name=\\\"case_t0001\\\", format=\\\"vtu\\\"\\n )\\n\\n meshmat = mesh.convert(meshtype=\\\"MeshMat\\\", scale=1)\\n\\n # meshsol = MeshSolution(mesh=[meshmat])\\n # meshsol.plot_mesh(is_show_fig=False)\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkTransformMeshFilterMF3MF3TF33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_cast(obj)\",\n \"def cast(*args):\\n return _itkMeshSourcePython.itkMeshSourceMD3Q_cast(*args)\",\n \"def Compute3d(self, *args):\\n return _BRepAlgo.BRepAlgo_NormalProjection_Compute3d(self, *args)\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMUS3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMUS3_cast(obj)\",\n \"def itkMeshSourceMUC3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMUC3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMUC3_cast(obj)\",\n \"def manifold_and_triangulate():\\n # Switch in edit mode \\n bpy.ops.object.mode_set(mode='EDIT')\\n\\n # Deselect everything\\n bpy.ops.mesh.select_all(action=\\\"DESELECT\\\")\\n\\n # Pass in vertices selection\\n bpy.ops.mesh.select_mode(type=\\\"VERT\\\")\\n\\n # Select non manifold vertices\\n bpy.ops.mesh.select_non_manifold()\\n\\n # Add an edge or face to selected vertices\\n bpy.ops.mesh.edge_face_add()\\n\\n # Pass in faces selection\\n bpy.ops.mesh.select_mode(type=\\\"FACE\\\")\\n\\n # Select all the faces\\n bpy.ops.mesh.select_all(action='SELECT')\\n \\n # Triangulate the faces\\n bpy.ops.mesh.quads_convert_to_tris(quad_method='FIXED_ALTERNATE', ngon_method='CLIP')\\n\\n # Switch in object mode \\n bpy.ops.object.mode_set(mode='OBJECT')\",\n \"def as_mesh(scene_or_mesh):\\n if isinstance(scene_or_mesh, trimesh.Scene):\\n if len(scene_or_mesh.geometry) == 0:\\n mesh = None # empty scene\\n else:\\n # we lose texture information here\\n mesh = trimesh.util.concatenate(\\n tuple(trimesh.Trimesh(vertices=g.vertices, faces=g.faces)\\n for g in scene_or_mesh.geometry.values()))\\n else:\\n mesh = scene_or_mesh\\n assert(isinstance(mesh, trimesh.Trimesh))\\n return mesh\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkTransformMeshFilterMF3MF3TD33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_cast(obj)\",\n \"def compose_transform3(phi1,theta1,psi1,sx1,sy1,sz1,scale1,phi2,theta2,psi2,sx2,sy2,sz2,scale2):\\n\\n\\tR1 = Transform({\\\"type\\\":\\\"spider\\\",\\\"phi\\\":float(phi1),\\\"theta\\\":float(theta1),\\\"psi\\\":float(psi1),\\\"tx\\\":float(sx1),\\\"ty\\\":float(sy1),\\\"tz\\\":float(sz1),\\\"mirror\\\":0,\\\"scale\\\":float(scale1)})\\n\\tR2 = Transform({\\\"type\\\":\\\"spider\\\",\\\"phi\\\":float(phi2),\\\"theta\\\":float(theta2),\\\"psi\\\":float(psi2),\\\"tx\\\":float(sx2),\\\"ty\\\":float(sy2),\\\"tz\\\":float(sz2),\\\"mirror\\\":0,\\\"scale\\\":float(scale2)})\\n\\tRcomp=R2*R1\\n\\td = Rcomp.get_params(\\\"spider\\\")\\n\\treturn d[\\\"phi\\\"],d[\\\"theta\\\"],d[\\\"psi\\\"],d[\\\"tx\\\"],d[\\\"ty\\\"],d[\\\"tz\\\"],d[\\\"scale\\\"]\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:])\",\n \"def rigid_transform_3d(v, mapping, alpha = 1):\\r\\n p_wgt = vec3(0, 0, 0)\\r\\n q_wgt = vec3(0, 0, 0)\\r\\n w = len(mapping)*[None]\\r\\n w_sum = 0\\r\\n for i in range(len(mapping)):\\r\\n mp = mapping[i]\\r\\n x = mp[0].x - v.x\\r\\n y = mp[0].y - v.y\\r\\n z = mp[0].z - v.z\\r\\n if (x == 0 and y == 0 and z == 0): return mp[1]\\r\\n w[i] = 1/((x*x + y*y + z*z) ** alpha)\\r\\n p_wgt += mp[0]*w[i]\\r\\n q_wgt += mp[1]*w[i]\\r\\n w_sum += w[i]\\r\\n p_wgt /= w_sum\\r\\n q_wgt /= w_sum\\r\\n A = mat3(0)\\r\\n for i in range(len(mapping)):\\r\\n mp = mapping[i]\\r\\n p_adj = mp[0] - p_wgt\\r\\n q_adj = mp[1] - q_wgt\\r\\n A += w[i]*p_adj.transpose_multiply(q_adj)\\r\\n A_arr = np.array(A.matrix).reshape(3, 3)\\r\\n U, S, V = np.linalg.svd(A_arr)\\r\\n M_arr = np.matmul(np.transpose(V), np.transpose(U))\\r\\n M = mat3(M_arr.ravel().tolist())\\r\\n v_out = M*(v - p_wgt) + q_wgt\\r\\n return v_out\",\n \"def mesh(self):\\n self._ensure_mesh()\\n return self._mesh\",\n \"def itkMeshSourceMSS3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMSS3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMSS3_cast(obj)\",\n \"def to_se3(self, state: Vector) -> RigidTransform:\\n return (state[:9],state[9:12])\",\n \"def GetModifiableTransform(self) -> \\\"itkTransformF33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TF33_GetModifiableTransform(self)\",\n \"def _triangular_mesh_to_three_geometry(vertices, faces, vertex_colors=None):\\n context = _js_builder.Js(mode=_js_builder.PERSISTENT)\\n vertices = context.Float32Array.new_object(vertices.ravel().tolist())\\n faces = context.Uint32Array.new_object(faces.ravel().tolist())\\n geometry = context.THREE.BufferGeometry.new_object()\\n geometry.addAttribute('position',\\n context.THREE.BufferAttribute.new_object(vertices, 3))\\n geometry.setIndex(context.THREE.BufferAttribute.new_object(faces, 1))\\n geometry.computeVertexNormals()\\n if vertex_colors is not None:\\n vertex_colors = context.Float32Array.new_object(\\n vertex_colors.ravel().tolist())\\n geometry.addAttribute(\\n 'color', context.THREE.BufferAttribute.new_object(vertex_colors, 3))\\n\\n return geometry\",\n \"def mrtrix_mesh2vox(surface_path, template_path, temp_dir, output_prefix):\\n # Adapt affine translation using metadata\\n template = nib.load(template_path)\\n _, _, meta = read_geometry(surface_path, read_metadata=True)\\n\\n template = nib.as_closest_canonical(template)\\n affine = template.affine.copy()\\n affine[:-1, -1] = template.affine[:-1, -1] - meta['cras']\\n\\n new_template = nib.Nifti1Image(template.dataobj, affine)\\n new_template_path = temp_dir / 'template.mgz'\\n nib.save(new_template, new_template_path)\\n\\n # Reconstruct volume from mesh\\n subprocess.run(['mesh2voxel', surface_path, new_template_path, temp_dir / f'{output_prefix}_output.mgz'])\\n\\n # Save the reconstructed volume with the right affine\\n output = nib.load(temp_dir / f'{output_prefix}_output.mgz')\\n new_output = nib.Nifti1Image(output.dataobj, template.affine)\\n # nib.save(new_output, output_path)\\n\\n return new_output\",\n \"def itkMeshSourcePSF3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourcePSF3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSF3_cast(obj)\",\n \"def apply_dof_transformation_to_transpose_hexahedron(\\n entity_transformations, entity_dofs, data, cell_info\\n):\\n apply_dof_transformation_to_transpose(3, 12, 6, entity_transformations, entity_dofs,\\n data, cell_info, List([\\\"quadrilateral\\\"] * 6))\",\n \"def project_on_trans(self, F):\\r\\n\\r\\n x0 = self.x1\\r\\n y0 = self.y1\\r\\n self.z1 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)\\r\\n\\r\\n x0 = self.x2\\r\\n y0 = self.y2\\r\\n self.z2 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)\\r\\n\\r\\n x0 = self.x3\\r\\n y0 = self.y3\\r\\n self.z3 = F - math.sqrt(F * F - x0 * x0 - y0 * y0)\",\n \"def transform(self, matrix: \\\"Matrix44\\\"):\\n self.vertices = list(matrix.transform_vertices(self.vertices))\\n return self\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMUC3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMUC3_cast(obj)\",\n \"def GetModifiableTransform(self) -> \\\"itkTransformD33 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_GetModifiableTransform(self)\",\n \"def apply_dof_transformation_tetrahedron(\\n entity_transformations, entity_dofs, data, cell_info\\n):\\n apply_dof_transformation(3, 6, 4, entity_transformations, entity_dofs,\\n data, cell_info, List([\\\"triangle\\\"] * 4))\",\n \"def itkMeshSourceMD3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMD3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMD3_cast(obj)\",\n \"def scale3d(p, a=1, b=1, c=1):\\n translation_mat = np.matrix([\\n [a,0,0,0],\\n [0,b,0,0],\\n [0,0,c,0],\\n [0,0,0,1],\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def cast(*args):\\n return _itkFixedCenterOfRotationAffineTransformPython.itkFixedCenterOfRotationAffineTransformD3_cast(*args)\",\n \"def itkMeshSourcePSD3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourcePSD3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSD3_cast(obj)\",\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 translate3d(p, a=0, b=0, c=0):\\n translation_mat = np.matrix([\\n [1,0,0,0],\\n [0,1,0,0],\\n [0,0,1,0],\\n [a,b,c,1]\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def reshape_tensor3d(self, x):\\n if self.dim_ordering == 'th':\\n tx = K.reshape(x, (-1, self.nb_filter, self.cols * self.rows))\\n else:\\n tx = K.reshape(x, (-1, self.cols * self.rows, self.nb_filter))\\n tx = K.transpose(tx, (0,2,1))\\n if self.cov_mode == 'channel' or self.cov_mode =='mean' or self.cov_mode =='pmean':\\n return tx\\n else:\\n return K.transpose(tx, (0,2,1))\",\n \"def itkMeshSourcePSSS3_cast(obj: 'itkLightObject') -> \\\"itkMeshSourcePSSS3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSSS3_cast(obj)\",\n \"def create_mesh(self):\\n print(\\\"create_mesh\\\")\\n faces = self.get_faces()\\n print(\\\"num faces: {}\\\".format(len(faces)))\\n\\n # TODO: perform face filtering to remove long edges in Z direction\\n # filtered_faces = self.get_filtered_faces(faces)\\n # print(\\\"num filtered faces: {}\\\".format(len(filtered_faces)))\\n\\n vertices = self.xyz_points.T\\n\\n # handle texture mappings\\n vertex_index_to_texture = []\\n for j in range(0, self.height):\\n for i in range(0, self.width):\\n # vertex_index = (j * self.width) + ij\\n w = i / self.width\\n h = (self.height - j - 1) / self.height\\n vertex_index_to_texture.append(\\n (w, h)\\n )\\n\\n # Create material.\\n # TODO: make the string/filename randomly generated and unique\\n file0 = open(os.path.join(self.args.path, \\\"triangle_mesh.obj.mtl\\\"), \\\"w\\\") # write mode\\n file0.write(\\\"newmtl material_0\\\\n\\\")\\n # Save image here.\\n cv2.imwrite(os.path.join(self.args.path, \\\"triangle_mesh.png\\\"), self.bgr)\\n file0.write(\\\"map_Kd triangle_mesh.png\\\\n\\\")\\n file0.close()\\n\\n # https://en.wikipedia.org/wiki/Wavefront_.obj_file\\n # https://github.com/mmatl/pyrender/blob/master/examples/models/fuze.obj\\n obj_path = os.path.join(self.args.path, \\\"triangle_mesh.obj\\\")\\n file1 = open(obj_path, \\\"w\\\") # write mode\\n file1.write(\\\"mtllib ./triangle_mesh.obj.mtl\\\\n\\\")\\n for vertex in vertices:\\n x, y, z = vertex\\n file1.write(\\\"v {} {} {}\\\\n\\\".format(x, y, z))\\n file1.write(\\\"usemtl material_0\\\\n\\\")\\n for w, h in vertex_index_to_texture:\\n file1.write(\\\"vt {} {}\\\\n\\\".format(w, h))\\n for face in faces:\\n a, b, c = face\\n a += 1\\n b += 1\\n c += 1\\n file1.write(\\\"f {}/{} {}/{} {}/{}\\\\n\\\".format(\\n a, a, b, b, c, c\\n )\\n )\\n file1.close()\\n\\n # Load the trimesh from OBJ file.\\n trimesh_mesh = trimesh.load(obj_path)\\n # trimesh_mesh.show()\\n\\n mesh = pyrender.Mesh.from_trimesh(trimesh_mesh, smooth=False)\\n self.scene = pyrender.Scene(ambient_light=[3.0, 3.0, 3.0])\\n\\n camera = pyrender.IntrinsicsCamera(\\n self.focal_length, self.focal_length, self.width / 2, self.height / 2\\n )\\n self.camera_pose = np.array([\\n [1.0, 0.0, 0.0, 0.0],\\n [0.0, 1.0, 0.0, 0.0],\\n [0.0, 0.0, 1.0, 0.0],\\n [0.0, 0.0, 0.0, 1.0],\\n ])\\n # https://pyrender.readthedocs.io/en/latest/examples/cameras.html#creating-cameras\\n # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.transform.Rotation.html\\n r = R.from_rotvec(np.array([0, np.pi, 0]))\\n r = R.from_rotvec(np.array([0.0, 0, np.pi])) * r\\n matrix = r.as_matrix()\\n self.camera_pose[:3, :3] = matrix\\n\\n light = pyrender.PointLight(\\n color=[1.0, 1.0, 1.0],\\n intensity=0.0\\n )\\n\\n self.nm = pyrender.Node(mesh=mesh, matrix=np.eye(4))\\n self.nl = pyrender.Node(light=light, matrix=np.eye(4))\\n self.nc = pyrender.Node(camera=camera, matrix=np.eye(4))\\n self.scene.add_node(self.nm)\\n self.scene.add_node(self.nl)\\n self.scene.add_node(self.nc)\\n\\n # Set the pose and show the image.\\n temppose = self.extrinsics @ self.camera_pose\\n self.scene.set_pose(self.nl, pose=temppose)\\n self.scene.set_pose(self.nc, pose=temppose)\\n pyrender.Viewer(self.scene, use_raymond_lighting=True,\\n viewport_size=(self.width, self.height))\",\n \"def apply_transform_on_3d_image(image: torch.Tensor, transforms: List[Callable]) -> torch.Tensor:\\n for z in range(image.shape[0]):\\n pil = TF.to_pil_image(image[z])\\n for transform_fn in transforms:\\n pil = transform_fn(pil)\\n image[z] = TF.to_tensor(pil).squeeze()\\n return image\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMSS3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMSS3_cast(obj)\",\n \"def GetOutput(self, *args) -> \\\"itkMeshF3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMF3_GetOutput(self, *args)\",\n \"def new_mesh_set(self, all_meshes):\\n if isinstance(all_meshes, Mesh):\\n mesh_tp = MeshCollection()\\n mesh_tp.append(all_meshes)\\n all_meshes = mesh_tp\\n\\n if all_meshes.get_num_frames() is not 1:\\n raise IndexError(\\\"Mesh should be from one frame only\\\")\\n\\n if not isinstance(all_meshes, MeshCollection):\\n raise TypeError(\\\"Please send a list of mesh to update_mesh\\\")\\n self.all_meshes = all_meshes\\n\\n # Remove previous actors from the scene\\n for actor in self.mesh_actors:\\n self.parent_window.ren.RemoveActor(actor)\\n self.mesh_actors = list()\\n\\n # Create the geometry of a point (the coordinate) points = vtkPoints()\\n for (i, mesh) in enumerate(self.all_meshes):\\n points = vtkPoints()\\n for j in range(mesh.get_num_vertex()):\\n points.InsertNextPoint([0, 0, 0])\\n\\n # Create an array for each triangle\\n cell = vtkCellArray()\\n for j in range(mesh.get_num_triangles()): # For each triangle\\n line = vtkPolyLine()\\n line.GetPointIds().SetNumberOfIds(4)\\n for k in range(len(mesh.triangles[j])): # For each index\\n line.GetPointIds().SetId(k, mesh.triangles[j, k])\\n line.GetPointIds().SetId(3, mesh.triangles[j, 0]) # Close the triangle\\n cell.InsertNextCell(line)\\n poly_line = vtkPolyData()\\n poly_line.SetPoints(points)\\n poly_line.SetLines(cell)\\n\\n # Create a mapper\\n mapper = vtkPolyDataMapper()\\n mapper.SetInputData(poly_line)\\n\\n # Create an actor\\n self.mesh_actors.append(vtkActor())\\n self.mesh_actors[i].SetMapper(mapper)\\n\\n self.parent_window.ren.AddActor(self.mesh_actors[i])\\n self.parent_window.ren.ResetCamera()\\n\\n # Update marker position\\n self.update_mesh(self.all_meshes)\",\n \"def reshape_tensor3d(self, x):\\n if self.dim_ordering == 'th':\\n tx = K.reshape(x, (-1, self.nb_filter, self.cols * self.rows))\\n else:\\n tx = K.reshape(x, (-1, self.cols * self.rows, self.nb_filter))\\n tx = K.transpose(tx, (0, 2, 1))\\n if self.bilinear_mode == 'channel' or self.bilinear_mode == 'mean' or self.bilinear_mode == 'pmean':\\n return tx\\n else:\\n return K.transpose(tx, (0, 2, 1))\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourcePSF3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSF3_cast(obj)\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourceMD3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourceMD3_cast(obj)\",\n \"def mesh(self):\\n return self._mesh\",\n \"def mesh(self):\\n return self._mesh\",\n \"def mesh(self):\\n return self._mesh\",\n \"def mesh(self):\\n return self._mesh\",\n \"def unwrap3D(matrix):\\n\\n dtype = matrix.dtype\\n dims = matrix.shape\\n\\n if len(dims) > 3:\\n raise ValueError(\\\"matrix has too many dimensions to unwrap\\\")\\n elif len(dims) < 3:\\n dims = (1, ) * (3 - len(dims)) + dims\\n\\n in_phase = numpy.reshape(matrix, dims).astype(numpy.float32)\\n \\n # actually this seems better pre-masked (confirm??)\\n ret = _punwrap3D.Unwrap3D(in_phase).astype(dtype)\\n return numpy.reshape(ret, matrix.shape)\",\n \"def recalculate_transform(self):\\n bias_mat = wireframe.translationMatrix(*self.bias)\\n rot_mat = wireframe.rotateMatrix(*self.view_angle)\\n scale_mat = wireframe.scaleMatrix(*self.scale)\\n\\n self.tf_wireframe.nodes = (self.wireframe.nodes - self._center_half) @ \\\\\\n rot_mat @ scale_mat @ bias_mat\",\n \"def cast(obj: 'itkLightObject') -> \\\"itkMeshSourcePSD3 *\\\":\\n return _itkMeshSourcePython.itkMeshSourcePSD3_cast(obj)\",\n \"def _Transform(obj, jac=None, offset=(0.,0.), flux_ratio=1.):\\n ret = Transformation.__new__(Transformation)\\n ret._gsparams = obj.gsparams\\n ret._propagate_gsparams = True\\n ret._jac = jac\\n ret._dx, ret._dy = offset\\n if isinstance(obj, Transformation):\\n if obj._has_offset:\\n if jac is None:\\n dx1, dy1 = obj._dx, obj._dy\\n else:\\n dx1, dy1 = ret._fwd_normal(obj._dx, obj._dy)\\n ret._dx += dx1\\n ret._dy += dy1\\n if jac is None:\\n ret._jac = obj._jac\\n else:\\n ret._jac = ret._jac if obj._jac is None else ret._jac.dot(obj.jac)\\n ret._flux_ratio = flux_ratio * obj._flux_ratio\\n ret._original = obj._original\\n else:\\n ret._flux_ratio = flux_ratio\\n ret._original = obj\\n ret._has_offset = (ret._dx != 0. or ret._dy != 0.)\\n return ret\",\n \"def imshow_mesh_3d(img, vertices, faces, camera_center, focal_length, colors=(76, 76, 204)):\\n H, W, C = img.shape\\n if not has_pyrender:\\n warnings.warn('pyrender package is not installed.')\\n return img\\n if not has_trimesh:\\n warnings.warn('trimesh package is not installed.')\\n return img\\n try:\\n renderer = pyrender.OffscreenRenderer(viewport_width=W, viewport_height=H)\\n except (ImportError, RuntimeError):\\n warnings.warn('pyrender package is not installed correctly.')\\n return img\\n if not isinstance(colors, list):\\n colors = [colors for _ in range(len(vertices))]\\n colors = [color_val(c) for c in colors]\\n depth_map = np.ones([H, W]) * np.inf\\n output_img = img\\n for idx in range(len(vertices)):\\n color = colors[idx]\\n color = [(c / 255.0) for c in color]\\n color.append(1.0)\\n vert = vertices[idx]\\n face = faces[idx]\\n material = pyrender.MetallicRoughnessMaterial(metallicFactor=0.2, alphaMode='OPAQUE', baseColorFactor=color)\\n mesh = trimesh.Trimesh(vert, face)\\n rot = trimesh.transformations.rotation_matrix(np.radians(180), [1, 0, 0])\\n mesh.apply_transform(rot)\\n mesh = pyrender.Mesh.from_trimesh(mesh, material=material)\\n scene = pyrender.Scene(ambient_light=(0.5, 0.5, 0.5))\\n scene.add(mesh, 'mesh')\\n camera_pose = np.eye(4)\\n camera = pyrender.IntrinsicsCamera(fx=focal_length[0], fy=focal_length[1], cx=camera_center[0], cy=camera_center[1], zfar=100000.0)\\n scene.add(camera, pose=camera_pose)\\n light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=1)\\n light_pose = np.eye(4)\\n light_pose[:3, 3] = np.array([0, -1, 1])\\n scene.add(light, pose=light_pose)\\n light_pose[:3, 3] = np.array([0, 1, 1])\\n scene.add(light, pose=light_pose)\\n light_pose[:3, 3] = np.array([1, 1, 2])\\n scene.add(light, pose=light_pose)\\n color, rend_depth = renderer.render(scene, flags=pyrender.RenderFlags.RGBA)\\n valid_mask = (rend_depth < depth_map) * (rend_depth > 0)\\n depth_map[valid_mask] = rend_depth[valid_mask]\\n valid_mask = valid_mask[:, :, None]\\n output_img = valid_mask * color[:, :, :3] + (1 - valid_mask) * output_img\\n return output_img\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6724482","0.6628377","0.6589676","0.6446487","0.6304848","0.6281156","0.6236697","0.62262785","0.61985016","0.6182246","0.6143696","0.6117967","0.6096631","0.60931605","0.6072821","0.603262","0.6030979","0.5999245","0.5990135","0.5965643","0.59506994","0.592851","0.59236634","0.5918925","0.5910485","0.591036","0.58600307","0.5853598","0.5839118","0.5817671","0.5816686","0.5814051","0.57928765","0.57928276","0.57877547","0.57826114","0.5782198","0.5780844","0.57709086","0.57692087","0.5760616","0.5757388","0.5738191","0.57268214","0.5715485","0.5710888","0.5703729","0.56949717","0.5693696","0.5692622","0.5692527","0.5689482","0.5686107","0.5672642","0.56599605","0.56555974","0.56518406","0.5646215","0.56391674","0.5637391","0.5627182","0.5619056","0.5599806","0.5598692","0.5582608","0.5579208","0.5574489","0.55734926","0.5564011","0.55611235","0.5538875","0.5535953","0.55353636","0.5522665","0.55186915","0.551437","0.54967207","0.5489053","0.54853785","0.548227","0.54786104","0.54714733","0.54671454","0.5466837","0.5462561","0.5457235","0.54493105","0.543895","0.5437609","0.5432722","0.54042417","0.5403762","0.5403762","0.5403762","0.5403762","0.5400763","0.5395442","0.539521","0.539128","0.53800845"],"string":"[\n \"0.6724482\",\n \"0.6628377\",\n \"0.6589676\",\n \"0.6446487\",\n \"0.6304848\",\n \"0.6281156\",\n \"0.6236697\",\n \"0.62262785\",\n \"0.61985016\",\n \"0.6182246\",\n \"0.6143696\",\n \"0.6117967\",\n \"0.6096631\",\n \"0.60931605\",\n \"0.6072821\",\n \"0.603262\",\n \"0.6030979\",\n \"0.5999245\",\n \"0.5990135\",\n \"0.5965643\",\n \"0.59506994\",\n \"0.592851\",\n \"0.59236634\",\n \"0.5918925\",\n \"0.5910485\",\n \"0.591036\",\n \"0.58600307\",\n \"0.5853598\",\n \"0.5839118\",\n \"0.5817671\",\n \"0.5816686\",\n \"0.5814051\",\n \"0.57928765\",\n \"0.57928276\",\n \"0.57877547\",\n \"0.57826114\",\n \"0.5782198\",\n \"0.5780844\",\n \"0.57709086\",\n \"0.57692087\",\n \"0.5760616\",\n \"0.5757388\",\n \"0.5738191\",\n \"0.57268214\",\n \"0.5715485\",\n \"0.5710888\",\n \"0.5703729\",\n \"0.56949717\",\n \"0.5693696\",\n \"0.5692622\",\n \"0.5692527\",\n \"0.5689482\",\n \"0.5686107\",\n \"0.5672642\",\n \"0.56599605\",\n \"0.56555974\",\n \"0.56518406\",\n \"0.5646215\",\n \"0.56391674\",\n \"0.5637391\",\n \"0.5627182\",\n \"0.5619056\",\n \"0.5599806\",\n \"0.5598692\",\n \"0.5582608\",\n \"0.5579208\",\n \"0.5574489\",\n \"0.55734926\",\n \"0.5564011\",\n \"0.55611235\",\n \"0.5538875\",\n \"0.5535953\",\n \"0.55353636\",\n \"0.5522665\",\n \"0.55186915\",\n \"0.551437\",\n \"0.54967207\",\n \"0.5489053\",\n \"0.54853785\",\n \"0.548227\",\n \"0.54786104\",\n \"0.54714733\",\n \"0.54671454\",\n \"0.5466837\",\n \"0.5462561\",\n \"0.5457235\",\n \"0.54493105\",\n \"0.543895\",\n \"0.5437609\",\n \"0.5432722\",\n \"0.54042417\",\n \"0.5403762\",\n \"0.5403762\",\n \"0.5403762\",\n \"0.5403762\",\n \"0.5400763\",\n \"0.5395442\",\n \"0.539521\",\n \"0.539128\",\n \"0.53800845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66893816"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84687,"cells":{"query":{"kind":"string","value":"Computes a lefthanded 4x4 lookat camera matrix."},"document":{"kind":"string","value":"def look_at_lh(eye: InputTensor, center: InputTensor,\n up: InputTensor) -> t.Tensor:\n eye = util.to_tensor(eye, dtype=t.float32)\n center = util.to_tensor(center, dtype=t.float32)\n up = util.to_tensor(up, dtype=t.float32)\n assert eye.shape == (3,)\n assert center.shape == (3,)\n assert up.shape == (3,)\n\n f = F.normalize(center - eye, dim=-1)\n s = F.normalize(t.cross(up, f), dim=-1)\n u = t.cross(f, s)\n\n return eye.new_tensor([\n [s[0], s[1], s[2], -t.dot(s, eye)],\n [u[0], u[1], u[2], -t.dot(u, eye)],\n [f[0], f[1], f[2], -t.dot(f, eye)],\n [0, 0, 0, 1],\n ], dtype=t.float32)"},"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 getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass","def camera_matrix(self) -> TransformationMatrixType:\n return numpy.matmul(\n self.rotation_matrix(*self.rotation),\n displacement_matrix(*-numpy.array(self.location)),\n )","def perspectiveFovLH(field_of_view, aspect, znear, zfar):\n h = 1 / tan(field_of_view / 2)\n w = h / aspect\n m = [\n [w, 0, 0, 0],\n [0, h, 0, 0],\n [0, 0, zfar / (zfar - znear), 1],\n [0, 0, (znear * zfar) / (znear - zfar), 0],\n ]\n return Matrix(m)","def camera_matrix(e, p, t):\n # Translates all points such that the camera is centered at the origin.\n T = np.array([[1, 0, 0, -e[0]],\n [0, 1, 0, -e[1]],\n [0, 0, 1, -e[2]],\n [0, 0, 0, 1]])\n\n # Set up orthonormal basis.\n w = e - p\n w = w / np.linalg.norm(w)\n u = np.cross(t, w)\n u = u / np.linalg.norm(u)\n v = np.cross(w, u)\n\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\n R = np.array([[u[0], u[1], u[2], 0],\n [v[0], v[1], v[2], 0],\n [w[0], w[1], w[2], 0],\n [ 0, 0, 0, 1]])\n return R.dot(T)","def fk4(joint_rotations):\n h0_4 = htm4(joint_rotations)\n x0_4 = h0_4[0, 3]\n y0_4 = h0_4[1, 3]\n z0_4 = h0_4[2, 3]\n d0_4 = [x0_4, y0_4, z0_4]\n return d0_4","def _mclachlan_atela_4th(vel_update, pos_update=update.PositionUpdate()):\n As = [\n 0.5153528374311229364,\n -0.085782019412973646,\n 0.4415830236164665242,\n 0.1288461583643841854,\n ]\n Bs = [\n 0.1344961992774310892,\n -0.2248198030794208058,\n 0.7563200005156682911,\n 0.3340036032863214255,\n ]\n updates = [vel_update, pos_update]*4\n coeff = []\n for a, b in zip(As, Bs):\n coeff.extend([a, b])\n return ExplicitIntegrator(coeff, updates)","def getMatrix(self) -> CMatrix4:\n ...","def ortho(self):\r\n\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n\r\n x = _vec3(m11, m21, m31)\r\n y = _vec3(m12, m22, m32)\r\n z = _vec3(m13, m23, m33)\r\n\r\n xl = x.length()\r\n xl*=xl\r\n y = y - ((x*y)/xl)*x\r\n z = z - ((x*z)/xl)*x\r\n\r\n yl = y.length()\r\n yl*=yl\r\n z = z - ((y*z)/yl)*y\r\n\r\n return mat4( x.x, y.x, z.x, m14,\r\n x.y, y.y, z.y, m24,\r\n x.z, y.z, z.z, m34,\r\n m41, m42, m43, m44)","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 _calculate_camera_array(self):\n look_list = []\n\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\n col_step_vec = self._get_look_right() * self.interspatial_distance\n\n # Start at the top left camera position\n for i in range(self.spatial_rows):\n row_movement = row_step_vec * (-i)\n row_look_from = self.look_from + row_movement\n row_look_to = self.look_to + row_movement\n\n for j in range(self.spatial_cols):\n col_movement = col_step_vec * j\n cam_look_from = row_look_from + col_movement\n cam_look_to = row_look_to + col_movement\n\n look_list.append((cam_look_from, cam_look_to))\n\n return look_list","def frustum(self, left, right, bottom, top, near, far):\r\n \r\n return mat4( (2.0*near)/(right-left), 0.0, float(right+left)/(right-left), 0.0,\r\n 0.0, (2.0*near)/(top-bottom), float(top+bottom)/(top-bottom), 0.0,\r\n 0.0, 0.0, -float(far+near)/(far-near), -(2.0*far*near)/(far-near),\r\n 0.0, 0.0, -1.0, 0.0)","def create_cam2world_matrix(forward_vector,\n origin,\n device=None):\n \"\"\"\"\"\"\n\n forward_vector = normalize_vecs(forward_vector)\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\n .expand_as(forward_vector)\n\n left_vector = normalize_vecs(\n torch.cross(up_vector,\n forward_vector,\n dim=-1))\n\n up_vector = normalize_vecs(\n torch.cross(forward_vector,\n left_vector,\n dim=-1))\n\n rotation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n rotation_matrix[:, :3, :3] = torch.stack(\n (-left_vector, up_vector, -forward_vector), axis=-1)\n\n translation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n translation_matrix[:, :3, 3] = origin\n\n cam2world = translation_matrix @ rotation_matrix\n\n return cam2world","def lookAtLH(eye, target, up):\n zaxis = (target - eye).normalize()\n xaxis = up.cross(zaxis).normalize()\n yaxis = zaxis.cross(xaxis).normalize()\n\n ex = -xaxis.dot(eye)\n ey = -yaxis.dot(eye)\n ez = -zaxis.dot(eye)\n\n m = [\n [xaxis.x, yaxis.x, zaxis.x, 0],\n [xaxis.y, yaxis.y, zaxis.y, 0],\n [xaxis.z, yaxis.z, zaxis.z, 0],\n [ex, ey, ez, 1]\n ]\n return Matrix(m)","def _embed44(matrix):\n result = np.eye(4)\n r, c = matrix.shape\n result[:r, :c] = matrix\n return result","def row_matrix_col_4d(a, b, A):\n\n\treturn (a[0]*A[0][0]*b[0] + a[1]*A[1][0]*b[0] + a[2]*A[2][0]*b[0] + a[3]*A[3][0]*b[0] +\n\t a[0]*A[0][1]*b[1] + a[1]*A[1][1]*b[1] + a[2]*A[2][1]*b[1] + a[3]*A[3][1]*b[1] +\n\t a[0]*A[0][2]*b[2] + a[1]*A[1][2]*b[2] + a[2]*A[2][2]*b[2] + a[3]*A[3][2]*b[2] +\n\t a[0]*A[0][3]*b[3] + a[1]*A[1][3]*b[3] + a[2]*A[2][3]*b[3] + a[3]*A[3][3]*b[3])","def _LookAtMatrix(at, eye, up=[0, 1, 0], reflect=False):\r\n # If reflect, then reflect in plane -20.0 (water depth)\r\n if reflect:\r\n depth = -20.0 # Shallower to avoid edge effects\r\n eye = [eye[0], -eye[1], eye[2]]\r\n at = [at[0], -at[1], at[2]]\r\n zaxis = vec_normal(vec_sub(at, eye))\r\n xaxis = vec_normal(vec_cross(up, zaxis))\r\n yaxis = vec_cross(zaxis, xaxis)\r\n xaxis.append(-vec_dot(xaxis, eye))\r\n yaxis.append(-vec_dot(yaxis, eye))\r\n zaxis.append(-vec_dot(zaxis, eye))\r\n z = [0, 0, 0, 1.0]\r\n return array([[xaxis[a], yaxis[a], zaxis[a], z[a]] for a in range(4)],\r\n dtype=float)","def set_camera(self, width, height):\n rightt = self.mat[:3, 0]\n upt = self.mat[:3, 1]\n pt = self.mat[:3, 2] * self.d\n t = self.mat[:3, 3]\n\n self.proj_mat = create_perspective_projection_matrix(np.radians(self.fov), 1. * width / height, self.near, self.far)\n gr3.setcameraprojectionparameters(self.fov, self.near, self.far)\n self.lookat_mat = create_look_at_matrix(pt + t, t, upt)\n gr3.cameralookat(pt[0] + t[0], pt[1] + t[1], pt[2] + t[2], t[0], t[1], t[2], upt[0], upt[1], upt[2])","def matrix(self):\n m = Matrix.identity(4, 4)\n\n m[:3, :3] = self.rotation.matrix.data\n m[:3, 3:4] = self.translation.matrix.data\n\n return m","def getDejaVuMatrix(self):\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\n mtx[3] = self.getTranslation()\n mtx[:3, 3] = mtx[3, :3]\n mtx[3, :3] = [0, 0, 0]\n return mtx","def get_projection_matrix(K, rvec, tvec):\n R = cv2.Rodrigues(np.float32(rvec))[0]\n Rt = np.zeros((3, 4))\n Rt[:, 0:3] = R\n Rt[:, 3] = tvec\n return K @ Rt","def map_to_matrix(x, y):\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\n\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\n\n return x_pos, y_pos","def modelview_matrix(self):\n camera = self.figure.scene.camera\n return camera.view_transform_matrix.to_array().astype(np.float32)","def htm4(joint_rotations):\n # H0_3\n h0_3 = htm0_3(joint_rotations)\n\n # H3_4\n r3_4 = rot_z(joint_rotations[3])\n x3_4 = a4 * np.cos(np.radians(joint_rotations[3]))\n y3_4 = a4 * np.sin(np.radians(joint_rotations[3]))\n z3_4 = 0\n d3_4 = transl(x3_4, y3_4, z3_4)\n h3_4 = htm(r3_4, d3_4)\n h0_4 = np.dot(h0_3, h3_4)\n return h0_4","def _ProjectionMatrix(near, far, fov, aspectRatio):\r\n # Matrices are considered to be M[row][col]\r\n # Use DirectX convention, so need to do rowvec*Matrix to transform\r\n size = 1 / tan(radians(fov)/2.0)\r\n M = [[0] * 4 for i in range(4)]\r\n M[0][0] = size/aspectRatio\r\n M[1][1] = size #negative value reflects scene on the Y axis\r\n M[2][2] = (far + near) / (far - near)\r\n M[2][3] = 1\r\n M[3][2] = -(2 * far * near)/(far - near)\r\n return array(M, dtype=float)","def camera_transform(image):\n img = np.zeros((image.shape[0], image.shape[1], 3))\n for y in range(image.shape[0]):\n for x in range(image.shape[1]):\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\n y, x]\n return img","def render_4d(polyhedron, **kwds):\n projection_direction = None\n try: \n projection_direction = kwds.pop('projection_directior')\n except KeyError:\n for ineq in polyhedron.inequality_generator():\n center = [v() for v in ineq.incident() if v.is_vertex()]\n center = sum(center) / len(center)\n if not center.is_zero(): \n projection_direction = center\n break\n projection_3d = Projection(polyhedron).schlegel(projection_direction)\n return render_3d(projection_3d, **kwds)","def computeMVP(self):\n projMat = self.converterYUR\n modelViewMat = self.transforMat.invertCompose(\n Globals.render.getTransform(self.cameraNode)).getMat()\n return UnalignedLMatrix4f(modelViewMat * projMat)","def L1U(A, d):\n n = shape(A)[0]\n L = eye(n)\n U = matrix(zeros((n,n))); U[0,0] = A[0,0]\n for k in range(1,n):\n km = array([0, k - d]).max()\n if km < k:\n L[k, km:k] = A[k, km:k]\n rforwardsolve(U[km:k, km:k].T, L[k, km:k].T, d) # L\n U[km:(k + 1), k] = A[km:(k + 1), k]\n rforwardsolve(L[km:(k + 1), km:(k + 1)], U[km:(k + 1), k], d) # U\n return L, U","def __init__(self, at=(0, 0, 0), eye=(0, 0, -0.1), lens=None,\r\n is_3d=True, scale=1.0):\r\n super(Camera, self).__init__()\r\n\r\n self.at = at\r\n self.start_eye = eye # for reset with different lens settings\r\n self.eye = [eye[0], eye[1], eye[2]]\r\n if lens == None:\r\n from pi3d.Display import Display\r\n lens = [Display.INSTANCE.near, Display.INSTANCE.far, Display.INSTANCE.fov,\r\n Display.INSTANCE.width / float(Display.INSTANCE.height)]\r\n self.lens = lens\r\n self.view = _LookAtMatrix(at, eye, [0, 1, 0])\r\n if is_3d:\r\n self.projection = _ProjectionMatrix(lens[0], lens[1], lens[2] / scale, lens[3])\r\n else:\r\n self.projection = _OrthographicMatrix(scale=scale)\r\n self.model_view = dot(self.view, self.projection)\r\n # Apply transform/rotation first, then shift into perspective space.\r\n self.mtrx = array(self.model_view, copy=True)\r\n # self.L_reflect = _LookAtMatrix(at,eye,[0,1,0],reflect=True)\r\n self.rtn = [0.0, 0.0, 0.0]\r\n\r\n self.was_moved = True","def matrix_math_api_examples():\n \n print(dingbat.vec2())\n print(dingbat.vec2(array.array('f', (20, 40))))\n print(dingbat.mat3())\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\n translate = dingbat.translation_matrix(-10, -20, -30)\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\n scale = dingbat.scale_matrix(100, 200, 300)\n print(translate)\n print(rotate)\n print(scale)\n print(dingbat.multiply_matrices(translate, rotate, scale))","def decompose_essential_matrix(E, x1, x2):\n\n # Fix left camera-matrix\n Rl = np.eye(3)\n tl = np.array([[0, 0, 0]]).T\n Pl = np.concatenate((Rl, tl), axis=1)\n\n # TODO: Compute possible rotations and translations\n \n # s must be [1, 1, 0]\n u, s, vh = np.linalg.svd(E)\n E = u @ np.diag([1, 1, 0]) @ vh\n u, s, vh = np.linalg.svd(E)\n\n w = np.array([[ 0, 1, 0], \n [-1, 0, 0], \n [ 0, 0, 1]]) \n \n z = np.array([[ 0, -1, 0], \n [ 1, 0, 0],\n [ 0, 0, 0]])\n \n R1 = u @ w.T @ vh\n s1 = -u @ z @ u.T\n R2 = u @ w @ vh\n s2 = u @ z @ u.T\n\n t1 = np.array([[s1[2, 1]], \n [s1[0, 2]],\n [s1[1, 0]]])\n \n t2 = np.array([[s2[2, 1]], \n [s2[0, 2]], \n [s2[1, 0]]]) \n\n # Four possibilities\n Pr = [np.concatenate((R1, t1), axis=1),\n np.concatenate((R1, t2), axis=1),\n np.concatenate((R2, t1), axis=1),\n np.concatenate((R2, t2), axis=1)]\n\n # Compute reconstructions for all possible right camera-matrices\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\n\n # Compute projections on image-planes and find when both cameras see point\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\n range(4)]\n test = np.array(test)\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\n\n # Choose correct matrix\n Pr = Pr[idx]\n\n return Pl, Pr","def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\n\n if phi is None:\n phi = const.PHI_IDX * 10.0\n\n #extrinsic x intrinsic\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\n\n intrinsic_matrix = np.eye(4, dtype=np.float32)\n extrinsic_matrix = np.eye(4, dtype=np.float32)\n\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\n\n #theta rotation\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\n rotation_azimuth[0, 0] = cos_theta\n rotation_azimuth[2, 2] = cos_theta\n rotation_azimuth[0, 2] = -sin_theta\n rotation_azimuth[2, 0] = sin_theta\n rotation_azimuth[1, 1] = 1.0\n\n #phi rotation\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\n rotation_elevation[0, 0] = cos_phi\n rotation_elevation[0, 1] = sin_phi\n rotation_elevation[1, 0] = -sin_phi\n rotation_elevation[1, 1] = cos_phi\n rotation_elevation[2, 2] = 1.0\n\n #rotate phi, then theta\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\n if invert_rot:\n rotation_matrix = np.linalg.inv(rotation_matrix)\n\n displacement = np.zeros((3, 1), dtype=np.float32)\n displacement[0, 0] = const.DIST_TO_CAM\n displacement = np.matmul(rotation_matrix, displacement)\n\n #assembling 4x4 from R + T\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\n extrinsic_matrix[0:3, 3:4] = -displacement\n\n if invert_focal:\n intrinsic_matrix[2, 2] = float(const.focal_length)\n intrinsic_matrix[1, 1] = float(const.focal_length)\n else:\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\n\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\n return camera_matrix","def perspective_transform():\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\n M = cv2.getPerspectiveTransform(src, dst)\n Minv = cv2.getPerspectiveTransform(dst, src)\n\n return M, Minv","def intrinsic_matrix_from_camera(w, h, fov):\n (cx, cy), f = calc_focal_values(w, h, fov)\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])","def ExtractCameraPose(E):\n u, s, v = np.linalg.svd(E, full_matrices=True)\n w = np.array([[0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]]).reshape(3, 3)\n c1 = u[:, 2].reshape(3, 1)\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c2 = -u[:, 2].reshape(3, 1)\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c3 = u[:, 2].reshape(3, 1)\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n c4 = -u[:, 2].reshape(3, 1)\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n if np.linalg.det(r1) < 0:\n c1 = -c1\n r1 = -r1\n if np.linalg.det(r2) < 0:\n c2 = -c2\n r2 = -r2\n if np.linalg.det(r3) < 0:\n c3 = -c3\n r3 = -r3\n if np.linalg.det(r4) < 0:\n c4 = -c4\n r4 = -r4\n cam_center = np.array([c1, c2, c3, c4])\n cam_rotation = np.array([r1, r2, r3, r4])\n return cam_center, cam_rotation","def calculate_pitch_yaw_roll(landmarks_2D, cam_w=256, cam_h=256,\n radians=False):\n\n assert landmarks_2D is not None, 'landmarks_2D is None'\n\n # Estimated camera matrix values.\n c_x = cam_w / 2\n c_y = cam_h / 2\n f_x = c_x / np.tan(60 / 2 * np.pi / 180)\n f_y = f_x\n camera_matrix = np.float32([[f_x, 0.0, c_x], [0.0, f_y, c_y],\n [0.0, 0.0, 1.0]])\n camera_distortion = np.float32([0.0, 0.0, 0.0, 0.0, 0.0])\n\n # dlib (68 landmark) trached points\n # TRACKED_POINTS = [17, 21, 22, 26, 36, 39, 42, 45, 31, 35, 48, 54, 57, 8]\n # wflw(98 landmark) trached points\n # TRACKED_POINTS = [33, 38, 50, 46, 60, 64, 68, 72, 55, 59, 76, 82, 85, 16]\n # X-Y-Z with X pointing forward and Y on the left and Z up.\n # The X-Y-Z coordinates used are like the standard coordinates of ROS (robotic operative system)\n # OpenCV uses the reference usually used in computer vision:\n # X points to the right, Y down, Z to the front\n landmarks_3D = np.float32([\n [6.825897, 6.760612, 4.402142], # LEFT_EYEBROW_LEFT, \n [1.330353, 7.122144, 6.903745], # LEFT_EYEBROW_RIGHT, \n [-1.330353, 7.122144, 6.903745], # RIGHT_EYEBROW_LEFT,\n [-6.825897, 6.760612, 4.402142], # RIGHT_EYEBROW_RIGHT,\n [5.311432, 5.485328, 3.987654], # LEFT_EYE_LEFT,\n [1.789930, 5.393625, 4.413414], # LEFT_EYE_RIGHT,\n [-1.789930, 5.393625, 4.413414], # RIGHT_EYE_LEFT,\n [-5.311432, 5.485328, 3.987654], # RIGHT_EYE_RIGHT,\n [-2.005628, 1.409845, 6.165652], # NOSE_LEFT,\n [-2.005628, 1.409845, 6.165652], # NOSE_RIGHT,\n [2.774015, -2.080775, 5.048531], # MOUTH_LEFT,\n [-2.774015, -2.080775, 5.048531], # MOUTH_RIGHT,\n [0.000000, -3.116408, 6.097667], # LOWER_LIP,\n [0.000000, -7.415691, 4.070434], # CHIN\n ])\n landmarks_2D = np.asarray(landmarks_2D, dtype=np.float32).reshape(-1, 2)\n\n # Applying the PnP solver to find the 3D pose of the head from the 2D position of the landmarks.\n # retval - bool\n # rvec - Output rotation vector that, together with tvec, brings points from the world coordinate system to the camera coordinate system.\n # tvec - Output translation vector. It is the position of the world origin (SELLION) in camera co-ords\n _, rvec, tvec = cv2.solvePnP(landmarks_3D, landmarks_2D,\n camera_matrix, camera_distortion)\n #Get as input the rotational vector, Return a rotational matrix\n\n # const double PI = 3.141592653;\n # double thetaz = atan2(r21, r11) / PI * 180;\n # double thetay = atan2(-1 * r31, sqrt(r32*r32 + r33*r33)) / PI * 180;\n # double thetax = atan2(r32, r33) / PI * 180;\n \n rmat, _ = cv2.Rodrigues(rvec)\n pose_mat = cv2.hconcat((rmat, tvec))\n _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)\n return map(lambda k: k[0], euler_angles) # euler_angles contain (pitch, yaw, roll)","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n\n origin = np.array([location.x, location.y, location.z])\n return matrix, origin","def pixel2cam(self, depth, intrinsics_inv):\n b, _, h, w = depth.size()\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\n ones = torch.ones(1,h,w).type_as(depth)\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\n return cam_coords * depth","def compute_projection_matrix(width,\n height,\n f_x,\n f_y,\n c_x,\n c_y,\n near,\n far):\n # pylint: disable=line-too-long\n matrix = vtk.vtkMatrix4x4()\n matrix.Zero()\n matrix.SetElement(0, 0, 2*f_x/width)\n matrix.SetElement(0, 1, -2*0/width) # Not doing skew, so this will be 0.\n matrix.SetElement(0, 2, (width - 2*c_x)/width)\n matrix.SetElement(1, 1, 2*f_y/height)\n matrix.SetElement(1, 2, (-height + 2*c_y)/height)\n matrix.SetElement(2, 2, (-far-near)/(far-near))\n matrix.SetElement(2, 3, -2*far*near/(far-near))\n matrix.SetElement(3, 2, -1)\n return matrix","def build_camera(R, t):\n camera = R.flatten()\n camera = np.append(camera, t.flatten())\n camera = np.append(camera, K[0][0])\n camera = np.append(camera, dist[0, 0:2].flatten())\n return camera","def proj_to_velo(calib_data):\n rect = calib_data[\"R0_rect\"].reshape(3, 3)\n #to transform a point from Lidar framce to camera frame\n #reshape the flat line with 12 elements to 3X4 matrix\n velo_to_cam = calib_data[\"Tr_velo_to_cam\"].reshape(3, 4)\n#print('velo2cam', velo_to_cam)\n inv_rect = np.linalg.inv(rect)\n #select all rows and only first three columns\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\n #select all rows and only first three columns\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\n return np.dot(inv_velo_to_cam, inv_rect)","def bloch_matrix(self):\n if self.gf_r is None:\n self.gf()\n\n return -self.gf_r.dot(self.lead[1])","def L1U(A, d):\n \n\n n, _ = A.shape\n L = np.eye(n, n, dtype=A.dtype)\n U = np.zeros((n, n), dtype=A.dtype)\n\n U[0, 0] = A[0, 0]\n for k in range(1, n):\n km = max(0, k-d)\n L[k, km : k] = np.transpose(rforwardsolve(np.transpose(U[km:k, km:k]),\\\n np.transpose(A[k, km:k]), d))\n U[km:k+1, k] = rforwardsolve(L[km:k+1, km:k+1], A[km:k+1, k], d)\n return L, U","def createCamera():\n\n turnCam = cmds.camera()\n lookThruAndFrame(turnCam[0])\n return turnCam","def set_modelview_from_camera(Rt):\n \n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n \n # rotate teapot 90 deg around x-axis so that z-axis is up\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\n \n # set rotation to best approximation\n R = Rt[:,:3]\n U,S,V = np.linalg.svd(R)\n R = np.dot(U,V)\n R[0,:] = -R[0,:] # change sign of x-axis\n \n # set translation\n t = Rt[:,3]\n \n # setup 4*4 model view matrix\n M = np.eye(4)\n M[:3,:3] = np.dot(R,Rx)\n M[:3,3] = t\n\n # transpose and flatten to get column order\n M = M.T\n \n m = M.flatten()\n \n # replace model view with the new matrix\n glLoadMatrixf(m)","def perspective_matrix(self) -> TransformationMatrixType:\n z_near, z_far = self._clipping[self.projection_mode.value]\n return perspective_matrix(\n math.radians(self.fov), self.aspect_ratio, z_near, z_far\n )","def get_projection_matrix(left, right, bottom, top):\r\n zNear = -25.0\r\n zFar = 25.0\r\n inv_z = 1.0 / (zFar - zNear)\r\n inv_y = 1.0 / (top - bottom)\r\n inv_x = 1.0 / (right - left)\r\n mat = [[(2.0 * inv_x), 0.0, 0.0, (-(right + left) * inv_x)],\r\n [0.0, (2.0 * inv_y), 0.0, (-(top + bottom) * inv_y)],\r\n [0.0, 0.0, (-2.0 * inv_z), (-(zFar + zNear) * inv_z)],\r\n [0.0, 0.0, 0.0, 1.0]]\r\n return mat","def _derive_transformation_matrices(self):\n\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\n if self._primaries is not None and self._whitepoint is not None:\n npm = normalised_primary_matrix(self._primaries,\n self._whitepoint)\n\n self._derived_RGB_to_XYZ_matrix = npm\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)","def test_RawRun_perspective_reference_old_style():\n ref = (0, 0)\n m = config.ideal_m\n grid = r.perspective_reference(ref, 'old', 'cam1')\n lower_right, upper_right, lower_left, upper_left = grid\n assert_equal((0, 0), lower_right)\n assert_equal((ref[0] - int(1.47 * m), ref[1] - int(0.25 * m)), upper_left)","def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\n # Camera intrinsics parameters\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\n\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\n\n skew = skew # \"skew param will be zero for most normal cameras\" Hartley, Zisserman\n\n m_x = resolution_x_px / resolution_x_mm\n m_y = resolution_y_px / resolution_y_mm\n\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\n\n x_0 = resolution_x_px / 2\n y_0 = resolution_y_px / 2\n\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])","def new_mirror(self,alongx,alongy):\n Knew = K.clone()\n if alongx:\n Knew[0,2] = size[0]-Knew[0,2]\n if alongy:\n Knew[1,2] = size[1]-Knew[1,2]\n return CameraInfo(self.size,Knew,self.dist)","def getPerspectiveProjectionMatrix(l, r, b, t, n, f):\n e11 = 2 * n / (r - l)\n e13 = (r + l) / (r - l)\n e22 = (2 * n) / (t - b)\n e23 = (t + b) / (t - b)\n e33 = -1 * (f + n) / (f - n)\n e34 = (-2 * f * n) / (f - n)\n\n return MatrixExtended([\n [e11, 0, e13, 0],\n [0, e22, e23, 0],\n [0, 0, e33, e34],\n [0, 0, -1, 0]])","def RudermanLABFwd(I):\n\n # get input image dimensions\n m = I.shape[0]\n n = I.shape[1]\n\n # define conversion matrices\n RGB2LMS = np.array([[0.3811, 0.5783, 0.0402],\n [0.1967, 0.7244, 0.0782],\n [0.0241, 0.1288, 0.8444]])\n LMS2LAB = np.array([[1 / (3**0.5), 0, 0],\n [0, 1 / (6**0.5), 0],\n [0, 0, 1 / (2**0.5)]]).dot(np.array([[1, 1, 1],\n [1, 1, -2],\n [1, -1, 0]]))\n\n # calculate LMS values from RGB\n I = np.reshape(I, (m * n, 3))\n LMS = np.dot(RGB2LMS, np.transpose(I))\n LMS[LMS == 0] = np.spacing(1)\n logLMS = np.log(LMS)\n\n # calculate LAB values from LMS\n I_LAB = LMS2LAB.dot(logLMS)\n\n # reshape to 3-channel image\n I_LAB = np.reshape(I_LAB.transpose(), (m, n, 3))\n\n return I_LAB","def camera_transformation_from_pose(azimutal, elevation):\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\n azimutal *= -1.\n elevation *= -1.\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\n [0, 1, 0],\n [-np.sin(elevation), 0, np.cos(elevation)]])\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\n [np.sin(azimutal), np.cos(azimutal), 0],\n [0, 0, 1]])\n r = r_z.dot(r_y)\n # world_to_camera matrix, camera_to_world matrix\n return r, np.linalg.inv(r)","def __ComputeDesignMatrix(self, groundPoints):\n # initialization for readability\n omega = self.exteriorOrientationParameters[3]\n phi = self.exteriorOrientationParameters[4]\n kappa = self.exteriorOrientationParameters[5]\n\n # Coordinates subtraction\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\n dXYZ = np.vstack([dX, dY, dZ])\n\n rotationMatrixT = self.rotationMatrix.T\n rotatedG = rotationMatrixT.dot(dXYZ)\n rT1g = rotatedG[0, :]\n rT2g = rotatedG[1, :]\n rT3g = rotatedG[2, :]\n\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\n\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\n\n dgdX0 = np.array([-1, 0, 0], 'f')\n dgdY0 = np.array([0, -1, 0], 'f')\n dgdZ0 = np.array([0, 0, -1], 'f')\n\n # Derivatives with respect to X0\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\n\n # Derivatives with respect to Y0\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\n\n # Derivatives with respect to Z0\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\n\n dRTdOmega = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'omega').T\n dRTdPhi = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'phi').T\n dRTdKappa = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'kappa').T\n\n gRT3g = dXYZ * rT3g\n\n # Derivatives with respect to Omega\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Phi\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Kappa\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n # all derivatives of x and y\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\n\n a = np.zeros((2 * dd[0].shape[0], 6))\n a[0::2] = dd[0]\n a[1::2] = dd[1]\n\n return a","def four_point_transform(image, pts):\n\n\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\n\n\tdst = np.array([\n\t\t[0, 0],\n\t\t[image.shape[1] - 1, 0],\n\t\t[image.shape[1] - 1, image.shape[0] - 1],\n\t\t[0, image.shape[0] - 1]], dtype=\"float32\")\n\n\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\n\n\treturn warped","def lap_mat(self):","def transformation_matrix(self) -> TransformationMatrixType:\n # camera translation\n if self._transformation_matrix is None:\n self._transformation_matrix = numpy.matmul(\n self.projection_matrix,\n self.camera_matrix,\n )\n\n return self._transformation_matrix","def create_ortho_matrices(self, offset, scale,\r\n window_dimensions, img_dimensions):\r\n window_width, window_height = window_dimensions\r\n object_x = int(window_width/2 - img_dimensions[0]*scale/2) + offset[0]\r\n object_y = int(window_height/2 - img_dimensions[1]*scale/2) + offset[1]\r\n model_matrix = get_4x4_transform(int(img_dimensions[0] * scale),\r\n int(img_dimensions[1] * scale),\r\n object_x,\r\n object_y, 1.0)\r\n proj_matrix = get_projection_matrix(0, window_width, 0, window_height)\r\n view_matrix = get_view_matrix(1.0, 1.0)\r\n return model_matrix, proj_matrix, view_matrix","def testMatchSwarpLanczos4Image(self):\n self.compareToSwarp(\"lanczos4\", useWarpExposure=False)","def set_matrix(self):\n theta1 = -90\n theta2 = 105\n theta3 = 180\n\n if self.number > 8:\n theta2 = 75\n\n glMatrixMode(GL_MODELVIEW)\n glPushMatrix()\n glLoadIdentity()\n glPushMatrix()\n glRotatef(theta2, 0.0, 1.0, 0.0)\n glRotatef(theta1, 1.0, 0.0, 0.0)\n glRotatef(theta3, 0.0, 0.0, 1.0)\n matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\n glPopMatrix()\n glPopMatrix()\n return matrix","def build_perspective_camera(field_of_view=60.0,\n aspect_ratio=1.0,\n near_plane=0.01,\n far_plane=1000.0,\n position=(0.0, 0.0, 5.0),\n enable_zoom=False):\n context = build_context()\n camera = context.THREE.PerspectiveCamera.new_object(field_of_view,\n aspect_ratio, near_plane,\n far_plane)\n camera.position.set(*position)\n controls = context.THREE.OrbitControls.new_object(camera)\n controls.enableZoom = enable_zoom\n return camera","def projection_matrix(self):\n scene = self.figure.scene\n scene_size = tuple(scene.get_size())\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\n p = scene.camera.get_perspective_transform_matrix(\n aspect_ratio, -1, 1).to_array().astype(np.float32)\n return p","def orthographic_matrix(self) -> TransformationMatrixType:\n near, far = self._clipping[self.projection_mode.value]\n return orthographic_matrix(self.fov, self.aspect_ratio, near, far)","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def read_camera(self):\n _, frame = self.camera.read()\n return self.mirror(frame)","def perspectiveNormalizationXform(self):\n return np.array([[1.0/np.tan(self.view_angle_h), 0, 0, 0],\n [0, 1.0/np.tan(self.view_angle_v), 0, 0],\n [0, 0, (self.far + self.near)/(self.far - self.near),\n 2*self.far*self.near/(self.far - self.near)],\n [0, 0, -1, 0]])","def _mat3(self):\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\n return np.identity(3)\n else:\n return self.QSW2TNW","def camera(*args, aspectRatio: Union[float, bool]=0.0, cameraScale: Union[float, bool]=0.0,\n centerOfInterest: Union[float, bool]=0.0, clippingPlanes: bool=True, depthOfField:\n bool=True, displayFieldChart: bool=True, displayFilmGate: bool=True,\n displayFilmOrigin: bool=True, displayFilmPivot: bool=True, displayGateMask:\n bool=True, displayResolution: bool=True, displaySafeAction: bool=True,\n displaySafeTitle: bool=True, fStop: Union[float, bool]=0.0, farClipPlane:\n Union[float, bool]=0.0, farFocusDistance: Union[float, bool]=0.0, filmFit:\n Union[AnyStr, bool]=\"\", filmFitOffset: Union[float, bool]=0.0, filmRollOrder:\n Union[AnyStr, bool]=\"\", filmRollValue: Union[float, bool]=0.0, filmTranslateH:\n Union[float, bool]=0.0, filmTranslateV: Union[float, bool]=0.0, focalLength:\n Union[float, bool]=0.0, focusDistance: Union[float, bool]=0.0, homeCommand:\n Union[AnyStr, bool]=\"\", horizontalFieldOfView: Union[float, bool]=0.0,\n horizontalFilmAperture: Union[float, bool]=0.0, horizontalFilmOffset: Union[float,\n bool]=0.0, horizontalPan: Union[float, bool]=0.0, horizontalRollPivot: Union[float,\n bool]=0.0, horizontalShake: Union[float, bool]=0.0, journalCommand: bool=True,\n lensSqueezeRatio: Union[float, bool]=0.0, lockTransform: bool=True, motionBlur:\n bool=True, name: Union[AnyStr, bool]=\"\", nearClipPlane: Union[float, bool]=0.0,\n nearFocusDistance: Union[float, bool]=0.0, orthographic: bool=True,\n orthographicWidth: Union[float, bool]=0.0, overscan: Union[float, bool]=0.0,\n panZoomEnabled: bool=True, position: Union[List[float, float, float], bool]=None,\n postScale: Union[float, bool]=0.0, preScale: Union[float, bool]=0.0, renderPanZoom:\n bool=True, rotation: Union[List[float, float, float], bool]=None, shakeEnabled:\n bool=True, shakeOverscan: Union[float, bool]=0.0, shakeOverscanEnabled: bool=True,\n shutterAngle: Union[float, bool]=0.0, startupCamera: bool=True,\n stereoHorizontalImageTranslate: Union[float, bool]=0.0,\n stereoHorizontalImageTranslateEnabled: bool=True, verticalFieldOfView: Union[float,\n bool]=0.0, verticalFilmAperture: Union[float, bool]=0.0, verticalFilmOffset:\n Union[float, bool]=0.0, verticalLock: bool=True, verticalPan: Union[float, bool]=0.0,\n verticalRollPivot: Union[float, bool]=0.0, verticalShake: Union[float, bool]=0.0,\n worldCenterOfInterest: Union[List[float, float, float], bool]=None, worldUp:\n Union[List[float, float, float], bool]=None, zoom: Union[float, bool]=0.0, q=True,\n query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\n pass","def _OrthographicMatrix(scale=1.0):\r\n from pi3d.Display import Display\r\n M = [[0] * 4 for i in range(4)]\r\n M[0][0] = 2.0 * scale / Display.INSTANCE.width\r\n M[1][1] = 2.0 * scale / Display.INSTANCE.height\r\n #M[2][2] = 2.0 / Display.INSTANCE.width\r\n M[2][2] = 2.0 / 10000.0\r\n M[3][2] = -1\r\n M[3][3] = 1\r\n return array(M, dtype=float)","def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])","def project(points, camera_params):\n # print(camera_params.shape)\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = 2360*np.ones(camera_params.shape[0])\n # np.ones()\n # n = np.sum(points_proj**2, axis=1)\n r = 1\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","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 camera_frame_directions(self) -> _BFRAME_TYPE:\n pass","def lvlh_matrix(pos, vel):\n\n # local vertical, local horizontal frame\n v_mag = np.sqrt(np.dot(vel, vel))\n p_mag = np.sqrt(np.dot(pos, pos))\n\n cross = np.cross(pos, vel)\n\n m_lvlh = np.array([\n vel/v_mag,\n cross/(-p_mag*v_mag),\n pos/(-p_mag)\n ])\n\n return m_lvlh","def setBillboardMatrix(self):\n \n wolrd_matrix_plug = OpenMaya.MPlug(self.thisObj, self.worldMatrix).elementByLogicalIndex(0)\n world_matrix = OpenMaya.MFnMatrixData(wolrd_matrix_plug.asMObject()).matrix()\n float_matrix = self.matrixToFloatMatrix(world_matrix)\n wolrd_rot_matrix = self.removeMatrixTranslate(float_matrix.inverse())\n\n camera_DagPath = OpenMaya.MDagPath()\n self.view.getCamera(camera_DagPath)\n camera_matrix = self.matrixToFloatMatrix(camera_DagPath.inclusiveMatrix())\n camera_rot_matrix = self.removeMatrixTranslate(camera_matrix)\n \n mult_matrix = camera_rot_matrix * wolrd_rot_matrix\n mult_float_matrix = self.matrixToFloatMatrix(mult_matrix)\n \n # set matrix\n float16_ptr = self.floatArrayToPrt(mult_float_matrix)\n glFT.glMultMatrixf(float16_ptr)\n \n # set scale\n sX, sY, sZ = self.getScale()\n glFT.glScalef(sX, sY, sZ)","def cameraToWorld(self, p):\n result = self.camPos\n result += p[2] * self.camZ # result is now in the middle of the view-plane\n result += p[0] * self.camX # result is now in the middle-left of the view-plane\n result += p[1] * self.camY # result is now the world-space equivalent of p\n return result","def cal_L(self):\n # calculate the l matrix\n self.point_matrixs = self.point_matrix.reshape(\n self.point_matrix.shape[0], 1, self.point_matrix.shape[1])\n self.point_matrixs = np.tile(self.point_matrixs,\n (self.attach_points.shape[0], 1))\n self.attach_points_matrix = np.matlib.repmat(\n self.attach_points[:, 0:3], self.point_matrix.shape[0], 1)\n self.attach_points_matrix = self.attach_points_matrix.reshape(\n self.point_matrix.shape[0], self.attach_points.shape[0], 3)\n self.L = np.subtract(self.attach_points_matrix,\n self.point_matrixs)\n # self.L[:,self.attach_points[:,3]==1,:] = \\\n # - self.L[:,self.attach_points[:,3]==1,:]\n # print(self.L)","def setCameraMatrix(self, val): # real signature unknown; restored from __doc__\n pass","def _get_rotation_matrix(transform):\n # caution: UE4 is using left-hand ortation order\n roll = np.deg2rad(-transform.rotation.roll)\n pitch = np.deg2rad(-transform.rotation.pitch)\n yaw = np.deg2rad(transform.rotation.yaw)\n sr, cr = np.sin(roll), np.cos(roll)\n sp, cp = np.sin(pitch), np.cos(pitch)\n sy, cy = np.sin(yaw), np.cos(yaw)\n rotation_matrix = np.array([[cy * cp, -sy * sr + cy * sp * sr, cy * sp * cr + sy * sr],\n [sy * cp, cy * sp * sr + cy * sr, -cy * sr + sy * sp * cr],\n [-sp, cp * sr, cp * cr]])\n return rotation_matrix","def get_matrix(self, transform):\r\n\r\n rotation = transform.rotation\r\n location = transform.location\r\n c_y = np.cos(np.radians(rotation.yaw))\r\n s_y = np.sin(np.radians(rotation.yaw))\r\n c_r = np.cos(np.radians(rotation.roll))\r\n s_r = np.sin(np.radians(rotation.roll))\r\n c_p = np.cos(np.radians(rotation.pitch))\r\n s_p = np.sin(np.radians(rotation.pitch))\r\n matrix = np.matrix(np.identity(4))\r\n matrix[0, 3] = location.x\r\n matrix[1, 3] = location.y\r\n matrix[2, 3] = location.z\r\n matrix[0, 0] = c_p * c_y\r\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\r\n matrix[1, 0] = s_y * c_p\r\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\r\n matrix[2, 0] = s_p\r\n matrix[2, 1] = -c_p * s_r\r\n matrix[2, 2] = c_p * c_r\r\n return matrix","def getMat3(self):\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n return _mat3(m11,m12,m13,\r\n m21,m22,m23,\r\n m31,m32,m33)","def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\n img = frame.copy()\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\n [0, 0, -grid_size]]).reshape(-1, 3)*2\n\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\n\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\n R, _ = cv2.Rodrigues(rvecs)\n # project 3D points onto image plane\n imgpts, _ = cv2.projectPoints(axis,\n rvecs, tvecs,\n K, d)\n\n canvas = computer_vision.draw_axis(img, corners, imgpts)\n return R, tvecs, canvas","def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\n if raw_lightfield.ndim == 6:\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for k, depth in enumerate(raw_lightfield):\n for i, row in enumerate(depth):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[k, i, j] = resized_image_data\n elif raw_lightfield.ndim == 5:\n n_cols, n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n\n for i, row in enumerate(raw_lightfield):\n for j, image_data in enumerate(row):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[i, j] = resized_image_data\n \n elif raw_lightfield.ndim == 4:\n n_rows, *_ = raw_lightfield.shape\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\n\n for j, image_data in enumerate(raw_lightfield):\n resized_image_data = cv2.resize(image_data, desired_size)\n output_lightfield[j] = resized_image_data\n \n return output_lightfield","def camera_2_world(self, o, d):\r\n wo = self.camera2world_point @ ti.Vector([o.x, o.y, o.z, 1.0])\r\n wd = self.camera2world_vec @ d\r\n return ti.Vector([wo.x,wo.y,wo.z]), wd","def generate_depth_map(calib_dir, velo_filename, cam=2, vel_depth=False):\n # load calibration files\n cam2cam = read_calib_file(os.path.join(calib_dir, 'calib_cam_to_cam.txt'))\n velo2cam = read_calib_file(os.path.join(calib_dir, 'calib_velo_to_cam.txt'))\n velo2cam = np.hstack((velo2cam['R'].reshape(3, 3), velo2cam['T'][..., np.newaxis]))\n velo2cam = np.vstack((velo2cam, np.array([0, 0, 0, 1.0])))\n\n # get image shape\n im_shape = cam2cam[\"S_rect_02\"][::-1].astype(np.int32)\n\n # compute projection matrix velodyne->image plane\n R_cam2rect = np.eye(4)\n R_cam2rect[:3, :3] = cam2cam['R_rect_00'].reshape(3, 3)\n P_rect = cam2cam['P_rect_0'+str(cam)].reshape(3, 4)\n P_velo2im = np.dot(np.dot(P_rect, R_cam2rect), velo2cam)\n\n # load velodyne points and remove all behind image plane (approximation)\n # each row of the velodyne data is forward, left, up, reflectance\n velo = load_velodyne_points(velo_filename)\n velo = velo[velo[:, 0] >= 0, :]\n\n # project the points to the camera\n velo_pts_im = np.dot(P_velo2im, velo.T).T\n velo_pts_im[:, :2] = velo_pts_im[:, :2] / velo_pts_im[:, 2][..., np.newaxis]\n\n if vel_depth:\n velo_pts_im[:, 2] = velo[:, 0]\n\n # check if in bounds\n # use minus 1 to get the exact same value as KITTI matlab code\n velo_pts_im[:, 0] = np.round(velo_pts_im[:, 0]) - 1\n velo_pts_im[:, 1] = np.round(velo_pts_im[:, 1]) - 1\n val_inds = (velo_pts_im[:, 0] >= 0) & (velo_pts_im[:, 1] >= 0)\n val_inds = val_inds & (velo_pts_im[:, 0] < im_shape[1]) & (velo_pts_im[:, 1] < im_shape[0])\n velo_pts_im = velo_pts_im[val_inds, :]\n\n # project to image\n depth = np.zeros((im_shape[:2]))\n depth[velo_pts_im[:, 1].astype(np.int), velo_pts_im[:, 0].astype(np.int)] = velo_pts_im[:, 2]\n\n # find the duplicate points and choose the closest depth\n inds = sub2ind(depth.shape, velo_pts_im[:, 1], velo_pts_im[:, 0])\n dupe_inds = [item for item, count in Counter(inds).items() if count > 1]\n for dd in dupe_inds:\n pts = np.where(inds == dd)[0]\n x_loc = int(velo_pts_im[pts[0], 0])\n y_loc = int(velo_pts_im[pts[0], 1])\n depth[y_loc, x_loc] = velo_pts_im[pts, 2].min()\n depth[depth < 0] = 0\n\n return depth","def matrix(self):\n\t\t# apply yaw, then pitch, then roll\n\t\treturn Matrix((\n\t\t\t(\t1,\t0,\t\t\t\t\t\t\t0\t\t\t\t\t\t\t),\n\t\t\t(\t0,\tmath.cos(self.roll.val),\t-math.sin(self.roll.val)\t),\n\t\t\t(\t0,\tmath.sin(self.roll.val),\tmath.cos(self.roll.val)\t\t)\n\t\t))* Matrix((\n\t\t\t(\tmath.cos(self.pitch.val),\t0,\tmath.sin(self.pitch.val)\t),\n\t\t\t(\t0,\t\t\t\t\t\t\t1,\t0 \t\t\t\t\t\t\t),\n\t\t\t(\t-math.sin(self.pitch.val),\t0,\tmath.cos(self.pitch.val)\t)\n\t\t)) * Matrix((\n\t\t\t(\tmath.cos(self.yaw.val),\t-math.sin(self.yaw.val),\t0\t),\n\t\t\t(\tmath.sin(self.yaw.val),\tmath.cos(self.yaw.val),\t\t0\t),\n\t\t\t(\t0,\t\t\t\t\t\t0,\t\t\t\t\t\t\t1\t)\n\t\t))","def prepare_data(cameras, frame_points_3d, frame_points_2d, keyframe_idx):\n camera_params = np.empty((0, 9))\n for c in cameras:\n R, _ = cv2.Rodrigues(c.R_mat)\n camera = build_camera(R, c.t)\n camera_params = np.append(camera_params, [camera], axis=0)\n\n camera_indices = []\n point_indices = []\n points_2d = np.empty((0, 2))\n points_3d = np.empty((0, 3))\n\n camera_id = 0\n pt_id_counter = 0\n for k, pts_2d in enumerate(frame_points_2d):\n if k > 0:\n halfway_idx = keyframe_idx[k] - keyframe_idx[k - 1] - 1\n points_2d = np.vstack((points_2d, frame_points_2d[k-1][halfway_idx]))\n points_3d = np.vstack((points_3d, frame_points_3d[k-1][halfway_idx]))\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-1][halfway_idx]))]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-1][halfway_idx]))]\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-1][halfway_idx])\n\n if k > 1:\n end_idx = keyframe_idx[k + 1] - keyframe_idx[k - 1] - 3\n points_2d = np.vstack((points_2d, frame_points_2d[k-2][end_idx]))\n points_3d = np.vstack((points_3d, frame_points_3d[k-2][end_idx]))\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-2][end_idx]))]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-2][end_idx]))]\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-2][end_idx])\n\n points_2d = np.vstack((points_2d, frame_points_2d[k][0]))\n points_3d = np.vstack((points_3d, frame_points_3d[k][0]))\n camera_indices += [camera_id for _ in range(pts_2d.shape[1])]\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + pts_2d.shape[1])]\n\n camera_id += 1\n pt_id_counter = pt_id_counter + pts_2d.shape[1]\n\n return camera_params, np.asarray(camera_indices), np.asarray(point_indices), points_3d, points_2d","def create_matrices(self):\n debut = time.process_time()\n\n x = np.arange(0, self.axe_X)\n y = np.arange(0, self.axe_Y)\n xv, yv = np.meshgrid(x, y)\n\n print(\"\\nmatrix creation estimation time: %.1fs\" % (1e-6*self.axe_X*self.axe_Y))\n\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\n\n fin = time.process_time()\n print(\"matrix created in time: %.1f s\" % (fin-debut))\n return img_matrix_x, img_matrix_y","def LV_Matrices(self):\n self.LV_inhM = self.LotkaVolterra_InhibitMatrix() # (nF, nF)\n self.LV_c, self.LV_s = self.LotkaVolterra_Dynamics() # (nS, 1)\n # TODO: The LV weights are incredibly slow...\n # self.LV_W = self.LotkaVolterra_Weights2()","def encode_landm(matched, priors, variances):\n matched = torch.reshape(matched, (matched.size(0), 4, 2))\n priors_cx = priors[:, 0].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\n priors_cy = priors[:, 1].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\n priors_w = priors[:, 2].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\n priors_h = priors[:, 3].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\n priors = torch.cat([priors_cx, priors_cy, priors_w, priors_h], dim=2)\n g_cxcy = matched[:, :, :2] - priors[:, :, :2]\n g_cxcy /= variances[0] * priors[:, :, 2:]\n g_cxcy = g_cxcy.reshape(g_cxcy.size(0), -1)\n return g_cxcy","def main():\n doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document\n keymod = GetKeyMod() # Get keymodifier\n selected = doc.GetActiveObjects(0) # Get selected objects\n cameras = [] # Collect cameras to an array\n doc.StartUndo() # Start recording undos\n # Collect cameras and do preparation operations\n for s in selected: # Iterate through objects\n if (s.GetType() == 5103) or (s.GetType() == 1057516): # If object is a camera object (standard C4D camera or Redshift camera)\n if s.GetType() == 5103: # If standard C4D camera\n dummyCam = DummyStandardCamera(s, doc) # Dummy camera\n dataVault = GetDataVault(5103) # Get corresponding data vault\n elif s.GetType() == 1057516: # If RS camera\n dummyCam = DummyRedshiftCamera(s, doc) # Dummy camera\n dataVault = GetDataVault(1057516) # Get corresponding data vault\n bakeCam = dummyCam.GetClone() # Bake camera\n name = s.GetName() # Get camera's name\n bakeCam.SetName(name+suffix) # Set baked camera's name\n doc.InsertObject(bakeCam) # Insert camera to document\n doc.AddUndo(c4d.UNDOTYPE_NEW, bakeCam) # Add undo command for creating a new object\n MoveToLast(bakeCam, doc) # Move object to last\n RemoveTags(bakeCam) # Remove tags of the object\n cameras.append([s, dummyCam, bakeCam, dataVault]) # Original camera, dummy camera, camera to bake\n\n doc.ExecutePasses(None, True, True, True, 0) # Animate the current frame of the document\n Bake(cameras) # Bake the camera (standard C4D camera)\n CleanKeys(cameras) # Clean keyframes\n\n # Remove dummy cameras\n for i in range(0, len(cameras)):\n cameras[i][1].Remove() # Delete Dummy camera(s)\n\n # Sort baked cameras\n for i in reversed(range(0, len(cameras))):\n MoveToFirst(cameras[i][2], doc) # Move camera to top of the hierarchy list\n\n #if keymod == \"Shift\":\n # CopyRendererTags(s, bakeCam) # Copies renderer tags from source camera to bake camera\n\n doc.EndUndo() # Stop recording undos\n c4d.EventAdd() # Refresh Cinema 4D\n c4d.StatusClear() # Clear status","def perspective_projection(points, rotation, translation, focal_length, camera_center):\n batch_size = points.shape[0]\n K = torch.zeros([batch_size, 3, 3], device=points.device)\n K[:, 0, 0] = focal_length\n K[:, 1, 1] = focal_length\n K[:, 2, 2] = 1.0\n K[:, :-1, -1] = camera_center\n points = torch.einsum('bij,bkj->bki', rotation, points)\n points = points + translation.unsqueeze(1)\n projected_points = points / points[:, :, -1].unsqueeze(-1)\n projected_points = torch.einsum('bij,bkj->bki', K, projected_points)\n projected_points = projected_points[:, :, :-1]\n return projected_points","def show_planes(im, spacing=10): # pragma: no cover\n s = spacing\n if np.squeeze(im.ndim) < 3:\n raise Exception('This view is only necessary for 3D images')\n x, y, z = (np.array(im.shape)/2).astype(int)\n im_xy = im[:, :, z]\n im_xz = im[:, y, :]\n im_yz = np.rot90(im[x, :, :])\n\n new_x = im_xy.shape[0] + im_yz.shape[0] + s\n\n new_y = im_xy.shape[1] + im_xz.shape[1] + s\n\n new_im = np.zeros([new_x + 2*s, new_y + 2*s], dtype=im.dtype)\n\n # Add xy image to upper left corner\n new_im[s:im_xy.shape[0] + s,\n s:im_xy.shape[1] + s] = im_xy\n # Add xz image to lower left coner\n x_off = im_xy.shape[0] + 2*s\n y_off = im_xy.shape[1] + 2*s\n new_im[s:s + im_xz.shape[0],\n y_off:y_off + im_xz.shape[1]] = im_xz\n new_im[x_off:x_off + im_yz.shape[0],\n s:s + im_yz.shape[1]] = im_yz\n\n return new_im","def matrix4_to_3x4_array(mat):\r\n return tuple(f for v in mat[0:3] for f in v)","def fun(params,n_cameras,n_points,camera_indices,point_indices,points_3d , points_2d):\n camera_params = params[:n_cameras * 6].reshape((n_cameras, 6))\n # points_3d = points_3d.T\n # points_3d = params[n_cameras * 7:].reshape((n_points, 3))\n # print(point_indices)\n points_proj = project(points_3d[point_indices], camera_params[camera_indices])\n return (points_proj - points_2d).ravel()","def lfread(path, ang=7):\n lenslet = cv2.imread(path)\n h, w, c = lenslet.shape\n lf = np.zeros((ang, ang, c, h // ang, w // ang), dtype=np.uint8)\n\n for idx in range(ang ** 2):\n q = idx // ang\n p = idx % ang\n lf[q, p, :, :, :] = lenslet[q::ang, p::ang, :].transpose(2, 0, 1)\n\n del lenslet\n return lf","def getInverseMatrix(self) -> CMatrix4:\n ...","def m(self) -> np.ndarray:\n assert self._k is not None and self._r is not None and self._t is not None, \"camera must be calibrated\"\n return forge_projective_matrix(self._k, r=self._r, t=self._t)","def forward(self, x, fm, camera_mat):\n\n batch_size = x.shape[0]\n # List of initial 3D coordinates (first item) and outputs of the layers\n out = list()\n\n initial_coordinates_expanded = self.initial_coordinates.expand(\n batch_size, -1, -1)\n out.append(initial_coordinates_expanded)\n \n # #######################\n # First Projection Block\n # Layer 0: 156 x feat_dim\n out.append(self.gp(initial_coordinates_expanded, fm, camera_mat))\n out.append(self.gc1(out[-1])) # Layer 1: 156 x hidden_dim\n for i in range(0, 12): # GraphConvs from and to 156 x hidden_dim\n val = self.gc2[i](out[-1])\n if (i % 2) == 1:\n # Add previous output (Restnet style)\n val = torch.add(val, out[-2]) * 0.5\n out.append(val)\n # Layer 14: Out of dim 156x3, will be used as outputs_2[1]\n out.append(self.gc3(out[-1]))\n\n # #######################\n # Second Projection Block\n # Layer 15: 156 x (hidden_dim + feat_dim)\n v = self.gp(out[-1], fm, camera_mat)\n v = torch.cat([v, out[-2]], dim=2)\n out.append(v)\n # Layer 16: 618x (hidden_dim + feat_dim)\n out.append(self.gup1(out[-1]))\n out.append(self.gc4(out[-1])) # Layer 17: 618 x hidden_dim\n for i in range(0, 12): # GraphConvs from and to 618 x hidden_dim\n val = self.gc5[i](out[-1])\n if (i % 2) == 1:\n # Add previous output (Restnet style)\n val = torch.add(val, out[-2]) * 0.5\n out.append(val)\n # Layer 30: 618 x 3, will be used as outputs_2[2]\n out.append(self.gc6(out[-1]))\n\n # #######################\n # Third Projection Block\n # Layer 31: 618 x hidden_dim + feat_dim\n v = self.gp(out[-1], fm, camera_mat) # 618 x feat_dim\n v = torch.cat([v, out[-2]], dim=2)\n out.append(v)\n # Layer 32: 2466 x hidden_dim + feat_dim\n out.append(self.gup2(out[-1]))\n out.append(self.gc7(out[-1])) # Layer 33: 2466 x hidden_dim\n for i in range(0, 13): # GraphConvs from and to 2466 x hidden_dim\n val = self.gc8[i](out[-1])\n if i % 2 == 1:\n # Add previous output (Restnet style)\n val = torch.add(val, out[-2]) * 0.5\n out.append(val)\n out.append(self.gc9(out[-1])) # Layer 47: 2466 x 3\n # 156 x hidden_dim, 618 x hidden_dim, 2466 x hidden_dim\n outputs = (out[15], out[31], out[-1])\n outputs_2 = (initial_coordinates_expanded,\n self.gup1(out[15]), self.gup2(out[31]))\n\n return outputs, outputs_2"],"string":"[\n \"def getCameraMatrix(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def camera_matrix(self) -> TransformationMatrixType:\\n return numpy.matmul(\\n self.rotation_matrix(*self.rotation),\\n displacement_matrix(*-numpy.array(self.location)),\\n )\",\n \"def perspectiveFovLH(field_of_view, aspect, znear, zfar):\\n h = 1 / tan(field_of_view / 2)\\n w = h / aspect\\n m = [\\n [w, 0, 0, 0],\\n [0, h, 0, 0],\\n [0, 0, zfar / (zfar - znear), 1],\\n [0, 0, (znear * zfar) / (znear - zfar), 0],\\n ]\\n return Matrix(m)\",\n \"def camera_matrix(e, p, t):\\n # Translates all points such that the camera is centered at the origin.\\n T = np.array([[1, 0, 0, -e[0]],\\n [0, 1, 0, -e[1]],\\n [0, 0, 1, -e[2]],\\n [0, 0, 0, 1]])\\n\\n # Set up orthonormal basis.\\n w = e - p\\n w = w / np.linalg.norm(w)\\n u = np.cross(t, w)\\n u = u / np.linalg.norm(u)\\n v = np.cross(w, u)\\n\\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\\n R = np.array([[u[0], u[1], u[2], 0],\\n [v[0], v[1], v[2], 0],\\n [w[0], w[1], w[2], 0],\\n [ 0, 0, 0, 1]])\\n return R.dot(T)\",\n \"def fk4(joint_rotations):\\n h0_4 = htm4(joint_rotations)\\n x0_4 = h0_4[0, 3]\\n y0_4 = h0_4[1, 3]\\n z0_4 = h0_4[2, 3]\\n d0_4 = [x0_4, y0_4, z0_4]\\n return d0_4\",\n \"def _mclachlan_atela_4th(vel_update, pos_update=update.PositionUpdate()):\\n As = [\\n 0.5153528374311229364,\\n -0.085782019412973646,\\n 0.4415830236164665242,\\n 0.1288461583643841854,\\n ]\\n Bs = [\\n 0.1344961992774310892,\\n -0.2248198030794208058,\\n 0.7563200005156682911,\\n 0.3340036032863214255,\\n ]\\n updates = [vel_update, pos_update]*4\\n coeff = []\\n for a, b in zip(As, Bs):\\n coeff.extend([a, b])\\n return ExplicitIntegrator(coeff, updates)\",\n \"def getMatrix(self) -> CMatrix4:\\n ...\",\n \"def ortho(self):\\r\\n\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n\\r\\n x = _vec3(m11, m21, m31)\\r\\n y = _vec3(m12, m22, m32)\\r\\n z = _vec3(m13, m23, m33)\\r\\n\\r\\n xl = x.length()\\r\\n xl*=xl\\r\\n y = y - ((x*y)/xl)*x\\r\\n z = z - ((x*z)/xl)*x\\r\\n\\r\\n yl = y.length()\\r\\n yl*=yl\\r\\n z = z - ((y*z)/yl)*y\\r\\n\\r\\n return mat4( x.x, y.x, z.x, m14,\\r\\n x.y, y.y, z.y, m24,\\r\\n x.z, y.z, z.z, m34,\\r\\n m41, m42, m43, m44)\",\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 _calculate_camera_array(self):\\n look_list = []\\n\\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\\n col_step_vec = self._get_look_right() * self.interspatial_distance\\n\\n # Start at the top left camera position\\n for i in range(self.spatial_rows):\\n row_movement = row_step_vec * (-i)\\n row_look_from = self.look_from + row_movement\\n row_look_to = self.look_to + row_movement\\n\\n for j in range(self.spatial_cols):\\n col_movement = col_step_vec * j\\n cam_look_from = row_look_from + col_movement\\n cam_look_to = row_look_to + col_movement\\n\\n look_list.append((cam_look_from, cam_look_to))\\n\\n return look_list\",\n \"def frustum(self, left, right, bottom, top, near, far):\\r\\n \\r\\n return mat4( (2.0*near)/(right-left), 0.0, float(right+left)/(right-left), 0.0,\\r\\n 0.0, (2.0*near)/(top-bottom), float(top+bottom)/(top-bottom), 0.0,\\r\\n 0.0, 0.0, -float(far+near)/(far-near), -(2.0*far*near)/(far-near),\\r\\n 0.0, 0.0, -1.0, 0.0)\",\n \"def create_cam2world_matrix(forward_vector,\\n origin,\\n device=None):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n forward_vector = normalize_vecs(forward_vector)\\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\\\\n .expand_as(forward_vector)\\n\\n left_vector = normalize_vecs(\\n torch.cross(up_vector,\\n forward_vector,\\n dim=-1))\\n\\n up_vector = normalize_vecs(\\n torch.cross(forward_vector,\\n left_vector,\\n dim=-1))\\n\\n rotation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n rotation_matrix[:, :3, :3] = torch.stack(\\n (-left_vector, up_vector, -forward_vector), axis=-1)\\n\\n translation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n translation_matrix[:, :3, 3] = origin\\n\\n cam2world = translation_matrix @ rotation_matrix\\n\\n return cam2world\",\n \"def lookAtLH(eye, target, up):\\n zaxis = (target - eye).normalize()\\n xaxis = up.cross(zaxis).normalize()\\n yaxis = zaxis.cross(xaxis).normalize()\\n\\n ex = -xaxis.dot(eye)\\n ey = -yaxis.dot(eye)\\n ez = -zaxis.dot(eye)\\n\\n m = [\\n [xaxis.x, yaxis.x, zaxis.x, 0],\\n [xaxis.y, yaxis.y, zaxis.y, 0],\\n [xaxis.z, yaxis.z, zaxis.z, 0],\\n [ex, ey, ez, 1]\\n ]\\n return Matrix(m)\",\n \"def _embed44(matrix):\\n result = np.eye(4)\\n r, c = matrix.shape\\n result[:r, :c] = matrix\\n return result\",\n \"def row_matrix_col_4d(a, b, A):\\n\\n\\treturn (a[0]*A[0][0]*b[0] + a[1]*A[1][0]*b[0] + a[2]*A[2][0]*b[0] + a[3]*A[3][0]*b[0] +\\n\\t a[0]*A[0][1]*b[1] + a[1]*A[1][1]*b[1] + a[2]*A[2][1]*b[1] + a[3]*A[3][1]*b[1] +\\n\\t a[0]*A[0][2]*b[2] + a[1]*A[1][2]*b[2] + a[2]*A[2][2]*b[2] + a[3]*A[3][2]*b[2] +\\n\\t a[0]*A[0][3]*b[3] + a[1]*A[1][3]*b[3] + a[2]*A[2][3]*b[3] + a[3]*A[3][3]*b[3])\",\n \"def _LookAtMatrix(at, eye, up=[0, 1, 0], reflect=False):\\r\\n # If reflect, then reflect in plane -20.0 (water depth)\\r\\n if reflect:\\r\\n depth = -20.0 # Shallower to avoid edge effects\\r\\n eye = [eye[0], -eye[1], eye[2]]\\r\\n at = [at[0], -at[1], at[2]]\\r\\n zaxis = vec_normal(vec_sub(at, eye))\\r\\n xaxis = vec_normal(vec_cross(up, zaxis))\\r\\n yaxis = vec_cross(zaxis, xaxis)\\r\\n xaxis.append(-vec_dot(xaxis, eye))\\r\\n yaxis.append(-vec_dot(yaxis, eye))\\r\\n zaxis.append(-vec_dot(zaxis, eye))\\r\\n z = [0, 0, 0, 1.0]\\r\\n return array([[xaxis[a], yaxis[a], zaxis[a], z[a]] for a in range(4)],\\r\\n dtype=float)\",\n \"def set_camera(self, width, height):\\n rightt = self.mat[:3, 0]\\n upt = self.mat[:3, 1]\\n pt = self.mat[:3, 2] * self.d\\n t = self.mat[:3, 3]\\n\\n self.proj_mat = create_perspective_projection_matrix(np.radians(self.fov), 1. * width / height, self.near, self.far)\\n gr3.setcameraprojectionparameters(self.fov, self.near, self.far)\\n self.lookat_mat = create_look_at_matrix(pt + t, t, upt)\\n gr3.cameralookat(pt[0] + t[0], pt[1] + t[1], pt[2] + t[2], t[0], t[1], t[2], upt[0], upt[1], upt[2])\",\n \"def matrix(self):\\n m = Matrix.identity(4, 4)\\n\\n m[:3, :3] = self.rotation.matrix.data\\n m[:3, 3:4] = self.translation.matrix.data\\n\\n return m\",\n \"def getDejaVuMatrix(self):\\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\\n mtx[3] = self.getTranslation()\\n mtx[:3, 3] = mtx[3, :3]\\n mtx[3, :3] = [0, 0, 0]\\n return mtx\",\n \"def get_projection_matrix(K, rvec, tvec):\\n R = cv2.Rodrigues(np.float32(rvec))[0]\\n Rt = np.zeros((3, 4))\\n Rt[:, 0:3] = R\\n Rt[:, 3] = tvec\\n return K @ Rt\",\n \"def map_to_matrix(x, y):\\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\\n\\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\\n\\n return x_pos, y_pos\",\n \"def modelview_matrix(self):\\n camera = self.figure.scene.camera\\n return camera.view_transform_matrix.to_array().astype(np.float32)\",\n \"def htm4(joint_rotations):\\n # H0_3\\n h0_3 = htm0_3(joint_rotations)\\n\\n # H3_4\\n r3_4 = rot_z(joint_rotations[3])\\n x3_4 = a4 * np.cos(np.radians(joint_rotations[3]))\\n y3_4 = a4 * np.sin(np.radians(joint_rotations[3]))\\n z3_4 = 0\\n d3_4 = transl(x3_4, y3_4, z3_4)\\n h3_4 = htm(r3_4, d3_4)\\n h0_4 = np.dot(h0_3, h3_4)\\n return h0_4\",\n \"def _ProjectionMatrix(near, far, fov, aspectRatio):\\r\\n # Matrices are considered to be M[row][col]\\r\\n # Use DirectX convention, so need to do rowvec*Matrix to transform\\r\\n size = 1 / tan(radians(fov)/2.0)\\r\\n M = [[0] * 4 for i in range(4)]\\r\\n M[0][0] = size/aspectRatio\\r\\n M[1][1] = size #negative value reflects scene on the Y axis\\r\\n M[2][2] = (far + near) / (far - near)\\r\\n M[2][3] = 1\\r\\n M[3][2] = -(2 * far * near)/(far - near)\\r\\n return array(M, dtype=float)\",\n \"def camera_transform(image):\\n img = np.zeros((image.shape[0], image.shape[1], 3))\\n for y in range(image.shape[0]):\\n for x in range(image.shape[1]):\\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\\n y, x]\\n return img\",\n \"def render_4d(polyhedron, **kwds):\\n projection_direction = None\\n try: \\n projection_direction = kwds.pop('projection_directior')\\n except KeyError:\\n for ineq in polyhedron.inequality_generator():\\n center = [v() for v in ineq.incident() if v.is_vertex()]\\n center = sum(center) / len(center)\\n if not center.is_zero(): \\n projection_direction = center\\n break\\n projection_3d = Projection(polyhedron).schlegel(projection_direction)\\n return render_3d(projection_3d, **kwds)\",\n \"def computeMVP(self):\\n projMat = self.converterYUR\\n modelViewMat = self.transforMat.invertCompose(\\n Globals.render.getTransform(self.cameraNode)).getMat()\\n return UnalignedLMatrix4f(modelViewMat * projMat)\",\n \"def L1U(A, d):\\n n = shape(A)[0]\\n L = eye(n)\\n U = matrix(zeros((n,n))); U[0,0] = A[0,0]\\n for k in range(1,n):\\n km = array([0, k - d]).max()\\n if km < k:\\n L[k, km:k] = A[k, km:k]\\n rforwardsolve(U[km:k, km:k].T, L[k, km:k].T, d) # L\\n U[km:(k + 1), k] = A[km:(k + 1), k]\\n rforwardsolve(L[km:(k + 1), km:(k + 1)], U[km:(k + 1), k], d) # U\\n return L, U\",\n \"def __init__(self, at=(0, 0, 0), eye=(0, 0, -0.1), lens=None,\\r\\n is_3d=True, scale=1.0):\\r\\n super(Camera, self).__init__()\\r\\n\\r\\n self.at = at\\r\\n self.start_eye = eye # for reset with different lens settings\\r\\n self.eye = [eye[0], eye[1], eye[2]]\\r\\n if lens == None:\\r\\n from pi3d.Display import Display\\r\\n lens = [Display.INSTANCE.near, Display.INSTANCE.far, Display.INSTANCE.fov,\\r\\n Display.INSTANCE.width / float(Display.INSTANCE.height)]\\r\\n self.lens = lens\\r\\n self.view = _LookAtMatrix(at, eye, [0, 1, 0])\\r\\n if is_3d:\\r\\n self.projection = _ProjectionMatrix(lens[0], lens[1], lens[2] / scale, lens[3])\\r\\n else:\\r\\n self.projection = _OrthographicMatrix(scale=scale)\\r\\n self.model_view = dot(self.view, self.projection)\\r\\n # Apply transform/rotation first, then shift into perspective space.\\r\\n self.mtrx = array(self.model_view, copy=True)\\r\\n # self.L_reflect = _LookAtMatrix(at,eye,[0,1,0],reflect=True)\\r\\n self.rtn = [0.0, 0.0, 0.0]\\r\\n\\r\\n self.was_moved = True\",\n \"def matrix_math_api_examples():\\n \\n print(dingbat.vec2())\\n print(dingbat.vec2(array.array('f', (20, 40))))\\n print(dingbat.mat3())\\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\\n translate = dingbat.translation_matrix(-10, -20, -30)\\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\\n scale = dingbat.scale_matrix(100, 200, 300)\\n print(translate)\\n print(rotate)\\n print(scale)\\n print(dingbat.multiply_matrices(translate, rotate, scale))\",\n \"def decompose_essential_matrix(E, x1, x2):\\n\\n # Fix left camera-matrix\\n Rl = np.eye(3)\\n tl = np.array([[0, 0, 0]]).T\\n Pl = np.concatenate((Rl, tl), axis=1)\\n\\n # TODO: Compute possible rotations and translations\\n \\n # s must be [1, 1, 0]\\n u, s, vh = np.linalg.svd(E)\\n E = u @ np.diag([1, 1, 0]) @ vh\\n u, s, vh = np.linalg.svd(E)\\n\\n w = np.array([[ 0, 1, 0], \\n [-1, 0, 0], \\n [ 0, 0, 1]]) \\n \\n z = np.array([[ 0, -1, 0], \\n [ 1, 0, 0],\\n [ 0, 0, 0]])\\n \\n R1 = u @ w.T @ vh\\n s1 = -u @ z @ u.T\\n R2 = u @ w @ vh\\n s2 = u @ z @ u.T\\n\\n t1 = np.array([[s1[2, 1]], \\n [s1[0, 2]],\\n [s1[1, 0]]])\\n \\n t2 = np.array([[s2[2, 1]], \\n [s2[0, 2]], \\n [s2[1, 0]]]) \\n\\n # Four possibilities\\n Pr = [np.concatenate((R1, t1), axis=1),\\n np.concatenate((R1, t2), axis=1),\\n np.concatenate((R2, t1), axis=1),\\n np.concatenate((R2, t2), axis=1)]\\n\\n # Compute reconstructions for all possible right camera-matrices\\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\\n\\n # Compute projections on image-planes and find when both cameras see point\\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\\n range(4)]\\n test = np.array(test)\\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\\n\\n # Choose correct matrix\\n Pr = Pr[idx]\\n\\n return Pl, Pr\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def perspective_transform():\\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\\n M = cv2.getPerspectiveTransform(src, dst)\\n Minv = cv2.getPerspectiveTransform(dst, src)\\n\\n return M, Minv\",\n \"def intrinsic_matrix_from_camera(w, h, fov):\\n (cx, cy), f = calc_focal_values(w, h, fov)\\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])\",\n \"def ExtractCameraPose(E):\\n u, s, v = np.linalg.svd(E, full_matrices=True)\\n w = np.array([[0, -1, 0],\\n [1, 0, 0],\\n [0, 0, 1]]).reshape(3, 3)\\n c1 = u[:, 2].reshape(3, 1)\\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c2 = -u[:, 2].reshape(3, 1)\\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c3 = u[:, 2].reshape(3, 1)\\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n c4 = -u[:, 2].reshape(3, 1)\\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n if np.linalg.det(r1) < 0:\\n c1 = -c1\\n r1 = -r1\\n if np.linalg.det(r2) < 0:\\n c2 = -c2\\n r2 = -r2\\n if np.linalg.det(r3) < 0:\\n c3 = -c3\\n r3 = -r3\\n if np.linalg.det(r4) < 0:\\n c4 = -c4\\n r4 = -r4\\n cam_center = np.array([c1, c2, c3, c4])\\n cam_rotation = np.array([r1, r2, r3, r4])\\n return cam_center, cam_rotation\",\n \"def calculate_pitch_yaw_roll(landmarks_2D, cam_w=256, cam_h=256,\\n radians=False):\\n\\n assert landmarks_2D is not None, 'landmarks_2D is None'\\n\\n # Estimated camera matrix values.\\n c_x = cam_w / 2\\n c_y = cam_h / 2\\n f_x = c_x / np.tan(60 / 2 * np.pi / 180)\\n f_y = f_x\\n camera_matrix = np.float32([[f_x, 0.0, c_x], [0.0, f_y, c_y],\\n [0.0, 0.0, 1.0]])\\n camera_distortion = np.float32([0.0, 0.0, 0.0, 0.0, 0.0])\\n\\n # dlib (68 landmark) trached points\\n # TRACKED_POINTS = [17, 21, 22, 26, 36, 39, 42, 45, 31, 35, 48, 54, 57, 8]\\n # wflw(98 landmark) trached points\\n # TRACKED_POINTS = [33, 38, 50, 46, 60, 64, 68, 72, 55, 59, 76, 82, 85, 16]\\n # X-Y-Z with X pointing forward and Y on the left and Z up.\\n # The X-Y-Z coordinates used are like the standard coordinates of ROS (robotic operative system)\\n # OpenCV uses the reference usually used in computer vision:\\n # X points to the right, Y down, Z to the front\\n landmarks_3D = np.float32([\\n [6.825897, 6.760612, 4.402142], # LEFT_EYEBROW_LEFT, \\n [1.330353, 7.122144, 6.903745], # LEFT_EYEBROW_RIGHT, \\n [-1.330353, 7.122144, 6.903745], # RIGHT_EYEBROW_LEFT,\\n [-6.825897, 6.760612, 4.402142], # RIGHT_EYEBROW_RIGHT,\\n [5.311432, 5.485328, 3.987654], # LEFT_EYE_LEFT,\\n [1.789930, 5.393625, 4.413414], # LEFT_EYE_RIGHT,\\n [-1.789930, 5.393625, 4.413414], # RIGHT_EYE_LEFT,\\n [-5.311432, 5.485328, 3.987654], # RIGHT_EYE_RIGHT,\\n [-2.005628, 1.409845, 6.165652], # NOSE_LEFT,\\n [-2.005628, 1.409845, 6.165652], # NOSE_RIGHT,\\n [2.774015, -2.080775, 5.048531], # MOUTH_LEFT,\\n [-2.774015, -2.080775, 5.048531], # MOUTH_RIGHT,\\n [0.000000, -3.116408, 6.097667], # LOWER_LIP,\\n [0.000000, -7.415691, 4.070434], # CHIN\\n ])\\n landmarks_2D = np.asarray(landmarks_2D, dtype=np.float32).reshape(-1, 2)\\n\\n # Applying the PnP solver to find the 3D pose of the head from the 2D position of the landmarks.\\n # retval - bool\\n # rvec - Output rotation vector that, together with tvec, brings points from the world coordinate system to the camera coordinate system.\\n # tvec - Output translation vector. It is the position of the world origin (SELLION) in camera co-ords\\n _, rvec, tvec = cv2.solvePnP(landmarks_3D, landmarks_2D,\\n camera_matrix, camera_distortion)\\n #Get as input the rotational vector, Return a rotational matrix\\n\\n # const double PI = 3.141592653;\\n # double thetaz = atan2(r21, r11) / PI * 180;\\n # double thetay = atan2(-1 * r31, sqrt(r32*r32 + r33*r33)) / PI * 180;\\n # double thetax = atan2(r32, r33) / PI * 180;\\n \\n rmat, _ = cv2.Rodrigues(rvec)\\n pose_mat = cv2.hconcat((rmat, tvec))\\n _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)\\n return map(lambda k: k[0], euler_angles) # euler_angles contain (pitch, yaw, roll)\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n\\n origin = np.array([location.x, location.y, location.z])\\n return matrix, origin\",\n \"def pixel2cam(self, depth, intrinsics_inv):\\n b, _, h, w = depth.size()\\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\\n ones = torch.ones(1,h,w).type_as(depth)\\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\\n return cam_coords * depth\",\n \"def compute_projection_matrix(width,\\n height,\\n f_x,\\n f_y,\\n c_x,\\n c_y,\\n near,\\n far):\\n # pylint: disable=line-too-long\\n matrix = vtk.vtkMatrix4x4()\\n matrix.Zero()\\n matrix.SetElement(0, 0, 2*f_x/width)\\n matrix.SetElement(0, 1, -2*0/width) # Not doing skew, so this will be 0.\\n matrix.SetElement(0, 2, (width - 2*c_x)/width)\\n matrix.SetElement(1, 1, 2*f_y/height)\\n matrix.SetElement(1, 2, (-height + 2*c_y)/height)\\n matrix.SetElement(2, 2, (-far-near)/(far-near))\\n matrix.SetElement(2, 3, -2*far*near/(far-near))\\n matrix.SetElement(3, 2, -1)\\n return matrix\",\n \"def build_camera(R, t):\\n camera = R.flatten()\\n camera = np.append(camera, t.flatten())\\n camera = np.append(camera, K[0][0])\\n camera = np.append(camera, dist[0, 0:2].flatten())\\n return camera\",\n \"def proj_to_velo(calib_data):\\n rect = calib_data[\\\"R0_rect\\\"].reshape(3, 3)\\n #to transform a point from Lidar framce to camera frame\\n #reshape the flat line with 12 elements to 3X4 matrix\\n velo_to_cam = calib_data[\\\"Tr_velo_to_cam\\\"].reshape(3, 4)\\n#print('velo2cam', velo_to_cam)\\n inv_rect = np.linalg.inv(rect)\\n #select all rows and only first three columns\\n#print('velo_to_cam[:, :3]', velo_to_cam[:, :3])\\n #select all rows and only first three columns\\n inv_velo_to_cam = np.linalg.pinv(velo_to_cam[:, :3])\\n return np.dot(inv_velo_to_cam, inv_rect)\",\n \"def bloch_matrix(self):\\n if self.gf_r is None:\\n self.gf()\\n\\n return -self.gf_r.dot(self.lead[1])\",\n \"def L1U(A, d):\\n \\n\\n n, _ = A.shape\\n L = np.eye(n, n, dtype=A.dtype)\\n U = np.zeros((n, n), dtype=A.dtype)\\n\\n U[0, 0] = A[0, 0]\\n for k in range(1, n):\\n km = max(0, k-d)\\n L[k, km : k] = np.transpose(rforwardsolve(np.transpose(U[km:k, km:k]),\\\\\\n np.transpose(A[k, km:k]), d))\\n U[km:k+1, k] = rforwardsolve(L[km:k+1, km:k+1], A[km:k+1, k], d)\\n return L, U\",\n \"def createCamera():\\n\\n turnCam = cmds.camera()\\n lookThruAndFrame(turnCam[0])\\n return turnCam\",\n \"def set_modelview_from_camera(Rt):\\n \\n glMatrixMode(GL_MODELVIEW)\\n glLoadIdentity()\\n \\n # rotate teapot 90 deg around x-axis so that z-axis is up\\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\\n \\n # set rotation to best approximation\\n R = Rt[:,:3]\\n U,S,V = np.linalg.svd(R)\\n R = np.dot(U,V)\\n R[0,:] = -R[0,:] # change sign of x-axis\\n \\n # set translation\\n t = Rt[:,3]\\n \\n # setup 4*4 model view matrix\\n M = np.eye(4)\\n M[:3,:3] = np.dot(R,Rx)\\n M[:3,3] = t\\n\\n # transpose and flatten to get column order\\n M = M.T\\n \\n m = M.flatten()\\n \\n # replace model view with the new matrix\\n glLoadMatrixf(m)\",\n \"def perspective_matrix(self) -> TransformationMatrixType:\\n z_near, z_far = self._clipping[self.projection_mode.value]\\n return perspective_matrix(\\n math.radians(self.fov), self.aspect_ratio, z_near, z_far\\n )\",\n \"def get_projection_matrix(left, right, bottom, top):\\r\\n zNear = -25.0\\r\\n zFar = 25.0\\r\\n inv_z = 1.0 / (zFar - zNear)\\r\\n inv_y = 1.0 / (top - bottom)\\r\\n inv_x = 1.0 / (right - left)\\r\\n mat = [[(2.0 * inv_x), 0.0, 0.0, (-(right + left) * inv_x)],\\r\\n [0.0, (2.0 * inv_y), 0.0, (-(top + bottom) * inv_y)],\\r\\n [0.0, 0.0, (-2.0 * inv_z), (-(zFar + zNear) * inv_z)],\\r\\n [0.0, 0.0, 0.0, 1.0]]\\r\\n return mat\",\n \"def _derive_transformation_matrices(self):\\n\\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\\n if self._primaries is not None and self._whitepoint is not None:\\n npm = normalised_primary_matrix(self._primaries,\\n self._whitepoint)\\n\\n self._derived_RGB_to_XYZ_matrix = npm\\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)\",\n \"def test_RawRun_perspective_reference_old_style():\\n ref = (0, 0)\\n m = config.ideal_m\\n grid = r.perspective_reference(ref, 'old', 'cam1')\\n lower_right, upper_right, lower_left, upper_left = grid\\n assert_equal((0, 0), lower_right)\\n assert_equal((ref[0] - int(1.47 * m), ref[1] - int(0.25 * m)), upper_left)\",\n \"def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\\n # Camera intrinsics parameters\\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\\n\\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\\n\\n skew = skew # \\\"skew param will be zero for most normal cameras\\\" Hartley, Zisserman\\n\\n m_x = resolution_x_px / resolution_x_mm\\n m_y = resolution_y_px / resolution_y_mm\\n\\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\\n\\n x_0 = resolution_x_px / 2\\n y_0 = resolution_y_px / 2\\n\\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])\",\n \"def new_mirror(self,alongx,alongy):\\n Knew = K.clone()\\n if alongx:\\n Knew[0,2] = size[0]-Knew[0,2]\\n if alongy:\\n Knew[1,2] = size[1]-Knew[1,2]\\n return CameraInfo(self.size,Knew,self.dist)\",\n \"def getPerspectiveProjectionMatrix(l, r, b, t, n, f):\\n e11 = 2 * n / (r - l)\\n e13 = (r + l) / (r - l)\\n e22 = (2 * n) / (t - b)\\n e23 = (t + b) / (t - b)\\n e33 = -1 * (f + n) / (f - n)\\n e34 = (-2 * f * n) / (f - n)\\n\\n return MatrixExtended([\\n [e11, 0, e13, 0],\\n [0, e22, e23, 0],\\n [0, 0, e33, e34],\\n [0, 0, -1, 0]])\",\n \"def RudermanLABFwd(I):\\n\\n # get input image dimensions\\n m = I.shape[0]\\n n = I.shape[1]\\n\\n # define conversion matrices\\n RGB2LMS = np.array([[0.3811, 0.5783, 0.0402],\\n [0.1967, 0.7244, 0.0782],\\n [0.0241, 0.1288, 0.8444]])\\n LMS2LAB = np.array([[1 / (3**0.5), 0, 0],\\n [0, 1 / (6**0.5), 0],\\n [0, 0, 1 / (2**0.5)]]).dot(np.array([[1, 1, 1],\\n [1, 1, -2],\\n [1, -1, 0]]))\\n\\n # calculate LMS values from RGB\\n I = np.reshape(I, (m * n, 3))\\n LMS = np.dot(RGB2LMS, np.transpose(I))\\n LMS[LMS == 0] = np.spacing(1)\\n logLMS = np.log(LMS)\\n\\n # calculate LAB values from LMS\\n I_LAB = LMS2LAB.dot(logLMS)\\n\\n # reshape to 3-channel image\\n I_LAB = np.reshape(I_LAB.transpose(), (m, n, 3))\\n\\n return I_LAB\",\n \"def camera_transformation_from_pose(azimutal, elevation):\\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\\n azimutal *= -1.\\n elevation *= -1.\\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\\n [0, 1, 0],\\n [-np.sin(elevation), 0, np.cos(elevation)]])\\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\\n [np.sin(azimutal), np.cos(azimutal), 0],\\n [0, 0, 1]])\\n r = r_z.dot(r_y)\\n # world_to_camera matrix, camera_to_world matrix\\n return r, np.linalg.inv(r)\",\n \"def __ComputeDesignMatrix(self, groundPoints):\\n # initialization for readability\\n omega = self.exteriorOrientationParameters[3]\\n phi = self.exteriorOrientationParameters[4]\\n kappa = self.exteriorOrientationParameters[5]\\n\\n # Coordinates subtraction\\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\\n dXYZ = np.vstack([dX, dY, dZ])\\n\\n rotationMatrixT = self.rotationMatrix.T\\n rotatedG = rotationMatrixT.dot(dXYZ)\\n rT1g = rotatedG[0, :]\\n rT2g = rotatedG[1, :]\\n rT3g = rotatedG[2, :]\\n\\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\\n\\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\\n\\n dgdX0 = np.array([-1, 0, 0], 'f')\\n dgdY0 = np.array([0, -1, 0], 'f')\\n dgdZ0 = np.array([0, 0, -1], 'f')\\n\\n # Derivatives with respect to X0\\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\\n\\n # Derivatives with respect to Y0\\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\\n\\n # Derivatives with respect to Z0\\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\\n\\n dRTdOmega = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'omega').T\\n dRTdPhi = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'phi').T\\n dRTdKappa = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'kappa').T\\n\\n gRT3g = dXYZ * rT3g\\n\\n # Derivatives with respect to Omega\\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Phi\\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Kappa\\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n # all derivatives of x and y\\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\\n\\n a = np.zeros((2 * dd[0].shape[0], 6))\\n a[0::2] = dd[0]\\n a[1::2] = dd[1]\\n\\n return a\",\n \"def four_point_transform(image, pts):\\n\\n\\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\\n\\n\\tdst = np.array([\\n\\t\\t[0, 0],\\n\\t\\t[image.shape[1] - 1, 0],\\n\\t\\t[image.shape[1] - 1, image.shape[0] - 1],\\n\\t\\t[0, image.shape[0] - 1]], dtype=\\\"float32\\\")\\n\\n\\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\\n\\n\\treturn warped\",\n \"def lap_mat(self):\",\n \"def transformation_matrix(self) -> TransformationMatrixType:\\n # camera translation\\n if self._transformation_matrix is None:\\n self._transformation_matrix = numpy.matmul(\\n self.projection_matrix,\\n self.camera_matrix,\\n )\\n\\n return self._transformation_matrix\",\n \"def create_ortho_matrices(self, offset, scale,\\r\\n window_dimensions, img_dimensions):\\r\\n window_width, window_height = window_dimensions\\r\\n object_x = int(window_width/2 - img_dimensions[0]*scale/2) + offset[0]\\r\\n object_y = int(window_height/2 - img_dimensions[1]*scale/2) + offset[1]\\r\\n model_matrix = get_4x4_transform(int(img_dimensions[0] * scale),\\r\\n int(img_dimensions[1] * scale),\\r\\n object_x,\\r\\n object_y, 1.0)\\r\\n proj_matrix = get_projection_matrix(0, window_width, 0, window_height)\\r\\n view_matrix = get_view_matrix(1.0, 1.0)\\r\\n return model_matrix, proj_matrix, view_matrix\",\n \"def testMatchSwarpLanczos4Image(self):\\n self.compareToSwarp(\\\"lanczos4\\\", useWarpExposure=False)\",\n \"def set_matrix(self):\\n theta1 = -90\\n theta2 = 105\\n theta3 = 180\\n\\n if self.number > 8:\\n theta2 = 75\\n\\n glMatrixMode(GL_MODELVIEW)\\n glPushMatrix()\\n glLoadIdentity()\\n glPushMatrix()\\n glRotatef(theta2, 0.0, 1.0, 0.0)\\n glRotatef(theta1, 1.0, 0.0, 0.0)\\n glRotatef(theta3, 0.0, 0.0, 1.0)\\n matrix = glGetDoublev(GL_MODELVIEW_MATRIX)\\n glPopMatrix()\\n glPopMatrix()\\n return matrix\",\n \"def build_perspective_camera(field_of_view=60.0,\\n aspect_ratio=1.0,\\n near_plane=0.01,\\n far_plane=1000.0,\\n position=(0.0, 0.0, 5.0),\\n enable_zoom=False):\\n context = build_context()\\n camera = context.THREE.PerspectiveCamera.new_object(field_of_view,\\n aspect_ratio, near_plane,\\n far_plane)\\n camera.position.set(*position)\\n controls = context.THREE.OrbitControls.new_object(camera)\\n controls.enableZoom = enable_zoom\\n return camera\",\n \"def projection_matrix(self):\\n scene = self.figure.scene\\n scene_size = tuple(scene.get_size())\\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\\n p = scene.camera.get_perspective_transform_matrix(\\n aspect_ratio, -1, 1).to_array().astype(np.float32)\\n return p\",\n \"def orthographic_matrix(self) -> TransformationMatrixType:\\n near, far = self._clipping[self.projection_mode.value]\\n return orthographic_matrix(self.fov, self.aspect_ratio, near, far)\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def read_camera(self):\\n _, frame = self.camera.read()\\n return self.mirror(frame)\",\n \"def perspectiveNormalizationXform(self):\\n return np.array([[1.0/np.tan(self.view_angle_h), 0, 0, 0],\\n [0, 1.0/np.tan(self.view_angle_v), 0, 0],\\n [0, 0, (self.far + self.near)/(self.far - self.near),\\n 2*self.far*self.near/(self.far - self.near)],\\n [0, 0, -1, 0]])\",\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 camera(*args, aspectRatio: Union[float, bool]=0.0, cameraScale: Union[float, bool]=0.0,\\n centerOfInterest: Union[float, bool]=0.0, clippingPlanes: bool=True, depthOfField:\\n bool=True, displayFieldChart: bool=True, displayFilmGate: bool=True,\\n displayFilmOrigin: bool=True, displayFilmPivot: bool=True, displayGateMask:\\n bool=True, displayResolution: bool=True, displaySafeAction: bool=True,\\n displaySafeTitle: bool=True, fStop: Union[float, bool]=0.0, farClipPlane:\\n Union[float, bool]=0.0, farFocusDistance: Union[float, bool]=0.0, filmFit:\\n Union[AnyStr, bool]=\\\"\\\", filmFitOffset: Union[float, bool]=0.0, filmRollOrder:\\n Union[AnyStr, bool]=\\\"\\\", filmRollValue: Union[float, bool]=0.0, filmTranslateH:\\n Union[float, bool]=0.0, filmTranslateV: Union[float, bool]=0.0, focalLength:\\n Union[float, bool]=0.0, focusDistance: Union[float, bool]=0.0, homeCommand:\\n Union[AnyStr, bool]=\\\"\\\", horizontalFieldOfView: Union[float, bool]=0.0,\\n horizontalFilmAperture: Union[float, bool]=0.0, horizontalFilmOffset: Union[float,\\n bool]=0.0, horizontalPan: Union[float, bool]=0.0, horizontalRollPivot: Union[float,\\n bool]=0.0, horizontalShake: Union[float, bool]=0.0, journalCommand: bool=True,\\n lensSqueezeRatio: Union[float, bool]=0.0, lockTransform: bool=True, motionBlur:\\n bool=True, name: Union[AnyStr, bool]=\\\"\\\", nearClipPlane: Union[float, bool]=0.0,\\n nearFocusDistance: Union[float, bool]=0.0, orthographic: bool=True,\\n orthographicWidth: Union[float, bool]=0.0, overscan: Union[float, bool]=0.0,\\n panZoomEnabled: bool=True, position: Union[List[float, float, float], bool]=None,\\n postScale: Union[float, bool]=0.0, preScale: Union[float, bool]=0.0, renderPanZoom:\\n bool=True, rotation: Union[List[float, float, float], bool]=None, shakeEnabled:\\n bool=True, shakeOverscan: Union[float, bool]=0.0, shakeOverscanEnabled: bool=True,\\n shutterAngle: Union[float, bool]=0.0, startupCamera: bool=True,\\n stereoHorizontalImageTranslate: Union[float, bool]=0.0,\\n stereoHorizontalImageTranslateEnabled: bool=True, verticalFieldOfView: Union[float,\\n bool]=0.0, verticalFilmAperture: Union[float, bool]=0.0, verticalFilmOffset:\\n Union[float, bool]=0.0, verticalLock: bool=True, verticalPan: Union[float, bool]=0.0,\\n verticalRollPivot: Union[float, bool]=0.0, verticalShake: Union[float, bool]=0.0,\\n worldCenterOfInterest: Union[List[float, float, float], bool]=None, worldUp:\\n Union[List[float, float, float], bool]=None, zoom: Union[float, bool]=0.0, q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def _OrthographicMatrix(scale=1.0):\\r\\n from pi3d.Display import Display\\r\\n M = [[0] * 4 for i in range(4)]\\r\\n M[0][0] = 2.0 * scale / Display.INSTANCE.width\\r\\n M[1][1] = 2.0 * scale / Display.INSTANCE.height\\r\\n #M[2][2] = 2.0 / Display.INSTANCE.width\\r\\n M[2][2] = 2.0 / 10000.0\\r\\n M[3][2] = -1\\r\\n M[3][3] = 1\\r\\n return array(M, dtype=float)\",\n \"def matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])\",\n \"def project(points, camera_params):\\n # print(camera_params.shape)\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = 2360*np.ones(camera_params.shape[0])\\n # np.ones()\\n # n = np.sum(points_proj**2, axis=1)\\n r = 1\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\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 camera_frame_directions(self) -> _BFRAME_TYPE:\\n pass\",\n \"def lvlh_matrix(pos, vel):\\n\\n # local vertical, local horizontal frame\\n v_mag = np.sqrt(np.dot(vel, vel))\\n p_mag = np.sqrt(np.dot(pos, pos))\\n\\n cross = np.cross(pos, vel)\\n\\n m_lvlh = np.array([\\n vel/v_mag,\\n cross/(-p_mag*v_mag),\\n pos/(-p_mag)\\n ])\\n\\n return m_lvlh\",\n \"def setBillboardMatrix(self):\\n \\n wolrd_matrix_plug = OpenMaya.MPlug(self.thisObj, self.worldMatrix).elementByLogicalIndex(0)\\n world_matrix = OpenMaya.MFnMatrixData(wolrd_matrix_plug.asMObject()).matrix()\\n float_matrix = self.matrixToFloatMatrix(world_matrix)\\n wolrd_rot_matrix = self.removeMatrixTranslate(float_matrix.inverse())\\n\\n camera_DagPath = OpenMaya.MDagPath()\\n self.view.getCamera(camera_DagPath)\\n camera_matrix = self.matrixToFloatMatrix(camera_DagPath.inclusiveMatrix())\\n camera_rot_matrix = self.removeMatrixTranslate(camera_matrix)\\n \\n mult_matrix = camera_rot_matrix * wolrd_rot_matrix\\n mult_float_matrix = self.matrixToFloatMatrix(mult_matrix)\\n \\n # set matrix\\n float16_ptr = self.floatArrayToPrt(mult_float_matrix)\\n glFT.glMultMatrixf(float16_ptr)\\n \\n # set scale\\n sX, sY, sZ = self.getScale()\\n glFT.glScalef(sX, sY, sZ)\",\n \"def cameraToWorld(self, p):\\n result = self.camPos\\n result += p[2] * self.camZ # result is now in the middle of the view-plane\\n result += p[0] * self.camX # result is now in the middle-left of the view-plane\\n result += p[1] * self.camY # result is now the world-space equivalent of p\\n return result\",\n \"def cal_L(self):\\n # calculate the l matrix\\n self.point_matrixs = self.point_matrix.reshape(\\n self.point_matrix.shape[0], 1, self.point_matrix.shape[1])\\n self.point_matrixs = np.tile(self.point_matrixs,\\n (self.attach_points.shape[0], 1))\\n self.attach_points_matrix = np.matlib.repmat(\\n self.attach_points[:, 0:3], self.point_matrix.shape[0], 1)\\n self.attach_points_matrix = self.attach_points_matrix.reshape(\\n self.point_matrix.shape[0], self.attach_points.shape[0], 3)\\n self.L = np.subtract(self.attach_points_matrix,\\n self.point_matrixs)\\n # self.L[:,self.attach_points[:,3]==1,:] = \\\\\\n # - self.L[:,self.attach_points[:,3]==1,:]\\n # print(self.L)\",\n \"def setCameraMatrix(self, val): # real signature unknown; restored from __doc__\\n pass\",\n \"def _get_rotation_matrix(transform):\\n # caution: UE4 is using left-hand ortation order\\n roll = np.deg2rad(-transform.rotation.roll)\\n pitch = np.deg2rad(-transform.rotation.pitch)\\n yaw = np.deg2rad(transform.rotation.yaw)\\n sr, cr = np.sin(roll), np.cos(roll)\\n sp, cp = np.sin(pitch), np.cos(pitch)\\n sy, cy = np.sin(yaw), np.cos(yaw)\\n rotation_matrix = np.array([[cy * cp, -sy * sr + cy * sp * sr, cy * sp * cr + sy * sr],\\n [sy * cp, cy * sp * sr + cy * sr, -cy * sr + sy * sp * cr],\\n [-sp, cp * sr, cp * cr]])\\n return rotation_matrix\",\n \"def get_matrix(self, transform):\\r\\n\\r\\n rotation = transform.rotation\\r\\n location = transform.location\\r\\n c_y = np.cos(np.radians(rotation.yaw))\\r\\n s_y = np.sin(np.radians(rotation.yaw))\\r\\n c_r = np.cos(np.radians(rotation.roll))\\r\\n s_r = np.sin(np.radians(rotation.roll))\\r\\n c_p = np.cos(np.radians(rotation.pitch))\\r\\n s_p = np.sin(np.radians(rotation.pitch))\\r\\n matrix = np.matrix(np.identity(4))\\r\\n matrix[0, 3] = location.x\\r\\n matrix[1, 3] = location.y\\r\\n matrix[2, 3] = location.z\\r\\n matrix[0, 0] = c_p * c_y\\r\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\r\\n matrix[1, 0] = s_y * c_p\\r\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\r\\n matrix[2, 0] = s_p\\r\\n matrix[2, 1] = -c_p * s_r\\r\\n matrix[2, 2] = c_p * c_r\\r\\n return matrix\",\n \"def getMat3(self):\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n return _mat3(m11,m12,m13,\\r\\n m21,m22,m23,\\r\\n m31,m32,m33)\",\n \"def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\\n img = frame.copy()\\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\\n [0, 0, -grid_size]]).reshape(-1, 3)*2\\n\\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\\n\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\\n R, _ = cv2.Rodrigues(rvecs)\\n # project 3D points onto image plane\\n imgpts, _ = cv2.projectPoints(axis,\\n rvecs, tvecs,\\n K, d)\\n\\n canvas = computer_vision.draw_axis(img, corners, imgpts)\\n return R, tvecs, canvas\",\n \"def resize_lightfield(raw_lightfield, desired_size): # -> lightfield\\n if raw_lightfield.ndim == 6:\\n n_depth, n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for k, depth in enumerate(raw_lightfield):\\n for i, row in enumerate(depth):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[k, i, j] = resized_image_data\\n elif raw_lightfield.ndim == 5:\\n n_cols, n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n\\n for i, row in enumerate(raw_lightfield):\\n for j, image_data in enumerate(row):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[i, j] = resized_image_data\\n \\n elif raw_lightfield.ndim == 4:\\n n_rows, *_ = raw_lightfield.shape\\n output_lightfield = np.empty([n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)\\n\\n for j, image_data in enumerate(raw_lightfield):\\n resized_image_data = cv2.resize(image_data, desired_size)\\n output_lightfield[j] = resized_image_data\\n \\n return output_lightfield\",\n \"def camera_2_world(self, o, d):\\r\\n wo = self.camera2world_point @ ti.Vector([o.x, o.y, o.z, 1.0])\\r\\n wd = self.camera2world_vec @ d\\r\\n return ti.Vector([wo.x,wo.y,wo.z]), wd\",\n \"def generate_depth_map(calib_dir, velo_filename, cam=2, vel_depth=False):\\n # load calibration files\\n cam2cam = read_calib_file(os.path.join(calib_dir, 'calib_cam_to_cam.txt'))\\n velo2cam = read_calib_file(os.path.join(calib_dir, 'calib_velo_to_cam.txt'))\\n velo2cam = np.hstack((velo2cam['R'].reshape(3, 3), velo2cam['T'][..., np.newaxis]))\\n velo2cam = np.vstack((velo2cam, np.array([0, 0, 0, 1.0])))\\n\\n # get image shape\\n im_shape = cam2cam[\\\"S_rect_02\\\"][::-1].astype(np.int32)\\n\\n # compute projection matrix velodyne->image plane\\n R_cam2rect = np.eye(4)\\n R_cam2rect[:3, :3] = cam2cam['R_rect_00'].reshape(3, 3)\\n P_rect = cam2cam['P_rect_0'+str(cam)].reshape(3, 4)\\n P_velo2im = np.dot(np.dot(P_rect, R_cam2rect), velo2cam)\\n\\n # load velodyne points and remove all behind image plane (approximation)\\n # each row of the velodyne data is forward, left, up, reflectance\\n velo = load_velodyne_points(velo_filename)\\n velo = velo[velo[:, 0] >= 0, :]\\n\\n # project the points to the camera\\n velo_pts_im = np.dot(P_velo2im, velo.T).T\\n velo_pts_im[:, :2] = velo_pts_im[:, :2] / velo_pts_im[:, 2][..., np.newaxis]\\n\\n if vel_depth:\\n velo_pts_im[:, 2] = velo[:, 0]\\n\\n # check if in bounds\\n # use minus 1 to get the exact same value as KITTI matlab code\\n velo_pts_im[:, 0] = np.round(velo_pts_im[:, 0]) - 1\\n velo_pts_im[:, 1] = np.round(velo_pts_im[:, 1]) - 1\\n val_inds = (velo_pts_im[:, 0] >= 0) & (velo_pts_im[:, 1] >= 0)\\n val_inds = val_inds & (velo_pts_im[:, 0] < im_shape[1]) & (velo_pts_im[:, 1] < im_shape[0])\\n velo_pts_im = velo_pts_im[val_inds, :]\\n\\n # project to image\\n depth = np.zeros((im_shape[:2]))\\n depth[velo_pts_im[:, 1].astype(np.int), velo_pts_im[:, 0].astype(np.int)] = velo_pts_im[:, 2]\\n\\n # find the duplicate points and choose the closest depth\\n inds = sub2ind(depth.shape, velo_pts_im[:, 1], velo_pts_im[:, 0])\\n dupe_inds = [item for item, count in Counter(inds).items() if count > 1]\\n for dd in dupe_inds:\\n pts = np.where(inds == dd)[0]\\n x_loc = int(velo_pts_im[pts[0], 0])\\n y_loc = int(velo_pts_im[pts[0], 1])\\n depth[y_loc, x_loc] = velo_pts_im[pts, 2].min()\\n depth[depth < 0] = 0\\n\\n return depth\",\n \"def matrix(self):\\n\\t\\t# apply yaw, then pitch, then roll\\n\\t\\treturn Matrix((\\n\\t\\t\\t(\\t1,\\t0,\\t\\t\\t\\t\\t\\t\\t0\\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t0,\\tmath.cos(self.roll.val),\\t-math.sin(self.roll.val)\\t),\\n\\t\\t\\t(\\t0,\\tmath.sin(self.roll.val),\\tmath.cos(self.roll.val)\\t\\t)\\n\\t\\t))* Matrix((\\n\\t\\t\\t(\\tmath.cos(self.pitch.val),\\t0,\\tmath.sin(self.pitch.val)\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t\\t1,\\t0 \\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t-math.sin(self.pitch.val),\\t0,\\tmath.cos(self.pitch.val)\\t)\\n\\t\\t)) * Matrix((\\n\\t\\t\\t(\\tmath.cos(self.yaw.val),\\t-math.sin(self.yaw.val),\\t0\\t),\\n\\t\\t\\t(\\tmath.sin(self.yaw.val),\\tmath.cos(self.yaw.val),\\t\\t0\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t0,\\t\\t\\t\\t\\t\\t\\t1\\t)\\n\\t\\t))\",\n \"def prepare_data(cameras, frame_points_3d, frame_points_2d, keyframe_idx):\\n camera_params = np.empty((0, 9))\\n for c in cameras:\\n R, _ = cv2.Rodrigues(c.R_mat)\\n camera = build_camera(R, c.t)\\n camera_params = np.append(camera_params, [camera], axis=0)\\n\\n camera_indices = []\\n point_indices = []\\n points_2d = np.empty((0, 2))\\n points_3d = np.empty((0, 3))\\n\\n camera_id = 0\\n pt_id_counter = 0\\n for k, pts_2d in enumerate(frame_points_2d):\\n if k > 0:\\n halfway_idx = keyframe_idx[k] - keyframe_idx[k - 1] - 1\\n points_2d = np.vstack((points_2d, frame_points_2d[k-1][halfway_idx]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k-1][halfway_idx]))\\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-1][halfway_idx]))]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-1][halfway_idx]))]\\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-1][halfway_idx])\\n\\n if k > 1:\\n end_idx = keyframe_idx[k + 1] - keyframe_idx[k - 1] - 3\\n points_2d = np.vstack((points_2d, frame_points_2d[k-2][end_idx]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k-2][end_idx]))\\n camera_indices += [camera_id for _ in range(len(frame_points_2d[k-2][end_idx]))]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + len(frame_points_2d[k-2][end_idx]))]\\n pt_id_counter = pt_id_counter + len(frame_points_2d[k-2][end_idx])\\n\\n points_2d = np.vstack((points_2d, frame_points_2d[k][0]))\\n points_3d = np.vstack((points_3d, frame_points_3d[k][0]))\\n camera_indices += [camera_id for _ in range(pts_2d.shape[1])]\\n point_indices += [i for i in range(pt_id_counter, pt_id_counter + pts_2d.shape[1])]\\n\\n camera_id += 1\\n pt_id_counter = pt_id_counter + pts_2d.shape[1]\\n\\n return camera_params, np.asarray(camera_indices), np.asarray(point_indices), points_3d, points_2d\",\n \"def create_matrices(self):\\n debut = time.process_time()\\n\\n x = np.arange(0, self.axe_X)\\n y = np.arange(0, self.axe_Y)\\n xv, yv = np.meshgrid(x, y)\\n\\n print(\\\"\\\\nmatrix creation estimation time: %.1fs\\\" % (1e-6*self.axe_X*self.axe_Y))\\n\\n img_matrix_x, img_matrix_y = self.find_position(xv, yv)\\n\\n fin = time.process_time()\\n print(\\\"matrix created in time: %.1f s\\\" % (fin-debut))\\n return img_matrix_x, img_matrix_y\",\n \"def LV_Matrices(self):\\n self.LV_inhM = self.LotkaVolterra_InhibitMatrix() # (nF, nF)\\n self.LV_c, self.LV_s = self.LotkaVolterra_Dynamics() # (nS, 1)\\n # TODO: The LV weights are incredibly slow...\\n # self.LV_W = self.LotkaVolterra_Weights2()\",\n \"def encode_landm(matched, priors, variances):\\n matched = torch.reshape(matched, (matched.size(0), 4, 2))\\n priors_cx = priors[:, 0].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\\n priors_cy = priors[:, 1].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\\n priors_w = priors[:, 2].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\\n priors_h = priors[:, 3].unsqueeze(1).expand(matched.size(0), 4).unsqueeze(2)\\n priors = torch.cat([priors_cx, priors_cy, priors_w, priors_h], dim=2)\\n g_cxcy = matched[:, :, :2] - priors[:, :, :2]\\n g_cxcy /= variances[0] * priors[:, :, 2:]\\n g_cxcy = g_cxcy.reshape(g_cxcy.size(0), -1)\\n return g_cxcy\",\n \"def main():\\n doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document\\n keymod = GetKeyMod() # Get keymodifier\\n selected = doc.GetActiveObjects(0) # Get selected objects\\n cameras = [] # Collect cameras to an array\\n doc.StartUndo() # Start recording undos\\n # Collect cameras and do preparation operations\\n for s in selected: # Iterate through objects\\n if (s.GetType() == 5103) or (s.GetType() == 1057516): # If object is a camera object (standard C4D camera or Redshift camera)\\n if s.GetType() == 5103: # If standard C4D camera\\n dummyCam = DummyStandardCamera(s, doc) # Dummy camera\\n dataVault = GetDataVault(5103) # Get corresponding data vault\\n elif s.GetType() == 1057516: # If RS camera\\n dummyCam = DummyRedshiftCamera(s, doc) # Dummy camera\\n dataVault = GetDataVault(1057516) # Get corresponding data vault\\n bakeCam = dummyCam.GetClone() # Bake camera\\n name = s.GetName() # Get camera's name\\n bakeCam.SetName(name+suffix) # Set baked camera's name\\n doc.InsertObject(bakeCam) # Insert camera to document\\n doc.AddUndo(c4d.UNDOTYPE_NEW, bakeCam) # Add undo command for creating a new object\\n MoveToLast(bakeCam, doc) # Move object to last\\n RemoveTags(bakeCam) # Remove tags of the object\\n cameras.append([s, dummyCam, bakeCam, dataVault]) # Original camera, dummy camera, camera to bake\\n\\n doc.ExecutePasses(None, True, True, True, 0) # Animate the current frame of the document\\n Bake(cameras) # Bake the camera (standard C4D camera)\\n CleanKeys(cameras) # Clean keyframes\\n\\n # Remove dummy cameras\\n for i in range(0, len(cameras)):\\n cameras[i][1].Remove() # Delete Dummy camera(s)\\n\\n # Sort baked cameras\\n for i in reversed(range(0, len(cameras))):\\n MoveToFirst(cameras[i][2], doc) # Move camera to top of the hierarchy list\\n\\n #if keymod == \\\"Shift\\\":\\n # CopyRendererTags(s, bakeCam) # Copies renderer tags from source camera to bake camera\\n\\n doc.EndUndo() # Stop recording undos\\n c4d.EventAdd() # Refresh Cinema 4D\\n c4d.StatusClear() # Clear status\",\n \"def perspective_projection(points, rotation, translation, focal_length, camera_center):\\n batch_size = points.shape[0]\\n K = torch.zeros([batch_size, 3, 3], device=points.device)\\n K[:, 0, 0] = focal_length\\n K[:, 1, 1] = focal_length\\n K[:, 2, 2] = 1.0\\n K[:, :-1, -1] = camera_center\\n points = torch.einsum('bij,bkj->bki', rotation, points)\\n points = points + translation.unsqueeze(1)\\n projected_points = points / points[:, :, -1].unsqueeze(-1)\\n projected_points = torch.einsum('bij,bkj->bki', K, projected_points)\\n projected_points = projected_points[:, :, :-1]\\n return projected_points\",\n \"def show_planes(im, spacing=10): # pragma: no cover\\n s = spacing\\n if np.squeeze(im.ndim) < 3:\\n raise Exception('This view is only necessary for 3D images')\\n x, y, z = (np.array(im.shape)/2).astype(int)\\n im_xy = im[:, :, z]\\n im_xz = im[:, y, :]\\n im_yz = np.rot90(im[x, :, :])\\n\\n new_x = im_xy.shape[0] + im_yz.shape[0] + s\\n\\n new_y = im_xy.shape[1] + im_xz.shape[1] + s\\n\\n new_im = np.zeros([new_x + 2*s, new_y + 2*s], dtype=im.dtype)\\n\\n # Add xy image to upper left corner\\n new_im[s:im_xy.shape[0] + s,\\n s:im_xy.shape[1] + s] = im_xy\\n # Add xz image to lower left coner\\n x_off = im_xy.shape[0] + 2*s\\n y_off = im_xy.shape[1] + 2*s\\n new_im[s:s + im_xz.shape[0],\\n y_off:y_off + im_xz.shape[1]] = im_xz\\n new_im[x_off:x_off + im_yz.shape[0],\\n s:s + im_yz.shape[1]] = im_yz\\n\\n return new_im\",\n \"def matrix4_to_3x4_array(mat):\\r\\n return tuple(f for v in mat[0:3] for f in v)\",\n \"def fun(params,n_cameras,n_points,camera_indices,point_indices,points_3d , points_2d):\\n camera_params = params[:n_cameras * 6].reshape((n_cameras, 6))\\n # points_3d = points_3d.T\\n # points_3d = params[n_cameras * 7:].reshape((n_points, 3))\\n # print(point_indices)\\n points_proj = project(points_3d[point_indices], camera_params[camera_indices])\\n return (points_proj - points_2d).ravel()\",\n \"def lfread(path, ang=7):\\n lenslet = cv2.imread(path)\\n h, w, c = lenslet.shape\\n lf = np.zeros((ang, ang, c, h // ang, w // ang), dtype=np.uint8)\\n\\n for idx in range(ang ** 2):\\n q = idx // ang\\n p = idx % ang\\n lf[q, p, :, :, :] = lenslet[q::ang, p::ang, :].transpose(2, 0, 1)\\n\\n del lenslet\\n return lf\",\n \"def getInverseMatrix(self) -> CMatrix4:\\n ...\",\n \"def m(self) -> np.ndarray:\\n assert self._k is not None and self._r is not None and self._t is not None, \\\"camera must be calibrated\\\"\\n return forge_projective_matrix(self._k, r=self._r, t=self._t)\",\n \"def forward(self, x, fm, camera_mat):\\n\\n batch_size = x.shape[0]\\n # List of initial 3D coordinates (first item) and outputs of the layers\\n out = list()\\n\\n initial_coordinates_expanded = self.initial_coordinates.expand(\\n batch_size, -1, -1)\\n out.append(initial_coordinates_expanded)\\n \\n # #######################\\n # First Projection Block\\n # Layer 0: 156 x feat_dim\\n out.append(self.gp(initial_coordinates_expanded, fm, camera_mat))\\n out.append(self.gc1(out[-1])) # Layer 1: 156 x hidden_dim\\n for i in range(0, 12): # GraphConvs from and to 156 x hidden_dim\\n val = self.gc2[i](out[-1])\\n if (i % 2) == 1:\\n # Add previous output (Restnet style)\\n val = torch.add(val, out[-2]) * 0.5\\n out.append(val)\\n # Layer 14: Out of dim 156x3, will be used as outputs_2[1]\\n out.append(self.gc3(out[-1]))\\n\\n # #######################\\n # Second Projection Block\\n # Layer 15: 156 x (hidden_dim + feat_dim)\\n v = self.gp(out[-1], fm, camera_mat)\\n v = torch.cat([v, out[-2]], dim=2)\\n out.append(v)\\n # Layer 16: 618x (hidden_dim + feat_dim)\\n out.append(self.gup1(out[-1]))\\n out.append(self.gc4(out[-1])) # Layer 17: 618 x hidden_dim\\n for i in range(0, 12): # GraphConvs from and to 618 x hidden_dim\\n val = self.gc5[i](out[-1])\\n if (i % 2) == 1:\\n # Add previous output (Restnet style)\\n val = torch.add(val, out[-2]) * 0.5\\n out.append(val)\\n # Layer 30: 618 x 3, will be used as outputs_2[2]\\n out.append(self.gc6(out[-1]))\\n\\n # #######################\\n # Third Projection Block\\n # Layer 31: 618 x hidden_dim + feat_dim\\n v = self.gp(out[-1], fm, camera_mat) # 618 x feat_dim\\n v = torch.cat([v, out[-2]], dim=2)\\n out.append(v)\\n # Layer 32: 2466 x hidden_dim + feat_dim\\n out.append(self.gup2(out[-1]))\\n out.append(self.gc7(out[-1])) # Layer 33: 2466 x hidden_dim\\n for i in range(0, 13): # GraphConvs from and to 2466 x hidden_dim\\n val = self.gc8[i](out[-1])\\n if i % 2 == 1:\\n # Add previous output (Restnet style)\\n val = torch.add(val, out[-2]) * 0.5\\n out.append(val)\\n out.append(self.gc9(out[-1])) # Layer 47: 2466 x 3\\n # 156 x hidden_dim, 618 x hidden_dim, 2466 x hidden_dim\\n outputs = (out[15], out[31], out[-1])\\n outputs_2 = (initial_coordinates_expanded,\\n self.gup1(out[15]), self.gup2(out[31]))\\n\\n return outputs, outputs_2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5941741","0.5775757","0.5662558","0.5599011","0.5386134","0.5304439","0.52797616","0.5268123","0.5224661","0.5198523","0.5161968","0.5151681","0.51350677","0.51214856","0.50689846","0.5061132","0.5058804","0.504136","0.50070995","0.5004285","0.4988299","0.49855465","0.4981803","0.49737483","0.49581927","0.49475425","0.49424782","0.49260002","0.4925581","0.49217582","0.49181974","0.4912475","0.49122405","0.49045095","0.4902439","0.48752055","0.48316023","0.4829647","0.48086128","0.4800789","0.47978526","0.47954947","0.4779499","0.4767175","0.4767109","0.47646788","0.47529197","0.4745887","0.47377503","0.47356638","0.4735461","0.47255722","0.4713891","0.47066292","0.47062317","0.46851224","0.46837473","0.4670715","0.46642873","0.46630797","0.46600306","0.46579126","0.4641004","0.46406296","0.46336251","0.46336251","0.46249914","0.4622718","0.46125096","0.4589231","0.45885006","0.45827207","0.45802602","0.4572999","0.45708838","0.45638895","0.45570263","0.4556316","0.45540464","0.4553075","0.4551368","0.45434758","0.45391655","0.45320222","0.4531609","0.45304102","0.45303524","0.45300615","0.4529027","0.45254463","0.45184928","0.45157817","0.450402","0.449568","0.44956073","0.44947833","0.44923747","0.4481258","0.44779754","0.44748792","0.44724622"],"string":"[\n \"0.5941741\",\n \"0.5775757\",\n \"0.5662558\",\n \"0.5599011\",\n \"0.5386134\",\n \"0.5304439\",\n \"0.52797616\",\n \"0.5268123\",\n \"0.5224661\",\n \"0.5198523\",\n \"0.5161968\",\n \"0.5151681\",\n \"0.51350677\",\n \"0.51214856\",\n \"0.50689846\",\n \"0.5061132\",\n \"0.5058804\",\n \"0.504136\",\n \"0.50070995\",\n \"0.5004285\",\n \"0.4988299\",\n \"0.49855465\",\n \"0.4981803\",\n \"0.49737483\",\n \"0.49581927\",\n \"0.49475425\",\n \"0.49424782\",\n \"0.49260002\",\n \"0.4925581\",\n \"0.49217582\",\n \"0.49181974\",\n \"0.4912475\",\n \"0.49122405\",\n \"0.49045095\",\n \"0.4902439\",\n \"0.48752055\",\n \"0.48316023\",\n \"0.4829647\",\n \"0.48086128\",\n \"0.4800789\",\n \"0.47978526\",\n \"0.47954947\",\n \"0.4779499\",\n \"0.4767175\",\n \"0.4767109\",\n \"0.47646788\",\n \"0.47529197\",\n \"0.4745887\",\n \"0.47377503\",\n \"0.47356638\",\n \"0.4735461\",\n \"0.47255722\",\n \"0.4713891\",\n \"0.47066292\",\n \"0.47062317\",\n \"0.46851224\",\n \"0.46837473\",\n \"0.4670715\",\n \"0.46642873\",\n \"0.46630797\",\n \"0.46600306\",\n \"0.46579126\",\n \"0.4641004\",\n \"0.46406296\",\n \"0.46336251\",\n \"0.46336251\",\n \"0.46249914\",\n \"0.4622718\",\n \"0.46125096\",\n \"0.4589231\",\n \"0.45885006\",\n \"0.45827207\",\n \"0.45802602\",\n \"0.4572999\",\n \"0.45708838\",\n \"0.45638895\",\n \"0.45570263\",\n \"0.4556316\",\n \"0.45540464\",\n \"0.4553075\",\n \"0.4551368\",\n \"0.45434758\",\n \"0.45391655\",\n \"0.45320222\",\n \"0.4531609\",\n \"0.45304102\",\n \"0.45303524\",\n \"0.45300615\",\n \"0.4529027\",\n \"0.45254463\",\n \"0.45184928\",\n \"0.45157817\",\n \"0.450402\",\n \"0.449568\",\n \"0.44956073\",\n \"0.44947833\",\n \"0.44923747\",\n \"0.4481258\",\n \"0.44779754\",\n \"0.44748792\",\n \"0.44724622\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84688,"cells":{"query":{"kind":"string","value":"Computes a righthanded 4x4 lookat camera matrix."},"document":{"kind":"string","value":"def look_at_rh(eye: InputTensor, center: InputTensor,\n up: InputTensor) -> t.Tensor:\n eye = util.to_tensor(eye, dtype=t.float32)\n center = util.to_tensor(center, dtype=t.float32)\n up = util.to_tensor(up, dtype=t.float32)\n assert eye.shape == (3,)\n assert center.shape == (3,)\n assert up.shape == (3,)\n\n f = F.normalize(center - eye, dim=-1)\n s = F.normalize(t.cross(f, up), dim=-1)\n u = t.cross(s, f)\n\n return eye.new_tensor([\n [s[0], s[1], s[2], -t.dot(s, eye)],\n [u[0], u[1], u[2], -t.dot(u, eye)],\n [-f[0], -f[1], -f[2], t.dot(f, eye)],\n [0, 0, 0, 1],\n ], dtype=t.float32)"},"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 getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass","def camera_matrix(self) -> TransformationMatrixType:\n return numpy.matmul(\n self.rotation_matrix(*self.rotation),\n displacement_matrix(*-numpy.array(self.location)),\n )","def camera_matrix(e, p, t):\n # Translates all points such that the camera is centered at the origin.\n T = np.array([[1, 0, 0, -e[0]],\n [0, 1, 0, -e[1]],\n [0, 0, 1, -e[2]],\n [0, 0, 0, 1]])\n\n # Set up orthonormal basis.\n w = e - p\n w = w / np.linalg.norm(w)\n u = np.cross(t, w)\n u = u / np.linalg.norm(u)\n v = np.cross(w, u)\n\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\n R = np.array([[u[0], u[1], u[2], 0],\n [v[0], v[1], v[2], 0],\n [w[0], w[1], w[2], 0],\n [ 0, 0, 0, 1]])\n return R.dot(T)","def intrinsic_matrix_from_camera(w, h, fov):\n (cx, cy), f = calc_focal_values(w, h, fov)\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])","def frustum(self, left, right, bottom, top, near, far):\r\n \r\n return mat4( (2.0*near)/(right-left), 0.0, float(right+left)/(right-left), 0.0,\r\n 0.0, (2.0*near)/(top-bottom), float(top+bottom)/(top-bottom), 0.0,\r\n 0.0, 0.0, -float(far+near)/(far-near), -(2.0*far*near)/(far-near),\r\n 0.0, 0.0, -1.0, 0.0)","def fk4(joint_rotations):\n h0_4 = htm4(joint_rotations)\n x0_4 = h0_4[0, 3]\n y0_4 = h0_4[1, 3]\n z0_4 = h0_4[2, 3]\n d0_4 = [x0_4, y0_4, z0_4]\n return d0_4","def htm4(joint_rotations):\n # H0_3\n h0_3 = htm0_3(joint_rotations)\n\n # H3_4\n r3_4 = rot_z(joint_rotations[3])\n x3_4 = a4 * np.cos(np.radians(joint_rotations[3]))\n y3_4 = a4 * np.sin(np.radians(joint_rotations[3]))\n z3_4 = 0\n d3_4 = transl(x3_4, y3_4, z3_4)\n h3_4 = htm(r3_4, d3_4)\n h0_4 = np.dot(h0_3, h3_4)\n return h0_4","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 __ComputeDesignMatrix_RzRyRz(self, groundPoints):\n # initialization for readability\n azimuth = self.exteriorOrientationParameters[3]\n phi = self.exteriorOrientationParameters[4]\n kappa = self.exteriorOrientationParameters[5]\n\n # Coordinates subtraction\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\n dXYZ = np.vstack([dX, dY, dZ])\n\n rotationMatrixT = self.rotationMatrix_RzRyRz.T\n rotatedG = rotationMatrixT.dot(dXYZ)\n rT1g = rotatedG[0, :]\n rT2g = rotatedG[1, :]\n rT3g = rotatedG[2, :]\n\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\n\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\n\n dgdX0 = np.array([-1, 0, 0], 'f')\n dgdY0 = np.array([0, -1, 0], 'f')\n dgdZ0 = np.array([0, 0, -1], 'f')\n\n # Derivatives with respect to X0\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\n\n # Derivatives with respect to Y0\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\n\n # Derivatives with respect to Z0\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\n\n dRTdOmega = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'azimuth').T\n dRTdPhi = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'phi').T\n dRTdKappa = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'kappa').T\n\n gRT3g = dXYZ * rT3g\n\n # Derivatives with respect to Omega\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Phi\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Kappa\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n # all derivatives of x and y\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\n\n a = np.zeros((2 * dd[0].shape[0], 6))\n a[0::2] = dd[0]\n a[1::2] = dd[1]\n\n return a","def get_projection_matrix(left, right, bottom, top):\r\n zNear = -25.0\r\n zFar = 25.0\r\n inv_z = 1.0 / (zFar - zNear)\r\n inv_y = 1.0 / (top - bottom)\r\n inv_x = 1.0 / (right - left)\r\n mat = [[(2.0 * inv_x), 0.0, 0.0, (-(right + left) * inv_x)],\r\n [0.0, (2.0 * inv_y), 0.0, (-(top + bottom) * inv_y)],\r\n [0.0, 0.0, (-2.0 * inv_z), (-(zFar + zNear) * inv_z)],\r\n [0.0, 0.0, 0.0, 1.0]]\r\n return mat","def get_projection_matrix(K, rvec, tvec):\n R = cv2.Rodrigues(np.float32(rvec))[0]\n Rt = np.zeros((3, 4))\n Rt[:, 0:3] = R\n Rt[:, 3] = tvec\n return K @ Rt","def _ProjectionMatrix(near, far, fov, aspectRatio):\r\n # Matrices are considered to be M[row][col]\r\n # Use DirectX convention, so need to do rowvec*Matrix to transform\r\n size = 1 / tan(radians(fov)/2.0)\r\n M = [[0] * 4 for i in range(4)]\r\n M[0][0] = size/aspectRatio\r\n M[1][1] = size #negative value reflects scene on the Y axis\r\n M[2][2] = (far + near) / (far - near)\r\n M[2][3] = 1\r\n M[3][2] = -(2 * far * near)/(far - near)\r\n return array(M, dtype=float)","def map_to_matrix(x, y):\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\n\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\n\n return x_pos, y_pos","def getMatrix(self) -> CMatrix4:\n ...","def row_matrix_col_4d(a, b, A):\n\n\treturn (a[0]*A[0][0]*b[0] + a[1]*A[1][0]*b[0] + a[2]*A[2][0]*b[0] + a[3]*A[3][0]*b[0] +\n\t a[0]*A[0][1]*b[1] + a[1]*A[1][1]*b[1] + a[2]*A[2][1]*b[1] + a[3]*A[3][1]*b[1] +\n\t a[0]*A[0][2]*b[2] + a[1]*A[1][2]*b[2] + a[2]*A[2][2]*b[2] + a[3]*A[3][2]*b[2] +\n\t a[0]*A[0][3]*b[3] + a[1]*A[1][3]*b[3] + a[2]*A[2][3]*b[3] + a[3]*A[3][3]*b[3])","def matrix(self):\n m = Matrix.identity(4, 4)\n\n m[:3, :3] = self.rotation.matrix.data\n m[:3, 3:4] = self.translation.matrix.data\n\n return m","def set_camera(self, width, height):\n rightt = self.mat[:3, 0]\n upt = self.mat[:3, 1]\n pt = self.mat[:3, 2] * self.d\n t = self.mat[:3, 3]\n\n self.proj_mat = create_perspective_projection_matrix(np.radians(self.fov), 1. * width / height, self.near, self.far)\n gr3.setcameraprojectionparameters(self.fov, self.near, self.far)\n self.lookat_mat = create_look_at_matrix(pt + t, t, upt)\n gr3.cameralookat(pt[0] + t[0], pt[1] + t[1], pt[2] + t[2], t[0], t[1], t[2], upt[0], upt[1], upt[2])","def _calculate_camera_array(self):\n look_list = []\n\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\n col_step_vec = self._get_look_right() * self.interspatial_distance\n\n # Start at the top left camera position\n for i in range(self.spatial_rows):\n row_movement = row_step_vec * (-i)\n row_look_from = self.look_from + row_movement\n row_look_to = self.look_to + row_movement\n\n for j in range(self.spatial_cols):\n col_movement = col_step_vec * j\n cam_look_from = row_look_from + col_movement\n cam_look_to = row_look_to + col_movement\n\n look_list.append((cam_look_from, cam_look_to))\n\n return look_list","def __ComputeDesignMatrix(self, groundPoints):\n # initialization for readability\n omega = self.exteriorOrientationParameters[3]\n phi = self.exteriorOrientationParameters[4]\n kappa = self.exteriorOrientationParameters[5]\n\n # Coordinates subtraction\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\n dXYZ = np.vstack([dX, dY, dZ])\n\n rotationMatrixT = self.rotationMatrix.T\n rotatedG = rotationMatrixT.dot(dXYZ)\n rT1g = rotatedG[0, :]\n rT2g = rotatedG[1, :]\n rT3g = rotatedG[2, :]\n\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\n\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\n\n dgdX0 = np.array([-1, 0, 0], 'f')\n dgdY0 = np.array([0, -1, 0], 'f')\n dgdZ0 = np.array([0, 0, -1], 'f')\n\n # Derivatives with respect to X0\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\n\n # Derivatives with respect to Y0\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\n\n # Derivatives with respect to Z0\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\n\n dRTdOmega = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'omega').T\n dRTdPhi = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'phi').T\n dRTdKappa = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'kappa').T\n\n gRT3g = dXYZ * rT3g\n\n # Derivatives with respect to Omega\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Phi\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\n\n # Derivatives with respect to Kappa\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\n\n # all derivatives of x and y\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\n\n a = np.zeros((2 * dd[0].shape[0], 6))\n a[0::2] = dd[0]\n a[1::2] = dd[1]\n\n return a","def modelview_matrix(self):\n camera = self.figure.scene.camera\n return camera.view_transform_matrix.to_array().astype(np.float32)","def perspective_transform():\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\n M = cv2.getPerspectiveTransform(src, dst)\n Minv = cv2.getPerspectiveTransform(dst, src)\n\n return M, Minv","def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\n\n if phi is None:\n phi = const.PHI_IDX * 10.0\n\n #extrinsic x intrinsic\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\n\n intrinsic_matrix = np.eye(4, dtype=np.float32)\n extrinsic_matrix = np.eye(4, dtype=np.float32)\n\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\n\n #theta rotation\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\n rotation_azimuth[0, 0] = cos_theta\n rotation_azimuth[2, 2] = cos_theta\n rotation_azimuth[0, 2] = -sin_theta\n rotation_azimuth[2, 0] = sin_theta\n rotation_azimuth[1, 1] = 1.0\n\n #phi rotation\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\n rotation_elevation[0, 0] = cos_phi\n rotation_elevation[0, 1] = sin_phi\n rotation_elevation[1, 0] = -sin_phi\n rotation_elevation[1, 1] = cos_phi\n rotation_elevation[2, 2] = 1.0\n\n #rotate phi, then theta\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\n if invert_rot:\n rotation_matrix = np.linalg.inv(rotation_matrix)\n\n displacement = np.zeros((3, 1), dtype=np.float32)\n displacement[0, 0] = const.DIST_TO_CAM\n displacement = np.matmul(rotation_matrix, displacement)\n\n #assembling 4x4 from R + T\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\n extrinsic_matrix[0:3, 3:4] = -displacement\n\n if invert_focal:\n intrinsic_matrix[2, 2] = float(const.focal_length)\n intrinsic_matrix[1, 1] = float(const.focal_length)\n else:\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\n\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\n return camera_matrix","def camera_transform(image):\n img = np.zeros((image.shape[0], image.shape[1], 3))\n for y in range(image.shape[0]):\n for x in range(image.shape[1]):\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\n y, x]\n return img","def _mat3(self):\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\n return np.identity(3)\n else:\n return self.QSW2TNW","def ortho(self):\r\n\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n\r\n x = _vec3(m11, m21, m31)\r\n y = _vec3(m12, m22, m32)\r\n z = _vec3(m13, m23, m33)\r\n\r\n xl = x.length()\r\n xl*=xl\r\n y = y - ((x*y)/xl)*x\r\n z = z - ((x*z)/xl)*x\r\n\r\n yl = y.length()\r\n yl*=yl\r\n z = z - ((y*z)/yl)*y\r\n\r\n return mat4( x.x, y.x, z.x, m14,\r\n x.y, y.y, z.y, m24,\r\n x.z, y.z, z.z, m34,\r\n m41, m42, m43, m44)","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n\n origin = np.array([location.x, location.y, location.z])\n return matrix, origin","def _LookAtMatrix(at, eye, up=[0, 1, 0], reflect=False):\r\n # If reflect, then reflect in plane -20.0 (water depth)\r\n if reflect:\r\n depth = -20.0 # Shallower to avoid edge effects\r\n eye = [eye[0], -eye[1], eye[2]]\r\n at = [at[0], -at[1], at[2]]\r\n zaxis = vec_normal(vec_sub(at, eye))\r\n xaxis = vec_normal(vec_cross(up, zaxis))\r\n yaxis = vec_cross(zaxis, xaxis)\r\n xaxis.append(-vec_dot(xaxis, eye))\r\n yaxis.append(-vec_dot(yaxis, eye))\r\n zaxis.append(-vec_dot(zaxis, eye))\r\n z = [0, 0, 0, 1.0]\r\n return array([[xaxis[a], yaxis[a], zaxis[a], z[a]] for a in range(4)],\r\n dtype=float)","def build_camera(R, t):\n camera = R.flatten()\n camera = np.append(camera, t.flatten())\n camera = np.append(camera, K[0][0])\n camera = np.append(camera, dist[0, 0:2].flatten())\n return camera","def computeMVP(self):\n projMat = self.converterYUR\n modelViewMat = self.transforMat.invertCompose(\n Globals.render.getTransform(self.cameraNode)).getMat()\n return UnalignedLMatrix4f(modelViewMat * projMat)","def quatRightMat(q):\n\ts = q[0]\n\tv = q[1:].reshape(-1,)\n\tR = np.zeros((4, 4))\n\tR[0, 0] = s\n\tR[0, 1:] = -v\n\tR[1:, 0] = v\n\tR[1:, 1:] = s*np.eye(3) - skewMat(v)\n\treturn R","def perspectiveFovLH(field_of_view, aspect, znear, zfar):\n h = 1 / tan(field_of_view / 2)\n w = h / aspect\n m = [\n [w, 0, 0, 0],\n [0, h, 0, 0],\n [0, 0, zfar / (zfar - znear), 1],\n [0, 0, (znear * zfar) / (znear - zfar), 0],\n ]\n return Matrix(m)","def perspective_matrix(self) -> TransformationMatrixType:\n z_near, z_far = self._clipping[self.projection_mode.value]\n return perspective_matrix(\n math.radians(self.fov), self.aspect_ratio, z_near, z_far\n )","def getDejaVuMatrix(self):\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\n mtx[3] = self.getTranslation()\n mtx[:3, 3] = mtx[3, :3]\n mtx[3, :3] = [0, 0, 0]\n return mtx","def bloch_matrix(self):\n if self.gf_r is None:\n self.gf()\n\n return -self.gf_r.dot(self.lead[1])","def m(self) -> np.ndarray:\n assert self._k is not None and self._r is not None and self._t is not None, \"camera must be calibrated\"\n return forge_projective_matrix(self._k, r=self._r, t=self._t)","def create_cam2world_matrix(forward_vector,\n origin,\n device=None):\n \"\"\"\"\"\"\n\n forward_vector = normalize_vecs(forward_vector)\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\n .expand_as(forward_vector)\n\n left_vector = normalize_vecs(\n torch.cross(up_vector,\n forward_vector,\n dim=-1))\n\n up_vector = normalize_vecs(\n torch.cross(forward_vector,\n left_vector,\n dim=-1))\n\n rotation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n rotation_matrix[:, :3, :3] = torch.stack(\n (-left_vector, up_vector, -forward_vector), axis=-1)\n\n translation_matrix = torch.eye(4, device=device) \\\n .unsqueeze(0) \\\n .repeat(forward_vector.shape[0], 1, 1)\n translation_matrix[:, :3, 3] = origin\n\n cam2world = translation_matrix @ rotation_matrix\n\n return cam2world","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def get_matrix(transform):\n\n rotation = transform.rotation\n location = transform.location\n c_y = np.cos(np.radians(rotation.yaw))\n s_y = np.sin(np.radians(rotation.yaw))\n c_r = np.cos(np.radians(rotation.roll))\n s_r = np.sin(np.radians(rotation.roll))\n c_p = np.cos(np.radians(rotation.pitch))\n s_p = np.sin(np.radians(rotation.pitch))\n matrix = np.matrix(np.identity(4))\n matrix[0, 3] = location.x\n matrix[1, 3] = location.y\n matrix[2, 3] = location.z\n matrix[0, 0] = c_p * c_y\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\n matrix[1, 0] = s_y * c_p\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\n matrix[2, 0] = s_p\n matrix[2, 1] = -c_p * s_r\n matrix[2, 2] = c_p * c_r\n return matrix","def pixel2cam(self, depth, intrinsics_inv):\n b, _, h, w = depth.size()\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\n ones = torch.ones(1,h,w).type_as(depth)\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\n return cam_coords * depth","def test_RawRun_perspective_reference_old_style():\n ref = (0, 0)\n m = config.ideal_m\n grid = r.perspective_reference(ref, 'old', 'cam1')\n lower_right, upper_right, lower_left, upper_left = grid\n assert_equal((0, 0), lower_right)\n assert_equal((ref[0] - int(1.47 * m), ref[1] - int(0.25 * m)), upper_left)","def get_matrix(self, transform):\r\n\r\n rotation = transform.rotation\r\n location = transform.location\r\n c_y = np.cos(np.radians(rotation.yaw))\r\n s_y = np.sin(np.radians(rotation.yaw))\r\n c_r = np.cos(np.radians(rotation.roll))\r\n s_r = np.sin(np.radians(rotation.roll))\r\n c_p = np.cos(np.radians(rotation.pitch))\r\n s_p = np.sin(np.radians(rotation.pitch))\r\n matrix = np.matrix(np.identity(4))\r\n matrix[0, 3] = location.x\r\n matrix[1, 3] = location.y\r\n matrix[2, 3] = location.z\r\n matrix[0, 0] = c_p * c_y\r\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\r\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\r\n matrix[1, 0] = s_y * c_p\r\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\r\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\r\n matrix[2, 0] = s_p\r\n matrix[2, 1] = -c_p * s_r\r\n matrix[2, 2] = c_p * c_r\r\n return matrix","def projection_matrix(self):\n scene = self.figure.scene\n scene_size = tuple(scene.get_size())\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\n p = scene.camera.get_perspective_transform_matrix(\n aspect_ratio, -1, 1).to_array().astype(np.float32)\n return p","def rotation_matrix(yaw, pitch) -> TransformationMatrixType:\n return rotation_matrix_yx(math.radians(yaw + 180), math.radians(pitch))","def read_camera(self):\n _, frame = self.camera.read()\n return self.mirror(frame)","def compute_projection_matrix(width,\n height,\n f_x,\n f_y,\n c_x,\n c_y,\n near,\n far):\n # pylint: disable=line-too-long\n matrix = vtk.vtkMatrix4x4()\n matrix.Zero()\n matrix.SetElement(0, 0, 2*f_x/width)\n matrix.SetElement(0, 1, -2*0/width) # Not doing skew, so this will be 0.\n matrix.SetElement(0, 2, (width - 2*c_x)/width)\n matrix.SetElement(1, 1, 2*f_y/height)\n matrix.SetElement(1, 2, (-height + 2*c_y)/height)\n matrix.SetElement(2, 2, (-far-near)/(far-near))\n matrix.SetElement(2, 3, -2*far*near/(far-near))\n matrix.SetElement(3, 2, -1)\n return matrix","def _embed44(matrix):\n result = np.eye(4)\n r, c = matrix.shape\n result[:r, :c] = matrix\n return result","def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\n img = frame.copy()\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\n [0, 0, -grid_size]]).reshape(-1, 3)*2\n\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\n\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\n R, _ = cv2.Rodrigues(rvecs)\n # project 3D points onto image plane\n imgpts, _ = cv2.projectPoints(axis,\n rvecs, tvecs,\n K, d)\n\n canvas = computer_vision.draw_axis(img, corners, imgpts)\n return R, tvecs, canvas","def camera_frame_directions(self) -> _BFRAME_TYPE:\n pass","def set_modelview_from_camera(Rt):\n \n glMatrixMode(GL_MODELVIEW)\n glLoadIdentity()\n \n # rotate teapot 90 deg around x-axis so that z-axis is up\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\n \n # set rotation to best approximation\n R = Rt[:,:3]\n U,S,V = np.linalg.svd(R)\n R = np.dot(U,V)\n R[0,:] = -R[0,:] # change sign of x-axis\n \n # set translation\n t = Rt[:,3]\n \n # setup 4*4 model view matrix\n M = np.eye(4)\n M[:3,:3] = np.dot(R,Rx)\n M[:3,3] = t\n\n # transpose and flatten to get column order\n M = M.T\n \n m = M.flatten()\n \n # replace model view with the new matrix\n glLoadMatrixf(m)","def four_point_transform(image, pts):\n\n\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\n\n\tdst = np.array([\n\t\t[0, 0],\n\t\t[image.shape[1] - 1, 0],\n\t\t[image.shape[1] - 1, image.shape[0] - 1],\n\t\t[0, image.shape[0] - 1]], dtype=\"float32\")\n\n\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\n\n\treturn warped","def _derive_transformation_matrices(self):\n\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\n if self._primaries is not None and self._whitepoint is not None:\n npm = normalised_primary_matrix(self._primaries,\n self._whitepoint)\n\n self._derived_RGB_to_XYZ_matrix = npm\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)","def getTransposeMatrix(self) -> CMatrix4:\n ...","def getMatrixFromSkeletonToGeometry(self):\n return _osgAnimation.RigGeometry_getMatrixFromSkeletonToGeometry(self)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[2, 2]=c\n self.matrix[2, 0]=s\n self.matrix[0, 2]=-s\n self.matrix[0, 0]=c\n return self.matrix","def get_frame(cap):\n\n #camera matrix for camera calibration\n mtx = np.array(np.mat(\"588.4525598886621, 0, 301.8008794717551; 0, 588.9763096391521, 242.617026416902; 0, 0, 1\"))\n\n #distrotion coefficients for camera calibration\n dist = np.array(np.mat(\"-0.4351555722591889, 0.2082765081608728, -0.006072767012672472, 0.008139871640987759, 0\"))\n\n #get image frame from the camera\n ret, frame = cap.read()\n\n return frame\n\n h, w = frame.shape[:2]\n\n #get the new optimal camera matrix and the roi which can be used to crop the result\n newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h))\n\n #get the undistroted image\n dst = cv2.undistort(frame, mtx, dist, None, newcameramtx)\n\n x,y,w,h = roi\n\n #get the cropped image\n dst = dst[y:y+h, x:x+w]\n h, w = dst.shape[:2]\n\n #furthur crop the image to reduce the size of arena\n dst = dst[int(h/7):int(h*6/7), int(w/7):int(w*6/7)]\n\n #resize the arena to ARENA_SIZE\n dst = cv2.resize(dst, ARENA_SIZE, interpolation= cv2.INTER_CUBIC)\n\n return dst","def camera_fov_corners(camera_info, zdist, Tcamera=np.eye(4)):\n cam_model = PinholeCameraModel()\n cam_model.fromCameraInfo(camera_info)\n delta_x = cam_model.getDeltaX(cam_model.width/2, zdist)\n delta_y = cam_model.getDeltaY(cam_model.height/2, zdist)\n corners = [Tcamera[:3,3]]\n for k in itertools.product([-1,1],[-1,1]):\n point = np.array([0, 0, zdist, 1])\n point[:2] = np.array([delta_x, delta_y]) * np.array(k)\n corners.append( np.dot(Tcamera, point)[:3] )\n return np.array(corners)","def matrix(self):\n\t\t# apply yaw, then pitch, then roll\n\t\treturn Matrix((\n\t\t\t(\t1,\t0,\t\t\t\t\t\t\t0\t\t\t\t\t\t\t),\n\t\t\t(\t0,\tmath.cos(self.roll.val),\t-math.sin(self.roll.val)\t),\n\t\t\t(\t0,\tmath.sin(self.roll.val),\tmath.cos(self.roll.val)\t\t)\n\t\t))* Matrix((\n\t\t\t(\tmath.cos(self.pitch.val),\t0,\tmath.sin(self.pitch.val)\t),\n\t\t\t(\t0,\t\t\t\t\t\t\t1,\t0 \t\t\t\t\t\t\t),\n\t\t\t(\t-math.sin(self.pitch.val),\t0,\tmath.cos(self.pitch.val)\t)\n\t\t)) * Matrix((\n\t\t\t(\tmath.cos(self.yaw.val),\t-math.sin(self.yaw.val),\t0\t),\n\t\t\t(\tmath.sin(self.yaw.val),\tmath.cos(self.yaw.val),\t\t0\t),\n\t\t\t(\t0,\t\t\t\t\t\t0,\t\t\t\t\t\t\t1\t)\n\t\t))","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 matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])","def rebuildMatrixCache(self):\n self.converterYUR = Mat4.convertMat(CSYupRight, self.lens.getCoordinateSystem()) * self.lens.getProjectionMat()","def get_warp_perspective(transpose_image, h_matrix, dimension):\n warped_image = np.zeros((dimension[0], dimension[1], 3))\n for index1 in range(0, transpose_image.shape[0]):\n for index2 in range(0, transpose_image.shape[1]):\n new_vec = np.dot(h_matrix, [index1, index2, 1])\n new_row, new_col, _ = (new_vec / new_vec[2] + 0.4).astype(int)\n if 5 < new_row < (dimension[0] - 5):\n if 5 < new_col < (dimension[1] - 5):\n warped_image[new_row, new_col] = transpose_image[index1, index2]\n warped_image[new_row - 1, new_col - 1] = transpose_image[index1, index2]\n warped_image[new_row - 2, new_col - 2] = transpose_image[index1, index2]\n warped_image[new_row - 3, new_col - 3] = transpose_image[index1, index2]\n warped_image[new_row + 1, new_col + 1] = transpose_image[index1, index2]\n warped_image[new_row + 2, new_col + 2] = transpose_image[index1, index2]\n warped_image[new_row + 3, new_col + 3] = transpose_image[index1, index2]\n\n return np.array(warped_image, dtype=np.uint8)","def new_mirror(self,alongx,alongy):\n Knew = K.clone()\n if alongx:\n Knew[0,2] = size[0]-Knew[0,2]\n if alongy:\n Knew[1,2] = size[1]-Knew[1,2]\n return CameraInfo(self.size,Knew,self.dist)","def createCamera():\n\n turnCam = cmds.camera()\n lookThruAndFrame(turnCam[0])\n return turnCam","def matrix_math_api_examples():\n \n print(dingbat.vec2())\n print(dingbat.vec2(array.array('f', (20, 40))))\n print(dingbat.mat3())\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\n translate = dingbat.translation_matrix(-10, -20, -30)\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\n scale = dingbat.scale_matrix(100, 200, 300)\n print(translate)\n print(rotate)\n print(scale)\n print(dingbat.multiply_matrices(translate, rotate, scale))","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 screenToCamera(self,x,y):\n #self.x = x\n #self.y = y\n new_x = x / (self.surf.get_width() - 1) - 0.5\n #-(new_x)\n new_y = y / (self.surf.get_height() - 1)\n new_y = (1.0 - cy) - 0.5\n new_z = -self.camNear\n formula = math3dsol.VectorN((new_x,new_y,new_z))\n return formula\n\n # FINISH ME!!!","def decompose_essential_matrix(E, x1, x2):\n\n # Fix left camera-matrix\n Rl = np.eye(3)\n tl = np.array([[0, 0, 0]]).T\n Pl = np.concatenate((Rl, tl), axis=1)\n\n # TODO: Compute possible rotations and translations\n \n # s must be [1, 1, 0]\n u, s, vh = np.linalg.svd(E)\n E = u @ np.diag([1, 1, 0]) @ vh\n u, s, vh = np.linalg.svd(E)\n\n w = np.array([[ 0, 1, 0], \n [-1, 0, 0], \n [ 0, 0, 1]]) \n \n z = np.array([[ 0, -1, 0], \n [ 1, 0, 0],\n [ 0, 0, 0]])\n \n R1 = u @ w.T @ vh\n s1 = -u @ z @ u.T\n R2 = u @ w @ vh\n s2 = u @ z @ u.T\n\n t1 = np.array([[s1[2, 1]], \n [s1[0, 2]],\n [s1[1, 0]]])\n \n t2 = np.array([[s2[2, 1]], \n [s2[0, 2]], \n [s2[1, 0]]]) \n\n # Four possibilities\n Pr = [np.concatenate((R1, t1), axis=1),\n np.concatenate((R1, t2), axis=1),\n np.concatenate((R2, t1), axis=1),\n np.concatenate((R2, t2), axis=1)]\n\n # Compute reconstructions for all possible right camera-matrices\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\n\n # Compute projections on image-planes and find when both cameras see point\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\n range(4)]\n test = np.array(test)\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\n\n # Choose correct matrix\n Pr = Pr[idx]\n\n return Pl, Pr","def project(points, camera_params):\n # print(camera_params.shape)\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = 2360*np.ones(camera_params.shape[0])\n # np.ones()\n # n = np.sum(points_proj**2, axis=1)\n r = 1\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj","def fourPointTransform(image, points):\r\n\r\n topLeft, topRight, bottomLeft, bottomRight = sortFourPoints(points)\r\n\r\n # Determine the maximum width\r\n topWidth = np.sqrt(((topRight[0] - topLeft[0]) ** 2) + ((topRight[1] - topLeft[1]) ** 2))\r\n bottomWidth = np.sqrt(((bottomRight[0] - bottomLeft[0]) ** 2) + ((bottomRight[1] - bottomLeft[1]) ** 2))\r\n width = max(int(topWidth), int(bottomWidth))\r\n\r\n # Determine the maximum height\r\n leftHeight = np.sqrt(((topLeft[0] - bottomLeft[0]) ** 2) + ((topLeft[1] - bottomLeft[1]) ** 2))\r\n rightHeight = np.sqrt(((topRight[0] - bottomRight[0]) ** 2) + ((topRight[1] - bottomRight[1]) ** 2))\r\n height = max(int(leftHeight), int(rightHeight))\r\n\r\n source = np.array([topLeft, topRight, bottomRight, bottomLeft], dtype=\"float32\")\r\n\r\n destination = np.array([[0, 0],\r\n [width - 1, 0],\r\n [width - 1, height - 1],\r\n [0, height - 1]], dtype=\"float32\")\r\n\r\n transformMatrix = cv2.getPerspectiveTransform(source, destination)\r\n\r\n return cv2.warpPerspective(image, transformMatrix, (width, height))","def ExtractCameraPose(E):\n u, s, v = np.linalg.svd(E, full_matrices=True)\n w = np.array([[0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]]).reshape(3, 3)\n c1 = u[:, 2].reshape(3, 1)\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c2 = -u[:, 2].reshape(3, 1)\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\n c3 = u[:, 2].reshape(3, 1)\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n c4 = -u[:, 2].reshape(3, 1)\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\n if np.linalg.det(r1) < 0:\n c1 = -c1\n r1 = -r1\n if np.linalg.det(r2) < 0:\n c2 = -c2\n r2 = -r2\n if np.linalg.det(r3) < 0:\n c3 = -c3\n r3 = -r3\n if np.linalg.det(r4) < 0:\n c4 = -c4\n r4 = -r4\n cam_center = np.array([c1, c2, c3, c4])\n cam_rotation = np.array([r1, r2, r3, r4])\n return cam_center, cam_rotation","def _OrthographicMatrix(scale=1.0):\r\n from pi3d.Display import Display\r\n M = [[0] * 4 for i in range(4)]\r\n M[0][0] = 2.0 * scale / Display.INSTANCE.width\r\n M[1][1] = 2.0 * scale / Display.INSTANCE.height\r\n #M[2][2] = 2.0 / Display.INSTANCE.width\r\n M[2][2] = 2.0 / 10000.0\r\n M[3][2] = -1\r\n M[3][3] = 1\r\n return array(M, dtype=float)","def stp_to_camera_transform(self):\n # setup variables\n camera_xyz_w = self.cam_pos\n camera_rot_w = self.cam_rot\n camera_int_pt_w = self.cam_interest_pt\n camera_xyz_obj_p = camera_xyz_w - camera_int_pt_w\n \n # get the distance from the camera to the world\n camera_dist_xy = np.linalg.norm(camera_xyz_w[:2])\n z = [0,0,np.linalg.norm(camera_xyz_w[:3])]\n\n # form the rotations about the x and z axis for the object on the tabletop\n theta = camera_rot_w[0] * np.pi / 180.0\n phi = -camera_rot_w[2] * np.pi / 180.0 + np.pi / 2.0\n camera_rot_obj_p_z = np.array([[np.cos(phi), -np.sin(phi), 0],\n [np.sin(phi), np.cos(phi), 0],\n [0, 0, 1]])\n\n camera_rot_obj_p_x = np.array([[1, 0, 0],\n [0, np.cos(theta), -np.sin(theta)],\n [0, np.sin(theta), np.cos(theta)]])\n \n # form the full rotation matrix, swapping axes to match maya\n camera_md = np.array([[0, 1, 0],\n [1, 0, 0],\n [0, 0, -1]])\n camera_rot_obj_p = camera_md.dot(camera_rot_obj_p_z.dot(camera_rot_obj_p_x))\n camera_rot_obj_p = camera_rot_obj_p.T\n \n # form the full object to camera transform\n R_stp_camera = camera_rot_obj_p\n t_stp_camera = np.array(z)\n return RigidTransform(rotation=R_stp_camera,\n translation=t_stp_camera,\n from_frame='stp', to_frame='camera')","def orthographic_matrix(self) -> TransformationMatrixType:\n near, far = self._clipping[self.projection_mode.value]\n return orthographic_matrix(self.fov, self.aspect_ratio, near, far)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[1, 1]=c\n self.matrix[1, 2]=s\n self.matrix[2, 1]=-s\n self.matrix[2, 2]=c\n return self.matrix","def getInverseMatrix(self) -> CMatrix4:\n ...","def camera(*args, aspectRatio: Union[float, bool]=0.0, cameraScale: Union[float, bool]=0.0,\n centerOfInterest: Union[float, bool]=0.0, clippingPlanes: bool=True, depthOfField:\n bool=True, displayFieldChart: bool=True, displayFilmGate: bool=True,\n displayFilmOrigin: bool=True, displayFilmPivot: bool=True, displayGateMask:\n bool=True, displayResolution: bool=True, displaySafeAction: bool=True,\n displaySafeTitle: bool=True, fStop: Union[float, bool]=0.0, farClipPlane:\n Union[float, bool]=0.0, farFocusDistance: Union[float, bool]=0.0, filmFit:\n Union[AnyStr, bool]=\"\", filmFitOffset: Union[float, bool]=0.0, filmRollOrder:\n Union[AnyStr, bool]=\"\", filmRollValue: Union[float, bool]=0.0, filmTranslateH:\n Union[float, bool]=0.0, filmTranslateV: Union[float, bool]=0.0, focalLength:\n Union[float, bool]=0.0, focusDistance: Union[float, bool]=0.0, homeCommand:\n Union[AnyStr, bool]=\"\", horizontalFieldOfView: Union[float, bool]=0.0,\n horizontalFilmAperture: Union[float, bool]=0.0, horizontalFilmOffset: Union[float,\n bool]=0.0, horizontalPan: Union[float, bool]=0.0, horizontalRollPivot: Union[float,\n bool]=0.0, horizontalShake: Union[float, bool]=0.0, journalCommand: bool=True,\n lensSqueezeRatio: Union[float, bool]=0.0, lockTransform: bool=True, motionBlur:\n bool=True, name: Union[AnyStr, bool]=\"\", nearClipPlane: Union[float, bool]=0.0,\n nearFocusDistance: Union[float, bool]=0.0, orthographic: bool=True,\n orthographicWidth: Union[float, bool]=0.0, overscan: Union[float, bool]=0.0,\n panZoomEnabled: bool=True, position: Union[List[float, float, float], bool]=None,\n postScale: Union[float, bool]=0.0, preScale: Union[float, bool]=0.0, renderPanZoom:\n bool=True, rotation: Union[List[float, float, float], bool]=None, shakeEnabled:\n bool=True, shakeOverscan: Union[float, bool]=0.0, shakeOverscanEnabled: bool=True,\n shutterAngle: Union[float, bool]=0.0, startupCamera: bool=True,\n stereoHorizontalImageTranslate: Union[float, bool]=0.0,\n stereoHorizontalImageTranslateEnabled: bool=True, verticalFieldOfView: Union[float,\n bool]=0.0, verticalFilmAperture: Union[float, bool]=0.0, verticalFilmOffset:\n Union[float, bool]=0.0, verticalLock: bool=True, verticalPan: Union[float, bool]=0.0,\n verticalRollPivot: Union[float, bool]=0.0, verticalShake: Union[float, bool]=0.0,\n worldCenterOfInterest: Union[List[float, float, float], bool]=None, worldUp:\n Union[List[float, float, float], bool]=None, zoom: Union[float, bool]=0.0, q=True,\n query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\n pass","def __init__(self, at=(0, 0, 0), eye=(0, 0, -0.1), lens=None,\r\n is_3d=True, scale=1.0):\r\n super(Camera, self).__init__()\r\n\r\n self.at = at\r\n self.start_eye = eye # for reset with different lens settings\r\n self.eye = [eye[0], eye[1], eye[2]]\r\n if lens == None:\r\n from pi3d.Display import Display\r\n lens = [Display.INSTANCE.near, Display.INSTANCE.far, Display.INSTANCE.fov,\r\n Display.INSTANCE.width / float(Display.INSTANCE.height)]\r\n self.lens = lens\r\n self.view = _LookAtMatrix(at, eye, [0, 1, 0])\r\n if is_3d:\r\n self.projection = _ProjectionMatrix(lens[0], lens[1], lens[2] / scale, lens[3])\r\n else:\r\n self.projection = _OrthographicMatrix(scale=scale)\r\n self.model_view = dot(self.view, self.projection)\r\n # Apply transform/rotation first, then shift into perspective space.\r\n self.mtrx = array(self.model_view, copy=True)\r\n # self.L_reflect = _LookAtMatrix(at,eye,[0,1,0],reflect=True)\r\n self.rtn = [0.0, 0.0, 0.0]\r\n\r\n self.was_moved = True","def projection_matrix(self) -> TransformationMatrixType:\n if self._projection_matrix is None:\n if self.projection_mode == Projection.TOP_DOWN:\n self._projection_matrix = self.orthographic_matrix\n else:\n self._projection_matrix = self.perspective_matrix\n\n return self._projection_matrix","def to_image_frame(loc):\n loc = np.dot(Hinv, loc) # to camera frame\n return loc / loc[2] # to pixels (from millimeters)","def GroundToImage_RzRyRz(self, groundPoints):\n X0 = float(self.exteriorOrientationParameters[0])\n Y0 = float(self.exteriorOrientationParameters[1])\n Z0 = float(self.exteriorOrientationParameters[2])\n\n xp = float(self.camera.principalPoint[0])\n yp = float(self.camera.principalPoint[1])\n\n R = self.rotationMatrix_RzRyRz\n r11 = float(R[0, 0])\n r12 = float(R[0, 1])\n r13 = float(R[0, 2])\n r21 = float(R[1, 0])\n r22 = float(R[1, 1])\n r23 = float(R[1, 2])\n r31 = float(R[2, 0])\n r32 = float(R[2, 1])\n r33 = float(R[2, 2])\n\n f = self.camera.focalLength\n\n camPoints = []\n\n for i in range(groundPoints.shape[0]):\n x = xp - (f) * (((r11 * (groundPoints[i, 0] - X0) + r21 * (groundPoints[i, 1] - Y0) + r31 * (\n groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (\n groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))\n y = yp - (f) * (((r12 * (groundPoints[i, 0] - X0) + r22 * (groundPoints[i, 1] - Y0) + r32 * (\n groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (\n groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))\n\n camPoints.append([x, y])\n\n # return self.CameraToImage(np.array(camPoints))\n return (np.array(camPoints))","def _get_rotation_matrix(transform):\n # caution: UE4 is using left-hand ortation order\n roll = np.deg2rad(-transform.rotation.roll)\n pitch = np.deg2rad(-transform.rotation.pitch)\n yaw = np.deg2rad(transform.rotation.yaw)\n sr, cr = np.sin(roll), np.cos(roll)\n sp, cp = np.sin(pitch), np.cos(pitch)\n sy, cy = np.sin(yaw), np.cos(yaw)\n rotation_matrix = np.array([[cy * cp, -sy * sr + cy * sp * sr, cy * sp * cr + sy * sr],\n [sy * cp, cy * sp * sr + cy * sr, -cy * sr + sy * sp * cr],\n [-sp, cp * sr, cp * cr]])\n return rotation_matrix","def XYZ_to_RGB_matrix(self):\n\n if not self._use_derived_XYZ_to_RGB_matrix:\n return self._XYZ_to_RGB_matrix\n else:\n return self._derived_XYZ_to_RGB_matrix","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[0, 0]=c\n self.matrix[0, 1]=s\n self.matrix[1, 0]=-s\n self.matrix[1, 1]=c\n return self.matrix","def transformation_matrix(self):\n t = np.array([[0.0], [0.0], [0.0]])\n Rt = np.hstack([self.rotation_matrix, t])\n return np.vstack([Rt, np.array([0.0, 0.0, 0.0, 1.0])])","def camera(target_size: Optional[Tuple[int, int]] = None, rgb: bool = True) -> Tensor:\n return imread(HERE+'camera.jpg', target_size=target_size, rgb=rgb)","def calculate_pitch_yaw_roll(landmarks_2D, cam_w=256, cam_h=256,\n radians=False):\n\n assert landmarks_2D is not None, 'landmarks_2D is None'\n\n # Estimated camera matrix values.\n c_x = cam_w / 2\n c_y = cam_h / 2\n f_x = c_x / np.tan(60 / 2 * np.pi / 180)\n f_y = f_x\n camera_matrix = np.float32([[f_x, 0.0, c_x], [0.0, f_y, c_y],\n [0.0, 0.0, 1.0]])\n camera_distortion = np.float32([0.0, 0.0, 0.0, 0.0, 0.0])\n\n # dlib (68 landmark) trached points\n # TRACKED_POINTS = [17, 21, 22, 26, 36, 39, 42, 45, 31, 35, 48, 54, 57, 8]\n # wflw(98 landmark) trached points\n # TRACKED_POINTS = [33, 38, 50, 46, 60, 64, 68, 72, 55, 59, 76, 82, 85, 16]\n # X-Y-Z with X pointing forward and Y on the left and Z up.\n # The X-Y-Z coordinates used are like the standard coordinates of ROS (robotic operative system)\n # OpenCV uses the reference usually used in computer vision:\n # X points to the right, Y down, Z to the front\n landmarks_3D = np.float32([\n [6.825897, 6.760612, 4.402142], # LEFT_EYEBROW_LEFT, \n [1.330353, 7.122144, 6.903745], # LEFT_EYEBROW_RIGHT, \n [-1.330353, 7.122144, 6.903745], # RIGHT_EYEBROW_LEFT,\n [-6.825897, 6.760612, 4.402142], # RIGHT_EYEBROW_RIGHT,\n [5.311432, 5.485328, 3.987654], # LEFT_EYE_LEFT,\n [1.789930, 5.393625, 4.413414], # LEFT_EYE_RIGHT,\n [-1.789930, 5.393625, 4.413414], # RIGHT_EYE_LEFT,\n [-5.311432, 5.485328, 3.987654], # RIGHT_EYE_RIGHT,\n [-2.005628, 1.409845, 6.165652], # NOSE_LEFT,\n [-2.005628, 1.409845, 6.165652], # NOSE_RIGHT,\n [2.774015, -2.080775, 5.048531], # MOUTH_LEFT,\n [-2.774015, -2.080775, 5.048531], # MOUTH_RIGHT,\n [0.000000, -3.116408, 6.097667], # LOWER_LIP,\n [0.000000, -7.415691, 4.070434], # CHIN\n ])\n landmarks_2D = np.asarray(landmarks_2D, dtype=np.float32).reshape(-1, 2)\n\n # Applying the PnP solver to find the 3D pose of the head from the 2D position of the landmarks.\n # retval - bool\n # rvec - Output rotation vector that, together with tvec, brings points from the world coordinate system to the camera coordinate system.\n # tvec - Output translation vector. It is the position of the world origin (SELLION) in camera co-ords\n _, rvec, tvec = cv2.solvePnP(landmarks_3D, landmarks_2D,\n camera_matrix, camera_distortion)\n #Get as input the rotational vector, Return a rotational matrix\n\n # const double PI = 3.141592653;\n # double thetaz = atan2(r21, r11) / PI * 180;\n # double thetay = atan2(-1 * r31, sqrt(r32*r32 + r33*r33)) / PI * 180;\n # double thetax = atan2(r32, r33) / PI * 180;\n \n rmat, _ = cv2.Rodrigues(rvec)\n pose_mat = cv2.hconcat((rmat, tvec))\n _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)\n return map(lambda k: k[0], euler_angles) # euler_angles contain (pitch, yaw, roll)","def camera_transformation_from_pose(azimutal, elevation):\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\n azimutal *= -1.\n elevation *= -1.\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\n [0, 1, 0],\n [-np.sin(elevation), 0, np.cos(elevation)]])\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\n [np.sin(azimutal), np.cos(azimutal), 0],\n [0, 0, 1]])\n r = r_z.dot(r_y)\n # world_to_camera matrix, camera_to_world matrix\n return r, np.linalg.inv(r)","def setBillboardMatrix(self):\n \n wolrd_matrix_plug = OpenMaya.MPlug(self.thisObj, self.worldMatrix).elementByLogicalIndex(0)\n world_matrix = OpenMaya.MFnMatrixData(wolrd_matrix_plug.asMObject()).matrix()\n float_matrix = self.matrixToFloatMatrix(world_matrix)\n wolrd_rot_matrix = self.removeMatrixTranslate(float_matrix.inverse())\n\n camera_DagPath = OpenMaya.MDagPath()\n self.view.getCamera(camera_DagPath)\n camera_matrix = self.matrixToFloatMatrix(camera_DagPath.inclusiveMatrix())\n camera_rot_matrix = self.removeMatrixTranslate(camera_matrix)\n \n mult_matrix = camera_rot_matrix * wolrd_rot_matrix\n mult_float_matrix = self.matrixToFloatMatrix(mult_matrix)\n \n # set matrix\n float16_ptr = self.floatArrayToPrt(mult_float_matrix)\n glFT.glMultMatrixf(float16_ptr)\n \n # set scale\n sX, sY, sZ = self.getScale()\n glFT.glScalef(sX, sY, sZ)","def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\n # Camera intrinsics parameters\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\n\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\n\n skew = skew # \"skew param will be zero for most normal cameras\" Hartley, Zisserman\n\n m_x = resolution_x_px / resolution_x_mm\n m_y = resolution_y_px / resolution_y_mm\n\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\n\n x_0 = resolution_x_px / 2\n y_0 = resolution_y_px / 2\n\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])","def show_planes(im, spacing=10): # pragma: no cover\n s = spacing\n if np.squeeze(im.ndim) < 3:\n raise Exception('This view is only necessary for 3D images')\n x, y, z = (np.array(im.shape)/2).astype(int)\n im_xy = im[:, :, z]\n im_xz = im[:, y, :]\n im_yz = np.rot90(im[x, :, :])\n\n new_x = im_xy.shape[0] + im_yz.shape[0] + s\n\n new_y = im_xy.shape[1] + im_xz.shape[1] + s\n\n new_im = np.zeros([new_x + 2*s, new_y + 2*s], dtype=im.dtype)\n\n # Add xy image to upper left corner\n new_im[s:im_xy.shape[0] + s,\n s:im_xy.shape[1] + s] = im_xy\n # Add xz image to lower left coner\n x_off = im_xy.shape[0] + 2*s\n y_off = im_xy.shape[1] + 2*s\n new_im[s:s + im_xz.shape[0],\n y_off:y_off + im_xz.shape[1]] = im_xz\n new_im[x_off:x_off + im_yz.shape[0],\n s:s + im_yz.shape[1]] = im_yz\n\n return new_im","def perspectiveNormalizationXform(self):\n return np.array([[1.0/np.tan(self.view_angle_h), 0, 0, 0],\n [0, 1.0/np.tan(self.view_angle_v), 0, 0],\n [0, 0, (self.far + self.near)/(self.far - self.near),\n 2*self.far*self.near/(self.far - self.near)],\n [0, 0, -1, 0]])","def lookAtLH(eye, target, up):\n zaxis = (target - eye).normalize()\n xaxis = up.cross(zaxis).normalize()\n yaxis = zaxis.cross(xaxis).normalize()\n\n ex = -xaxis.dot(eye)\n ey = -yaxis.dot(eye)\n ez = -zaxis.dot(eye)\n\n m = [\n [xaxis.x, yaxis.x, zaxis.x, 0],\n [xaxis.y, yaxis.y, zaxis.y, 0],\n [xaxis.z, yaxis.z, zaxis.z, 0],\n [ex, ey, ez, 1]\n ]\n return Matrix(m)","def CameraToImage(self, cameraPoints):\n # setting up the required matrices\n a0 = self.innerOrientationParameters[0]\n b0 = self.innerOrientationParameters[1]\n a1 = self.innerOrientationParameters[2]\n a2 = self.innerOrientationParameters[3]\n b1 = self.innerOrientationParameters[4]\n b2 = self.innerOrientationParameters[5]\n\n if np.isscalar(a0):\n\n R = np.array([[a1, a2], [b1, b2]])\n T = np.array([[a0], [b0]])\n\n else:\n R = np.array([[a1[0], a2[0]], [b1[0], b2[0]]])\n T = np.array([[a0[0]], [b0[0]]])\n\n cameraPoints = cameraPoints.T\n # computing the transformation to the image system\n return (T + np.dot(R, cameraPoints)).T","def d4out():\n\td4x.moveTo(d4x_out)\n\td4y.moveTo(d4y_out)","def camera(self):\n return self.__camera","def base_projection_matrix(self, fiber):\n return matrix(ZZ, fiber.vertices()).right_kernel_matrix()","def camera_to_object_transform(self):\n # form the full object to camera transform\n T_stp_camera = self.stp_to_camera_transform()\n T_obj_stp = self.object_to_stp_transform()\n T_obj_camera = T_stp_camera.dot(T_obj_stp)\n return T_obj_camera","def transpose(self):\r\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\r\n return mat4(m11,m21,m31,m41,\r\n m12,m22,m32,m42,\r\n m13,m23,m33,m43,\r\n m14,m24,m34,m44)","def render_4d(polyhedron, **kwds):\n projection_direction = None\n try: \n projection_direction = kwds.pop('projection_directior')\n except KeyError:\n for ineq in polyhedron.inequality_generator():\n center = [v() for v in ineq.incident() if v.is_vertex()]\n center = sum(center) / len(center)\n if not center.is_zero(): \n projection_direction = center\n break\n projection_3d = Projection(polyhedron).schlegel(projection_direction)\n return render_3d(projection_3d, **kwds)","def project(points, camera_params):\n points_proj = rotate(points, camera_params[:, :3])\n points_proj += camera_params[:, 3:6]\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\n f = camera_params[:, 6]\n k1 = camera_params[:, 7]\n k2 = camera_params[:, 8]\n n = np.sum(points_proj ** 2, axis=1)\n r = 1 + k1 * n + k2 * n ** 2\n points_proj *= (r * f)[:, np.newaxis]\n return points_proj"],"string":"[\n \"def getCameraMatrix(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def camera_matrix(self) -> TransformationMatrixType:\\n return numpy.matmul(\\n self.rotation_matrix(*self.rotation),\\n displacement_matrix(*-numpy.array(self.location)),\\n )\",\n \"def camera_matrix(e, p, t):\\n # Translates all points such that the camera is centered at the origin.\\n T = np.array([[1, 0, 0, -e[0]],\\n [0, 1, 0, -e[1]],\\n [0, 0, 1, -e[2]],\\n [0, 0, 0, 1]])\\n\\n # Set up orthonormal basis.\\n w = e - p\\n w = w / np.linalg.norm(w)\\n u = np.cross(t, w)\\n u = u / np.linalg.norm(u)\\n v = np.cross(w, u)\\n\\n # Rotate points such that camera is aligned with UVW-axes (g -> -z-axis).\\n R = np.array([[u[0], u[1], u[2], 0],\\n [v[0], v[1], v[2], 0],\\n [w[0], w[1], w[2], 0],\\n [ 0, 0, 0, 1]])\\n return R.dot(T)\",\n \"def intrinsic_matrix_from_camera(w, h, fov):\\n (cx, cy), f = calc_focal_values(w, h, fov)\\n return np.array([[f, 0, cx], [0, f, cy], [0, 0, 1]])\",\n \"def frustum(self, left, right, bottom, top, near, far):\\r\\n \\r\\n return mat4( (2.0*near)/(right-left), 0.0, float(right+left)/(right-left), 0.0,\\r\\n 0.0, (2.0*near)/(top-bottom), float(top+bottom)/(top-bottom), 0.0,\\r\\n 0.0, 0.0, -float(far+near)/(far-near), -(2.0*far*near)/(far-near),\\r\\n 0.0, 0.0, -1.0, 0.0)\",\n \"def fk4(joint_rotations):\\n h0_4 = htm4(joint_rotations)\\n x0_4 = h0_4[0, 3]\\n y0_4 = h0_4[1, 3]\\n z0_4 = h0_4[2, 3]\\n d0_4 = [x0_4, y0_4, z0_4]\\n return d0_4\",\n \"def htm4(joint_rotations):\\n # H0_3\\n h0_3 = htm0_3(joint_rotations)\\n\\n # H3_4\\n r3_4 = rot_z(joint_rotations[3])\\n x3_4 = a4 * np.cos(np.radians(joint_rotations[3]))\\n y3_4 = a4 * np.sin(np.radians(joint_rotations[3]))\\n z3_4 = 0\\n d3_4 = transl(x3_4, y3_4, z3_4)\\n h3_4 = htm(r3_4, d3_4)\\n h0_4 = np.dot(h0_3, h3_4)\\n return h0_4\",\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 __ComputeDesignMatrix_RzRyRz(self, groundPoints):\\n # initialization for readability\\n azimuth = self.exteriorOrientationParameters[3]\\n phi = self.exteriorOrientationParameters[4]\\n kappa = self.exteriorOrientationParameters[5]\\n\\n # Coordinates subtraction\\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\\n dXYZ = np.vstack([dX, dY, dZ])\\n\\n rotationMatrixT = self.rotationMatrix_RzRyRz.T\\n rotatedG = rotationMatrixT.dot(dXYZ)\\n rT1g = rotatedG[0, :]\\n rT2g = rotatedG[1, :]\\n rT3g = rotatedG[2, :]\\n\\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\\n\\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\\n\\n dgdX0 = np.array([-1, 0, 0], 'f')\\n dgdY0 = np.array([0, -1, 0], 'f')\\n dgdZ0 = np.array([0, 0, -1], 'f')\\n\\n # Derivatives with respect to X0\\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\\n\\n # Derivatives with respect to Y0\\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\\n\\n # Derivatives with respect to Z0\\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\\n\\n dRTdOmega = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'azimuth').T\\n dRTdPhi = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'phi').T\\n dRTdKappa = Compute3DRotationDerivativeMatrix_RzRyRz(azimuth, phi, kappa, 'kappa').T\\n\\n gRT3g = dXYZ * rT3g\\n\\n # Derivatives with respect to Omega\\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Phi\\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Kappa\\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n # all derivatives of x and y\\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\\n\\n a = np.zeros((2 * dd[0].shape[0], 6))\\n a[0::2] = dd[0]\\n a[1::2] = dd[1]\\n\\n return a\",\n \"def get_projection_matrix(left, right, bottom, top):\\r\\n zNear = -25.0\\r\\n zFar = 25.0\\r\\n inv_z = 1.0 / (zFar - zNear)\\r\\n inv_y = 1.0 / (top - bottom)\\r\\n inv_x = 1.0 / (right - left)\\r\\n mat = [[(2.0 * inv_x), 0.0, 0.0, (-(right + left) * inv_x)],\\r\\n [0.0, (2.0 * inv_y), 0.0, (-(top + bottom) * inv_y)],\\r\\n [0.0, 0.0, (-2.0 * inv_z), (-(zFar + zNear) * inv_z)],\\r\\n [0.0, 0.0, 0.0, 1.0]]\\r\\n return mat\",\n \"def get_projection_matrix(K, rvec, tvec):\\n R = cv2.Rodrigues(np.float32(rvec))[0]\\n Rt = np.zeros((3, 4))\\n Rt[:, 0:3] = R\\n Rt[:, 3] = tvec\\n return K @ Rt\",\n \"def _ProjectionMatrix(near, far, fov, aspectRatio):\\r\\n # Matrices are considered to be M[row][col]\\r\\n # Use DirectX convention, so need to do rowvec*Matrix to transform\\r\\n size = 1 / tan(radians(fov)/2.0)\\r\\n M = [[0] * 4 for i in range(4)]\\r\\n M[0][0] = size/aspectRatio\\r\\n M[1][1] = size #negative value reflects scene on the Y axis\\r\\n M[2][2] = (far + near) / (far - near)\\r\\n M[2][3] = 1\\r\\n M[3][2] = -(2 * far * near)/(far - near)\\r\\n return array(M, dtype=float)\",\n \"def map_to_matrix(x, y):\\n x_pos = round(x * ((MATRIX_SIZE_X - 1)/(FRAME_W - 1)))\\n y_pos = round(y * ((MATRIX_SIZE_Y - 1)/(FRAME_H - 1)))\\n\\n x_pos = (MATRIX_SIZE_X - 1) - x_pos #invert x direction (left and right) to account for camera perspective\\n\\n return x_pos, y_pos\",\n \"def getMatrix(self) -> CMatrix4:\\n ...\",\n \"def row_matrix_col_4d(a, b, A):\\n\\n\\treturn (a[0]*A[0][0]*b[0] + a[1]*A[1][0]*b[0] + a[2]*A[2][0]*b[0] + a[3]*A[3][0]*b[0] +\\n\\t a[0]*A[0][1]*b[1] + a[1]*A[1][1]*b[1] + a[2]*A[2][1]*b[1] + a[3]*A[3][1]*b[1] +\\n\\t a[0]*A[0][2]*b[2] + a[1]*A[1][2]*b[2] + a[2]*A[2][2]*b[2] + a[3]*A[3][2]*b[2] +\\n\\t a[0]*A[0][3]*b[3] + a[1]*A[1][3]*b[3] + a[2]*A[2][3]*b[3] + a[3]*A[3][3]*b[3])\",\n \"def matrix(self):\\n m = Matrix.identity(4, 4)\\n\\n m[:3, :3] = self.rotation.matrix.data\\n m[:3, 3:4] = self.translation.matrix.data\\n\\n return m\",\n \"def set_camera(self, width, height):\\n rightt = self.mat[:3, 0]\\n upt = self.mat[:3, 1]\\n pt = self.mat[:3, 2] * self.d\\n t = self.mat[:3, 3]\\n\\n self.proj_mat = create_perspective_projection_matrix(np.radians(self.fov), 1. * width / height, self.near, self.far)\\n gr3.setcameraprojectionparameters(self.fov, self.near, self.far)\\n self.lookat_mat = create_look_at_matrix(pt + t, t, upt)\\n gr3.cameralookat(pt[0] + t[0], pt[1] + t[1], pt[2] + t[2], t[0], t[1], t[2], upt[0], upt[1], upt[2])\",\n \"def _calculate_camera_array(self):\\n look_list = []\\n\\n row_step_vec = normalize(self.look_up) * self.interspatial_distance\\n col_step_vec = self._get_look_right() * self.interspatial_distance\\n\\n # Start at the top left camera position\\n for i in range(self.spatial_rows):\\n row_movement = row_step_vec * (-i)\\n row_look_from = self.look_from + row_movement\\n row_look_to = self.look_to + row_movement\\n\\n for j in range(self.spatial_cols):\\n col_movement = col_step_vec * j\\n cam_look_from = row_look_from + col_movement\\n cam_look_to = row_look_to + col_movement\\n\\n look_list.append((cam_look_from, cam_look_to))\\n\\n return look_list\",\n \"def __ComputeDesignMatrix(self, groundPoints):\\n # initialization for readability\\n omega = self.exteriorOrientationParameters[3]\\n phi = self.exteriorOrientationParameters[4]\\n kappa = self.exteriorOrientationParameters[5]\\n\\n # Coordinates subtraction\\n dX = groundPoints[:, 0] - self.exteriorOrientationParameters[0]\\n dY = groundPoints[:, 1] - self.exteriorOrientationParameters[1]\\n dZ = groundPoints[:, 2] - self.exteriorOrientationParameters[2]\\n dXYZ = np.vstack([dX, dY, dZ])\\n\\n rotationMatrixT = self.rotationMatrix.T\\n rotatedG = rotationMatrixT.dot(dXYZ)\\n rT1g = rotatedG[0, :]\\n rT2g = rotatedG[1, :]\\n rT3g = rotatedG[2, :]\\n\\n focalBySqauredRT3g = self.camera.focalLength / rT3g ** 2\\n\\n dxdg = rotationMatrixT[0, :][None, :] * rT3g[:, None] - rT1g[:, None] * rotationMatrixT[2, :][None, :]\\n dydg = rotationMatrixT[1, :][None, :] * rT3g[:, None] - rT2g[:, None] * rotationMatrixT[2, :][None, :]\\n\\n dgdX0 = np.array([-1, 0, 0], 'f')\\n dgdY0 = np.array([0, -1, 0], 'f')\\n dgdZ0 = np.array([0, 0, -1], 'f')\\n\\n # Derivatives with respect to X0\\n dxdX0 = -focalBySqauredRT3g * np.dot(dxdg, dgdX0)\\n dydX0 = -focalBySqauredRT3g * np.dot(dydg, dgdX0)\\n\\n # Derivatives with respect to Y0\\n dxdY0 = -focalBySqauredRT3g * np.dot(dxdg, dgdY0)\\n dydY0 = -focalBySqauredRT3g * np.dot(dydg, dgdY0)\\n\\n # Derivatives with respect to Z0\\n dxdZ0 = -focalBySqauredRT3g * np.dot(dxdg, dgdZ0)\\n dydZ0 = -focalBySqauredRT3g * np.dot(dydg, dgdZ0)\\n\\n dRTdOmega = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'omega').T\\n dRTdPhi = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'phi').T\\n dRTdKappa = Compute3DRotationDerivativeMatrix(omega, phi, kappa, 'kappa').T\\n\\n gRT3g = dXYZ * rT3g\\n\\n # Derivatives with respect to Omega\\n dxdOmega = -focalBySqauredRT3g * (dRTdOmega[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydOmega = -focalBySqauredRT3g * (dRTdOmega[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdOmega[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Phi\\n dxdPhi = -focalBySqauredRT3g * (dRTdPhi[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydPhi = -focalBySqauredRT3g * (dRTdPhi[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdPhi[2, :][None, :].dot(dXYZ)))[0]\\n\\n # Derivatives with respect to Kappa\\n dxdKappa = -focalBySqauredRT3g * (dRTdKappa[0, :][None, :].dot(gRT3g) -\\n rT1g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n dydKappa = -focalBySqauredRT3g * (dRTdKappa[1, :][None, :].dot(gRT3g) -\\n rT2g * (dRTdKappa[2, :][None, :].dot(dXYZ)))[0]\\n\\n # all derivatives of x and y\\n dd = np.array([np.vstack([dxdX0, dxdY0, dxdZ0, dxdOmega, dxdPhi, dxdKappa]).T,\\n np.vstack([dydX0, dydY0, dydZ0, dydOmega, dydPhi, dydKappa]).T])\\n\\n a = np.zeros((2 * dd[0].shape[0], 6))\\n a[0::2] = dd[0]\\n a[1::2] = dd[1]\\n\\n return a\",\n \"def modelview_matrix(self):\\n camera = self.figure.scene.camera\\n return camera.view_transform_matrix.to_array().astype(np.float32)\",\n \"def perspective_transform():\\n src = np.float32([(220,720), (1110, 720), (570, 470), (722, 470)]) # Manually get these numbers from plot\\n dst = np.float32([[320, 720], [920, 720], [320, 1], [920, 1]])\\n M = cv2.getPerspectiveTransform(src, dst)\\n Minv = cv2.getPerspectiveTransform(dst, src)\\n\\n return M, Minv\",\n \"def get_transform_matrix(theta, phi = None, invert_rot = False, invert_focal = False):\\n\\n if phi is None:\\n phi = const.PHI_IDX * 10.0\\n\\n #extrinsic x intrinsic\\n camera_matrix = np.zeros((4, 4), dtype=np.float32)\\n\\n intrinsic_matrix = np.eye(4, dtype=np.float32)\\n extrinsic_matrix = np.eye(4, dtype=np.float32)\\n\\n sin_phi = np.sin(float(phi) / 180.0 * np.pi)\\n cos_phi = np.cos(float(phi) / 180.0 * np.pi)\\n sin_theta = np.sin(float(-theta) / 180.0 * np.pi)\\n cos_theta = np.cos(float(-theta) / 180.0 * np.pi)\\n\\n #theta rotation\\n rotation_azimuth = np.zeros((3, 3), dtype=np.float32)\\n rotation_azimuth[0, 0] = cos_theta\\n rotation_azimuth[2, 2] = cos_theta\\n rotation_azimuth[0, 2] = -sin_theta\\n rotation_azimuth[2, 0] = sin_theta\\n rotation_azimuth[1, 1] = 1.0\\n\\n #phi rotation\\n rotation_elevation = np.zeros((3, 3), dtype=np.float32)\\n rotation_elevation[0, 0] = cos_phi\\n rotation_elevation[0, 1] = sin_phi\\n rotation_elevation[1, 0] = -sin_phi\\n rotation_elevation[1, 1] = cos_phi\\n rotation_elevation[2, 2] = 1.0\\n\\n #rotate phi, then theta\\n rotation_matrix = np.matmul(rotation_azimuth, rotation_elevation)\\n if invert_rot:\\n rotation_matrix = np.linalg.inv(rotation_matrix)\\n\\n displacement = np.zeros((3, 1), dtype=np.float32)\\n displacement[0, 0] = const.DIST_TO_CAM\\n displacement = np.matmul(rotation_matrix, displacement)\\n\\n #assembling 4x4 from R + T\\n extrinsic_matrix[0:3, 0:3] = rotation_matrix\\n extrinsic_matrix[0:3, 3:4] = -displacement\\n\\n if invert_focal:\\n intrinsic_matrix[2, 2] = float(const.focal_length)\\n intrinsic_matrix[1, 1] = float(const.focal_length)\\n else:\\n intrinsic_matrix[2, 2] = 1.0 / float(const.focal_length)\\n intrinsic_matrix[1, 1] = 1.0 / float(const.focal_length)\\n\\n camera_matrix = np.matmul(extrinsic_matrix, intrinsic_matrix)\\n return camera_matrix\",\n \"def camera_transform(image):\\n img = np.zeros((image.shape[0], image.shape[1], 3))\\n for y in range(image.shape[0]):\\n for x in range(image.shape[1]):\\n img[y][x] = (x - 320) / 575.5 * image[y, x], (240 - y) / 575.5 * image[y, x], image[\\n y, x]\\n return img\",\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 ortho(self):\\r\\n\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n\\r\\n x = _vec3(m11, m21, m31)\\r\\n y = _vec3(m12, m22, m32)\\r\\n z = _vec3(m13, m23, m33)\\r\\n\\r\\n xl = x.length()\\r\\n xl*=xl\\r\\n y = y - ((x*y)/xl)*x\\r\\n z = z - ((x*z)/xl)*x\\r\\n\\r\\n yl = y.length()\\r\\n yl*=yl\\r\\n z = z - ((y*z)/yl)*y\\r\\n\\r\\n return mat4( x.x, y.x, z.x, m14,\\r\\n x.y, y.y, z.y, m24,\\r\\n x.z, y.z, z.z, m34,\\r\\n m41, m42, m43, m44)\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n\\n origin = np.array([location.x, location.y, location.z])\\n return matrix, origin\",\n \"def _LookAtMatrix(at, eye, up=[0, 1, 0], reflect=False):\\r\\n # If reflect, then reflect in plane -20.0 (water depth)\\r\\n if reflect:\\r\\n depth = -20.0 # Shallower to avoid edge effects\\r\\n eye = [eye[0], -eye[1], eye[2]]\\r\\n at = [at[0], -at[1], at[2]]\\r\\n zaxis = vec_normal(vec_sub(at, eye))\\r\\n xaxis = vec_normal(vec_cross(up, zaxis))\\r\\n yaxis = vec_cross(zaxis, xaxis)\\r\\n xaxis.append(-vec_dot(xaxis, eye))\\r\\n yaxis.append(-vec_dot(yaxis, eye))\\r\\n zaxis.append(-vec_dot(zaxis, eye))\\r\\n z = [0, 0, 0, 1.0]\\r\\n return array([[xaxis[a], yaxis[a], zaxis[a], z[a]] for a in range(4)],\\r\\n dtype=float)\",\n \"def build_camera(R, t):\\n camera = R.flatten()\\n camera = np.append(camera, t.flatten())\\n camera = np.append(camera, K[0][0])\\n camera = np.append(camera, dist[0, 0:2].flatten())\\n return camera\",\n \"def computeMVP(self):\\n projMat = self.converterYUR\\n modelViewMat = self.transforMat.invertCompose(\\n Globals.render.getTransform(self.cameraNode)).getMat()\\n return UnalignedLMatrix4f(modelViewMat * projMat)\",\n \"def quatRightMat(q):\\n\\ts = q[0]\\n\\tv = q[1:].reshape(-1,)\\n\\tR = np.zeros((4, 4))\\n\\tR[0, 0] = s\\n\\tR[0, 1:] = -v\\n\\tR[1:, 0] = v\\n\\tR[1:, 1:] = s*np.eye(3) - skewMat(v)\\n\\treturn R\",\n \"def perspectiveFovLH(field_of_view, aspect, znear, zfar):\\n h = 1 / tan(field_of_view / 2)\\n w = h / aspect\\n m = [\\n [w, 0, 0, 0],\\n [0, h, 0, 0],\\n [0, 0, zfar / (zfar - znear), 1],\\n [0, 0, (znear * zfar) / (znear - zfar), 0],\\n ]\\n return Matrix(m)\",\n \"def perspective_matrix(self) -> TransformationMatrixType:\\n z_near, z_far = self._clipping[self.projection_mode.value]\\n return perspective_matrix(\\n math.radians(self.fov), self.aspect_ratio, z_near, z_far\\n )\",\n \"def getDejaVuMatrix(self):\\n mtx = self.getRotMatrix((4, 4), transpose=None) # from Quaternion\\n mtx[3] = self.getTranslation()\\n mtx[:3, 3] = mtx[3, :3]\\n mtx[3, :3] = [0, 0, 0]\\n return mtx\",\n \"def bloch_matrix(self):\\n if self.gf_r is None:\\n self.gf()\\n\\n return -self.gf_r.dot(self.lead[1])\",\n \"def m(self) -> np.ndarray:\\n assert self._k is not None and self._r is not None and self._t is not None, \\\"camera must be calibrated\\\"\\n return forge_projective_matrix(self._k, r=self._r, t=self._t)\",\n \"def create_cam2world_matrix(forward_vector,\\n origin,\\n device=None):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n forward_vector = normalize_vecs(forward_vector)\\n up_vector = torch.tensor([0, 1, 0], dtype=torch.float, device=device) \\\\\\n .expand_as(forward_vector)\\n\\n left_vector = normalize_vecs(\\n torch.cross(up_vector,\\n forward_vector,\\n dim=-1))\\n\\n up_vector = normalize_vecs(\\n torch.cross(forward_vector,\\n left_vector,\\n dim=-1))\\n\\n rotation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n rotation_matrix[:, :3, :3] = torch.stack(\\n (-left_vector, up_vector, -forward_vector), axis=-1)\\n\\n translation_matrix = torch.eye(4, device=device) \\\\\\n .unsqueeze(0) \\\\\\n .repeat(forward_vector.shape[0], 1, 1)\\n translation_matrix[:, :3, 3] = origin\\n\\n cam2world = translation_matrix @ rotation_matrix\\n\\n return cam2world\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def get_matrix(transform):\\n\\n rotation = transform.rotation\\n location = transform.location\\n c_y = np.cos(np.radians(rotation.yaw))\\n s_y = np.sin(np.radians(rotation.yaw))\\n c_r = np.cos(np.radians(rotation.roll))\\n s_r = np.sin(np.radians(rotation.roll))\\n c_p = np.cos(np.radians(rotation.pitch))\\n s_p = np.sin(np.radians(rotation.pitch))\\n matrix = np.matrix(np.identity(4))\\n matrix[0, 3] = location.x\\n matrix[1, 3] = location.y\\n matrix[2, 3] = location.z\\n matrix[0, 0] = c_p * c_y\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\n matrix[1, 0] = s_y * c_p\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\n matrix[2, 0] = s_p\\n matrix[2, 1] = -c_p * s_r\\n matrix[2, 2] = c_p * c_r\\n return matrix\",\n \"def pixel2cam(self, depth, intrinsics_inv):\\n b, _, h, w = depth.size()\\n i_range = torch.arange(0, h).view(1, h, 1).expand(1,h,w).type_as(depth) # [1, H, W]\\n j_range = torch.arange(0, w).view(1, 1, w).expand(1,h,w).type_as(depth) # [1, H, W]\\n ones = torch.ones(1,h,w).type_as(depth)\\n pixel_coords = torch.stack((j_range, i_range, ones), dim=1) # [1, 3, H, W]\\n ###pixel_coords is an array of camera pixel coordinates (x,y,1) where x,y origin is the upper left corner of the image.\\n current_pixel_coords = pixel_coords[:,:,:h,:w].expand(b,3,h,w).view(b,3,-1) #.contiguous().view(b, 3, -1) # [B, 3, H*W]\\n #cam_coords = intrinsic_inv.expand(b,3,3).bmm(current_pixel_coords).view(b,3,h,w)\\n cam_coords = intrinsics_inv.bmm(current_pixel_coords).view(b,3,h,w)\\n return cam_coords * depth\",\n \"def test_RawRun_perspective_reference_old_style():\\n ref = (0, 0)\\n m = config.ideal_m\\n grid = r.perspective_reference(ref, 'old', 'cam1')\\n lower_right, upper_right, lower_left, upper_left = grid\\n assert_equal((0, 0), lower_right)\\n assert_equal((ref[0] - int(1.47 * m), ref[1] - int(0.25 * m)), upper_left)\",\n \"def get_matrix(self, transform):\\r\\n\\r\\n rotation = transform.rotation\\r\\n location = transform.location\\r\\n c_y = np.cos(np.radians(rotation.yaw))\\r\\n s_y = np.sin(np.radians(rotation.yaw))\\r\\n c_r = np.cos(np.radians(rotation.roll))\\r\\n s_r = np.sin(np.radians(rotation.roll))\\r\\n c_p = np.cos(np.radians(rotation.pitch))\\r\\n s_p = np.sin(np.radians(rotation.pitch))\\r\\n matrix = np.matrix(np.identity(4))\\r\\n matrix[0, 3] = location.x\\r\\n matrix[1, 3] = location.y\\r\\n matrix[2, 3] = location.z\\r\\n matrix[0, 0] = c_p * c_y\\r\\n matrix[0, 1] = c_y * s_p * s_r - s_y * c_r\\r\\n matrix[0, 2] = -c_y * s_p * c_r - s_y * s_r\\r\\n matrix[1, 0] = s_y * c_p\\r\\n matrix[1, 1] = s_y * s_p * s_r + c_y * c_r\\r\\n matrix[1, 2] = -s_y * s_p * c_r + c_y * s_r\\r\\n matrix[2, 0] = s_p\\r\\n matrix[2, 1] = -c_p * s_r\\r\\n matrix[2, 2] = c_p * c_r\\r\\n return matrix\",\n \"def projection_matrix(self):\\n scene = self.figure.scene\\n scene_size = tuple(scene.get_size())\\n aspect_ratio = float(scene_size[0]) / float(scene_size[1])\\n p = scene.camera.get_perspective_transform_matrix(\\n aspect_ratio, -1, 1).to_array().astype(np.float32)\\n return p\",\n \"def rotation_matrix(yaw, pitch) -> TransformationMatrixType:\\n return rotation_matrix_yx(math.radians(yaw + 180), math.radians(pitch))\",\n \"def read_camera(self):\\n _, frame = self.camera.read()\\n return self.mirror(frame)\",\n \"def compute_projection_matrix(width,\\n height,\\n f_x,\\n f_y,\\n c_x,\\n c_y,\\n near,\\n far):\\n # pylint: disable=line-too-long\\n matrix = vtk.vtkMatrix4x4()\\n matrix.Zero()\\n matrix.SetElement(0, 0, 2*f_x/width)\\n matrix.SetElement(0, 1, -2*0/width) # Not doing skew, so this will be 0.\\n matrix.SetElement(0, 2, (width - 2*c_x)/width)\\n matrix.SetElement(1, 1, 2*f_y/height)\\n matrix.SetElement(1, 2, (-height + 2*c_y)/height)\\n matrix.SetElement(2, 2, (-far-near)/(far-near))\\n matrix.SetElement(2, 3, -2*far*near/(far-near))\\n matrix.SetElement(3, 2, -1)\\n return matrix\",\n \"def _embed44(matrix):\\n result = np.eye(4)\\n r, c = matrix.shape\\n result[:r, :c] = matrix\\n return result\",\n \"def _calculate_camera_pose(frame, K, d, corners, pattern_shape=(6, 4), grid_size=30): # noqa: E501\\n img = frame.copy()\\n axis = np.float32([[grid_size, 0, 0], [0, grid_size, 0],\\n [0, 0, -grid_size]]).reshape(-1, 3)*2\\n\\n objp = np.zeros((np.prod(pattern_shape), 3), np.float32)\\n objp[:, :2] = np.mgrid[0:pattern_shape[0],\\n 0:pattern_shape[1]].T.reshape(-1, 2) * grid_size\\n\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners, K, d)\\n R, _ = cv2.Rodrigues(rvecs)\\n # project 3D points onto image plane\\n imgpts, _ = cv2.projectPoints(axis,\\n rvecs, tvecs,\\n K, d)\\n\\n canvas = computer_vision.draw_axis(img, corners, imgpts)\\n return R, tvecs, canvas\",\n \"def camera_frame_directions(self) -> _BFRAME_TYPE:\\n pass\",\n \"def set_modelview_from_camera(Rt):\\n \\n glMatrixMode(GL_MODELVIEW)\\n glLoadIdentity()\\n \\n # rotate teapot 90 deg around x-axis so that z-axis is up\\n Rx = np.array([[1,0,0],[0,0,-1],[0,1,0]])\\n \\n # set rotation to best approximation\\n R = Rt[:,:3]\\n U,S,V = np.linalg.svd(R)\\n R = np.dot(U,V)\\n R[0,:] = -R[0,:] # change sign of x-axis\\n \\n # set translation\\n t = Rt[:,3]\\n \\n # setup 4*4 model view matrix\\n M = np.eye(4)\\n M[:3,:3] = np.dot(R,Rx)\\n M[:3,3] = t\\n\\n # transpose and flatten to get column order\\n M = M.T\\n \\n m = M.flatten()\\n \\n # replace model view with the new matrix\\n glLoadMatrixf(m)\",\n \"def four_point_transform(image, pts):\\n\\n\\tmax_x, max_y = np.max(pts[:, 0]).astype(np.int32), np.max(pts[:, 1]).astype(np.int32)\\n\\n\\tdst = np.array([\\n\\t\\t[0, 0],\\n\\t\\t[image.shape[1] - 1, 0],\\n\\t\\t[image.shape[1] - 1, image.shape[0] - 1],\\n\\t\\t[0, image.shape[0] - 1]], dtype=\\\"float32\\\")\\n\\n\\twarped = cv2.warpPerspective(image, cv2.getPerspectiveTransform(dst, pts), (max_x, max_y))\\n\\n\\treturn warped\",\n \"def _derive_transformation_matrices(self):\\n\\n if hasattr(self, '_primaries') and hasattr(self, '_whitepoint'):\\n if self._primaries is not None and self._whitepoint is not None:\\n npm = normalised_primary_matrix(self._primaries,\\n self._whitepoint)\\n\\n self._derived_RGB_to_XYZ_matrix = npm\\n self._derived_XYZ_to_RGB_matrix = np.linalg.inv(npm)\",\n \"def getTransposeMatrix(self) -> CMatrix4:\\n ...\",\n \"def getMatrixFromSkeletonToGeometry(self):\\n return _osgAnimation.RigGeometry_getMatrixFromSkeletonToGeometry(self)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[2, 2]=c\\n self.matrix[2, 0]=s\\n self.matrix[0, 2]=-s\\n self.matrix[0, 0]=c\\n return self.matrix\",\n \"def get_frame(cap):\\n\\n #camera matrix for camera calibration\\n mtx = np.array(np.mat(\\\"588.4525598886621, 0, 301.8008794717551; 0, 588.9763096391521, 242.617026416902; 0, 0, 1\\\"))\\n\\n #distrotion coefficients for camera calibration\\n dist = np.array(np.mat(\\\"-0.4351555722591889, 0.2082765081608728, -0.006072767012672472, 0.008139871640987759, 0\\\"))\\n\\n #get image frame from the camera\\n ret, frame = cap.read()\\n\\n return frame\\n\\n h, w = frame.shape[:2]\\n\\n #get the new optimal camera matrix and the roi which can be used to crop the result\\n newcameramtx, roi=cv2.getOptimalNewCameraMatrix(mtx,dist,(w,h),0,(w,h))\\n\\n #get the undistroted image\\n dst = cv2.undistort(frame, mtx, dist, None, newcameramtx)\\n\\n x,y,w,h = roi\\n\\n #get the cropped image\\n dst = dst[y:y+h, x:x+w]\\n h, w = dst.shape[:2]\\n\\n #furthur crop the image to reduce the size of arena\\n dst = dst[int(h/7):int(h*6/7), int(w/7):int(w*6/7)]\\n\\n #resize the arena to ARENA_SIZE\\n dst = cv2.resize(dst, ARENA_SIZE, interpolation= cv2.INTER_CUBIC)\\n\\n return dst\",\n \"def camera_fov_corners(camera_info, zdist, Tcamera=np.eye(4)):\\n cam_model = PinholeCameraModel()\\n cam_model.fromCameraInfo(camera_info)\\n delta_x = cam_model.getDeltaX(cam_model.width/2, zdist)\\n delta_y = cam_model.getDeltaY(cam_model.height/2, zdist)\\n corners = [Tcamera[:3,3]]\\n for k in itertools.product([-1,1],[-1,1]):\\n point = np.array([0, 0, zdist, 1])\\n point[:2] = np.array([delta_x, delta_y]) * np.array(k)\\n corners.append( np.dot(Tcamera, point)[:3] )\\n return np.array(corners)\",\n \"def matrix(self):\\n\\t\\t# apply yaw, then pitch, then roll\\n\\t\\treturn Matrix((\\n\\t\\t\\t(\\t1,\\t0,\\t\\t\\t\\t\\t\\t\\t0\\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t0,\\tmath.cos(self.roll.val),\\t-math.sin(self.roll.val)\\t),\\n\\t\\t\\t(\\t0,\\tmath.sin(self.roll.val),\\tmath.cos(self.roll.val)\\t\\t)\\n\\t\\t))* Matrix((\\n\\t\\t\\t(\\tmath.cos(self.pitch.val),\\t0,\\tmath.sin(self.pitch.val)\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t\\t1,\\t0 \\t\\t\\t\\t\\t\\t\\t),\\n\\t\\t\\t(\\t-math.sin(self.pitch.val),\\t0,\\tmath.cos(self.pitch.val)\\t)\\n\\t\\t)) * Matrix((\\n\\t\\t\\t(\\tmath.cos(self.yaw.val),\\t-math.sin(self.yaw.val),\\t0\\t),\\n\\t\\t\\t(\\tmath.sin(self.yaw.val),\\tmath.cos(self.yaw.val),\\t\\t0\\t),\\n\\t\\t\\t(\\t0,\\t\\t\\t\\t\\t\\t0,\\t\\t\\t\\t\\t\\t\\t1\\t)\\n\\t\\t))\",\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 matrix_translate_3d(tx: float, ty: float, tz: float) -> np.matrix:\\n return np.matrix([[1, 0, 0, tx], [0, 1, 0, ty], [0, 0, 1, tz], [0, 0, 0, 1]])\",\n \"def rebuildMatrixCache(self):\\n self.converterYUR = Mat4.convertMat(CSYupRight, self.lens.getCoordinateSystem()) * self.lens.getProjectionMat()\",\n \"def get_warp_perspective(transpose_image, h_matrix, dimension):\\n warped_image = np.zeros((dimension[0], dimension[1], 3))\\n for index1 in range(0, transpose_image.shape[0]):\\n for index2 in range(0, transpose_image.shape[1]):\\n new_vec = np.dot(h_matrix, [index1, index2, 1])\\n new_row, new_col, _ = (new_vec / new_vec[2] + 0.4).astype(int)\\n if 5 < new_row < (dimension[0] - 5):\\n if 5 < new_col < (dimension[1] - 5):\\n warped_image[new_row, new_col] = transpose_image[index1, index2]\\n warped_image[new_row - 1, new_col - 1] = transpose_image[index1, index2]\\n warped_image[new_row - 2, new_col - 2] = transpose_image[index1, index2]\\n warped_image[new_row - 3, new_col - 3] = transpose_image[index1, index2]\\n warped_image[new_row + 1, new_col + 1] = transpose_image[index1, index2]\\n warped_image[new_row + 2, new_col + 2] = transpose_image[index1, index2]\\n warped_image[new_row + 3, new_col + 3] = transpose_image[index1, index2]\\n\\n return np.array(warped_image, dtype=np.uint8)\",\n \"def new_mirror(self,alongx,alongy):\\n Knew = K.clone()\\n if alongx:\\n Knew[0,2] = size[0]-Knew[0,2]\\n if alongy:\\n Knew[1,2] = size[1]-Knew[1,2]\\n return CameraInfo(self.size,Knew,self.dist)\",\n \"def createCamera():\\n\\n turnCam = cmds.camera()\\n lookThruAndFrame(turnCam[0])\\n return turnCam\",\n \"def matrix_math_api_examples():\\n \\n print(dingbat.vec2())\\n print(dingbat.vec2(array.array('f', (20, 40))))\\n print(dingbat.mat3())\\n print(dingbat.perspective_matrix(45, 640/480, 0.001, 100.0))\\n print(dingbat.orthographic_matrix(-1.0, 1.0, -1.0, 1.0, 0.001, 100.0))\\n print(dingbat.lookat_matrix(-20, -20, 20, 0, 0, 0, 0, 0, 1))\\n translate = dingbat.translation_matrix(-10, -20, -30)\\n rotate = dingbat.rotation_matrix(45, 0, 1, 0)\\n scale = dingbat.scale_matrix(100, 200, 300)\\n print(translate)\\n print(rotate)\\n print(scale)\\n print(dingbat.multiply_matrices(translate, rotate, scale))\",\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 screenToCamera(self,x,y):\\n #self.x = x\\n #self.y = y\\n new_x = x / (self.surf.get_width() - 1) - 0.5\\n #-(new_x)\\n new_y = y / (self.surf.get_height() - 1)\\n new_y = (1.0 - cy) - 0.5\\n new_z = -self.camNear\\n formula = math3dsol.VectorN((new_x,new_y,new_z))\\n return formula\\n\\n # FINISH ME!!!\",\n \"def decompose_essential_matrix(E, x1, x2):\\n\\n # Fix left camera-matrix\\n Rl = np.eye(3)\\n tl = np.array([[0, 0, 0]]).T\\n Pl = np.concatenate((Rl, tl), axis=1)\\n\\n # TODO: Compute possible rotations and translations\\n \\n # s must be [1, 1, 0]\\n u, s, vh = np.linalg.svd(E)\\n E = u @ np.diag([1, 1, 0]) @ vh\\n u, s, vh = np.linalg.svd(E)\\n\\n w = np.array([[ 0, 1, 0], \\n [-1, 0, 0], \\n [ 0, 0, 1]]) \\n \\n z = np.array([[ 0, -1, 0], \\n [ 1, 0, 0],\\n [ 0, 0, 0]])\\n \\n R1 = u @ w.T @ vh\\n s1 = -u @ z @ u.T\\n R2 = u @ w @ vh\\n s2 = u @ z @ u.T\\n\\n t1 = np.array([[s1[2, 1]], \\n [s1[0, 2]],\\n [s1[1, 0]]])\\n \\n t2 = np.array([[s2[2, 1]], \\n [s2[0, 2]], \\n [s2[1, 0]]]) \\n\\n # Four possibilities\\n Pr = [np.concatenate((R1, t1), axis=1),\\n np.concatenate((R1, t2), axis=1),\\n np.concatenate((R2, t1), axis=1),\\n np.concatenate((R2, t2), axis=1)]\\n\\n # Compute reconstructions for all possible right camera-matrices\\n X3Ds = [infer_3d(x1[:, 0:1], x2[:, 0:1], Pl, x) for x in Pr]\\n\\n # Compute projections on image-planes and find when both cameras see point\\n test = [np.prod(np.hstack((Pl @ np.vstack((X3Ds[i], [[1]])), Pr[i] @ np.vstack((X3Ds[i], [[1]])))) > 0, 1) for i in\\n range(4)]\\n test = np.array(test)\\n idx = np.where(np.hstack((test[0, 2], test[1, 2], test[2, 2], test[3, 2])) > 0.)[0][0]\\n\\n # Choose correct matrix\\n Pr = Pr[idx]\\n\\n return Pl, Pr\",\n \"def project(points, camera_params):\\n # print(camera_params.shape)\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = 2360*np.ones(camera_params.shape[0])\\n # np.ones()\\n # n = np.sum(points_proj**2, axis=1)\\n r = 1\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\",\n \"def fourPointTransform(image, points):\\r\\n\\r\\n topLeft, topRight, bottomLeft, bottomRight = sortFourPoints(points)\\r\\n\\r\\n # Determine the maximum width\\r\\n topWidth = np.sqrt(((topRight[0] - topLeft[0]) ** 2) + ((topRight[1] - topLeft[1]) ** 2))\\r\\n bottomWidth = np.sqrt(((bottomRight[0] - bottomLeft[0]) ** 2) + ((bottomRight[1] - bottomLeft[1]) ** 2))\\r\\n width = max(int(topWidth), int(bottomWidth))\\r\\n\\r\\n # Determine the maximum height\\r\\n leftHeight = np.sqrt(((topLeft[0] - bottomLeft[0]) ** 2) + ((topLeft[1] - bottomLeft[1]) ** 2))\\r\\n rightHeight = np.sqrt(((topRight[0] - bottomRight[0]) ** 2) + ((topRight[1] - bottomRight[1]) ** 2))\\r\\n height = max(int(leftHeight), int(rightHeight))\\r\\n\\r\\n source = np.array([topLeft, topRight, bottomRight, bottomLeft], dtype=\\\"float32\\\")\\r\\n\\r\\n destination = np.array([[0, 0],\\r\\n [width - 1, 0],\\r\\n [width - 1, height - 1],\\r\\n [0, height - 1]], dtype=\\\"float32\\\")\\r\\n\\r\\n transformMatrix = cv2.getPerspectiveTransform(source, destination)\\r\\n\\r\\n return cv2.warpPerspective(image, transformMatrix, (width, height))\",\n \"def ExtractCameraPose(E):\\n u, s, v = np.linalg.svd(E, full_matrices=True)\\n w = np.array([[0, -1, 0],\\n [1, 0, 0],\\n [0, 0, 1]]).reshape(3, 3)\\n c1 = u[:, 2].reshape(3, 1)\\n r1 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c2 = -u[:, 2].reshape(3, 1)\\n r2 = np.dot(np.dot(u, w), v).reshape(3, 3)\\n c3 = u[:, 2].reshape(3, 1)\\n r3 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n c4 = -u[:, 2].reshape(3, 1)\\n r4 = np.dot(np.dot(u, w.T), v).reshape(3, 3)\\n if np.linalg.det(r1) < 0:\\n c1 = -c1\\n r1 = -r1\\n if np.linalg.det(r2) < 0:\\n c2 = -c2\\n r2 = -r2\\n if np.linalg.det(r3) < 0:\\n c3 = -c3\\n r3 = -r3\\n if np.linalg.det(r4) < 0:\\n c4 = -c4\\n r4 = -r4\\n cam_center = np.array([c1, c2, c3, c4])\\n cam_rotation = np.array([r1, r2, r3, r4])\\n return cam_center, cam_rotation\",\n \"def _OrthographicMatrix(scale=1.0):\\r\\n from pi3d.Display import Display\\r\\n M = [[0] * 4 for i in range(4)]\\r\\n M[0][0] = 2.0 * scale / Display.INSTANCE.width\\r\\n M[1][1] = 2.0 * scale / Display.INSTANCE.height\\r\\n #M[2][2] = 2.0 / Display.INSTANCE.width\\r\\n M[2][2] = 2.0 / 10000.0\\r\\n M[3][2] = -1\\r\\n M[3][3] = 1\\r\\n return array(M, dtype=float)\",\n \"def stp_to_camera_transform(self):\\n # setup variables\\n camera_xyz_w = self.cam_pos\\n camera_rot_w = self.cam_rot\\n camera_int_pt_w = self.cam_interest_pt\\n camera_xyz_obj_p = camera_xyz_w - camera_int_pt_w\\n \\n # get the distance from the camera to the world\\n camera_dist_xy = np.linalg.norm(camera_xyz_w[:2])\\n z = [0,0,np.linalg.norm(camera_xyz_w[:3])]\\n\\n # form the rotations about the x and z axis for the object on the tabletop\\n theta = camera_rot_w[0] * np.pi / 180.0\\n phi = -camera_rot_w[2] * np.pi / 180.0 + np.pi / 2.0\\n camera_rot_obj_p_z = np.array([[np.cos(phi), -np.sin(phi), 0],\\n [np.sin(phi), np.cos(phi), 0],\\n [0, 0, 1]])\\n\\n camera_rot_obj_p_x = np.array([[1, 0, 0],\\n [0, np.cos(theta), -np.sin(theta)],\\n [0, np.sin(theta), np.cos(theta)]])\\n \\n # form the full rotation matrix, swapping axes to match maya\\n camera_md = np.array([[0, 1, 0],\\n [1, 0, 0],\\n [0, 0, -1]])\\n camera_rot_obj_p = camera_md.dot(camera_rot_obj_p_z.dot(camera_rot_obj_p_x))\\n camera_rot_obj_p = camera_rot_obj_p.T\\n \\n # form the full object to camera transform\\n R_stp_camera = camera_rot_obj_p\\n t_stp_camera = np.array(z)\\n return RigidTransform(rotation=R_stp_camera,\\n translation=t_stp_camera,\\n from_frame='stp', to_frame='camera')\",\n \"def orthographic_matrix(self) -> TransformationMatrixType:\\n near, far = self._clipping[self.projection_mode.value]\\n return orthographic_matrix(self.fov, self.aspect_ratio, near, far)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[1, 1]=c\\n self.matrix[1, 2]=s\\n self.matrix[2, 1]=-s\\n self.matrix[2, 2]=c\\n return self.matrix\",\n \"def getInverseMatrix(self) -> CMatrix4:\\n ...\",\n \"def camera(*args, aspectRatio: Union[float, bool]=0.0, cameraScale: Union[float, bool]=0.0,\\n centerOfInterest: Union[float, bool]=0.0, clippingPlanes: bool=True, depthOfField:\\n bool=True, displayFieldChart: bool=True, displayFilmGate: bool=True,\\n displayFilmOrigin: bool=True, displayFilmPivot: bool=True, displayGateMask:\\n bool=True, displayResolution: bool=True, displaySafeAction: bool=True,\\n displaySafeTitle: bool=True, fStop: Union[float, bool]=0.0, farClipPlane:\\n Union[float, bool]=0.0, farFocusDistance: Union[float, bool]=0.0, filmFit:\\n Union[AnyStr, bool]=\\\"\\\", filmFitOffset: Union[float, bool]=0.0, filmRollOrder:\\n Union[AnyStr, bool]=\\\"\\\", filmRollValue: Union[float, bool]=0.0, filmTranslateH:\\n Union[float, bool]=0.0, filmTranslateV: Union[float, bool]=0.0, focalLength:\\n Union[float, bool]=0.0, focusDistance: Union[float, bool]=0.0, homeCommand:\\n Union[AnyStr, bool]=\\\"\\\", horizontalFieldOfView: Union[float, bool]=0.0,\\n horizontalFilmAperture: Union[float, bool]=0.0, horizontalFilmOffset: Union[float,\\n bool]=0.0, horizontalPan: Union[float, bool]=0.0, horizontalRollPivot: Union[float,\\n bool]=0.0, horizontalShake: Union[float, bool]=0.0, journalCommand: bool=True,\\n lensSqueezeRatio: Union[float, bool]=0.0, lockTransform: bool=True, motionBlur:\\n bool=True, name: Union[AnyStr, bool]=\\\"\\\", nearClipPlane: Union[float, bool]=0.0,\\n nearFocusDistance: Union[float, bool]=0.0, orthographic: bool=True,\\n orthographicWidth: Union[float, bool]=0.0, overscan: Union[float, bool]=0.0,\\n panZoomEnabled: bool=True, position: Union[List[float, float, float], bool]=None,\\n postScale: Union[float, bool]=0.0, preScale: Union[float, bool]=0.0, renderPanZoom:\\n bool=True, rotation: Union[List[float, float, float], bool]=None, shakeEnabled:\\n bool=True, shakeOverscan: Union[float, bool]=0.0, shakeOverscanEnabled: bool=True,\\n shutterAngle: Union[float, bool]=0.0, startupCamera: bool=True,\\n stereoHorizontalImageTranslate: Union[float, bool]=0.0,\\n stereoHorizontalImageTranslateEnabled: bool=True, verticalFieldOfView: Union[float,\\n bool]=0.0, verticalFilmAperture: Union[float, bool]=0.0, verticalFilmOffset:\\n Union[float, bool]=0.0, verticalLock: bool=True, verticalPan: Union[float, bool]=0.0,\\n verticalRollPivot: Union[float, bool]=0.0, verticalShake: Union[float, bool]=0.0,\\n worldCenterOfInterest: Union[List[float, float, float], bool]=None, worldUp:\\n Union[List[float, float, float], bool]=None, zoom: Union[float, bool]=0.0, q=True,\\n query=True, e=True, edit=True, **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def __init__(self, at=(0, 0, 0), eye=(0, 0, -0.1), lens=None,\\r\\n is_3d=True, scale=1.0):\\r\\n super(Camera, self).__init__()\\r\\n\\r\\n self.at = at\\r\\n self.start_eye = eye # for reset with different lens settings\\r\\n self.eye = [eye[0], eye[1], eye[2]]\\r\\n if lens == None:\\r\\n from pi3d.Display import Display\\r\\n lens = [Display.INSTANCE.near, Display.INSTANCE.far, Display.INSTANCE.fov,\\r\\n Display.INSTANCE.width / float(Display.INSTANCE.height)]\\r\\n self.lens = lens\\r\\n self.view = _LookAtMatrix(at, eye, [0, 1, 0])\\r\\n if is_3d:\\r\\n self.projection = _ProjectionMatrix(lens[0], lens[1], lens[2] / scale, lens[3])\\r\\n else:\\r\\n self.projection = _OrthographicMatrix(scale=scale)\\r\\n self.model_view = dot(self.view, self.projection)\\r\\n # Apply transform/rotation first, then shift into perspective space.\\r\\n self.mtrx = array(self.model_view, copy=True)\\r\\n # self.L_reflect = _LookAtMatrix(at,eye,[0,1,0],reflect=True)\\r\\n self.rtn = [0.0, 0.0, 0.0]\\r\\n\\r\\n self.was_moved = True\",\n \"def projection_matrix(self) -> TransformationMatrixType:\\n if self._projection_matrix is None:\\n if self.projection_mode == Projection.TOP_DOWN:\\n self._projection_matrix = self.orthographic_matrix\\n else:\\n self._projection_matrix = self.perspective_matrix\\n\\n return self._projection_matrix\",\n \"def to_image_frame(loc):\\n loc = np.dot(Hinv, loc) # to camera frame\\n return loc / loc[2] # to pixels (from millimeters)\",\n \"def GroundToImage_RzRyRz(self, groundPoints):\\n X0 = float(self.exteriorOrientationParameters[0])\\n Y0 = float(self.exteriorOrientationParameters[1])\\n Z0 = float(self.exteriorOrientationParameters[2])\\n\\n xp = float(self.camera.principalPoint[0])\\n yp = float(self.camera.principalPoint[1])\\n\\n R = self.rotationMatrix_RzRyRz\\n r11 = float(R[0, 0])\\n r12 = float(R[0, 1])\\n r13 = float(R[0, 2])\\n r21 = float(R[1, 0])\\n r22 = float(R[1, 1])\\n r23 = float(R[1, 2])\\n r31 = float(R[2, 0])\\n r32 = float(R[2, 1])\\n r33 = float(R[2, 2])\\n\\n f = self.camera.focalLength\\n\\n camPoints = []\\n\\n for i in range(groundPoints.shape[0]):\\n x = xp - (f) * (((r11 * (groundPoints[i, 0] - X0) + r21 * (groundPoints[i, 1] - Y0) + r31 * (\\n groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (\\n groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))\\n y = yp - (f) * (((r12 * (groundPoints[i, 0] - X0) + r22 * (groundPoints[i, 1] - Y0) + r32 * (\\n groundPoints[i, 2] - Z0)) / (r13 * (groundPoints[i, 0] - X0) + r23 * (\\n groundPoints[i, 1] - Y0) + r33 * (groundPoints[i, 2] - Z0))))\\n\\n camPoints.append([x, y])\\n\\n # return self.CameraToImage(np.array(camPoints))\\n return (np.array(camPoints))\",\n \"def _get_rotation_matrix(transform):\\n # caution: UE4 is using left-hand ortation order\\n roll = np.deg2rad(-transform.rotation.roll)\\n pitch = np.deg2rad(-transform.rotation.pitch)\\n yaw = np.deg2rad(transform.rotation.yaw)\\n sr, cr = np.sin(roll), np.cos(roll)\\n sp, cp = np.sin(pitch), np.cos(pitch)\\n sy, cy = np.sin(yaw), np.cos(yaw)\\n rotation_matrix = np.array([[cy * cp, -sy * sr + cy * sp * sr, cy * sp * cr + sy * sr],\\n [sy * cp, cy * sp * sr + cy * sr, -cy * sr + sy * sp * cr],\\n [-sp, cp * sr, cp * cr]])\\n return rotation_matrix\",\n \"def XYZ_to_RGB_matrix(self):\\n\\n if not self._use_derived_XYZ_to_RGB_matrix:\\n return self._XYZ_to_RGB_matrix\\n else:\\n return self._derived_XYZ_to_RGB_matrix\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[0, 0]=c\\n self.matrix[0, 1]=s\\n self.matrix[1, 0]=-s\\n self.matrix[1, 1]=c\\n return self.matrix\",\n \"def transformation_matrix(self):\\n t = np.array([[0.0], [0.0], [0.0]])\\n Rt = np.hstack([self.rotation_matrix, t])\\n return np.vstack([Rt, np.array([0.0, 0.0, 0.0, 1.0])])\",\n \"def camera(target_size: Optional[Tuple[int, int]] = None, rgb: bool = True) -> Tensor:\\n return imread(HERE+'camera.jpg', target_size=target_size, rgb=rgb)\",\n \"def calculate_pitch_yaw_roll(landmarks_2D, cam_w=256, cam_h=256,\\n radians=False):\\n\\n assert landmarks_2D is not None, 'landmarks_2D is None'\\n\\n # Estimated camera matrix values.\\n c_x = cam_w / 2\\n c_y = cam_h / 2\\n f_x = c_x / np.tan(60 / 2 * np.pi / 180)\\n f_y = f_x\\n camera_matrix = np.float32([[f_x, 0.0, c_x], [0.0, f_y, c_y],\\n [0.0, 0.0, 1.0]])\\n camera_distortion = np.float32([0.0, 0.0, 0.0, 0.0, 0.0])\\n\\n # dlib (68 landmark) trached points\\n # TRACKED_POINTS = [17, 21, 22, 26, 36, 39, 42, 45, 31, 35, 48, 54, 57, 8]\\n # wflw(98 landmark) trached points\\n # TRACKED_POINTS = [33, 38, 50, 46, 60, 64, 68, 72, 55, 59, 76, 82, 85, 16]\\n # X-Y-Z with X pointing forward and Y on the left and Z up.\\n # The X-Y-Z coordinates used are like the standard coordinates of ROS (robotic operative system)\\n # OpenCV uses the reference usually used in computer vision:\\n # X points to the right, Y down, Z to the front\\n landmarks_3D = np.float32([\\n [6.825897, 6.760612, 4.402142], # LEFT_EYEBROW_LEFT, \\n [1.330353, 7.122144, 6.903745], # LEFT_EYEBROW_RIGHT, \\n [-1.330353, 7.122144, 6.903745], # RIGHT_EYEBROW_LEFT,\\n [-6.825897, 6.760612, 4.402142], # RIGHT_EYEBROW_RIGHT,\\n [5.311432, 5.485328, 3.987654], # LEFT_EYE_LEFT,\\n [1.789930, 5.393625, 4.413414], # LEFT_EYE_RIGHT,\\n [-1.789930, 5.393625, 4.413414], # RIGHT_EYE_LEFT,\\n [-5.311432, 5.485328, 3.987654], # RIGHT_EYE_RIGHT,\\n [-2.005628, 1.409845, 6.165652], # NOSE_LEFT,\\n [-2.005628, 1.409845, 6.165652], # NOSE_RIGHT,\\n [2.774015, -2.080775, 5.048531], # MOUTH_LEFT,\\n [-2.774015, -2.080775, 5.048531], # MOUTH_RIGHT,\\n [0.000000, -3.116408, 6.097667], # LOWER_LIP,\\n [0.000000, -7.415691, 4.070434], # CHIN\\n ])\\n landmarks_2D = np.asarray(landmarks_2D, dtype=np.float32).reshape(-1, 2)\\n\\n # Applying the PnP solver to find the 3D pose of the head from the 2D position of the landmarks.\\n # retval - bool\\n # rvec - Output rotation vector that, together with tvec, brings points from the world coordinate system to the camera coordinate system.\\n # tvec - Output translation vector. It is the position of the world origin (SELLION) in camera co-ords\\n _, rvec, tvec = cv2.solvePnP(landmarks_3D, landmarks_2D,\\n camera_matrix, camera_distortion)\\n #Get as input the rotational vector, Return a rotational matrix\\n\\n # const double PI = 3.141592653;\\n # double thetaz = atan2(r21, r11) / PI * 180;\\n # double thetay = atan2(-1 * r31, sqrt(r32*r32 + r33*r33)) / PI * 180;\\n # double thetax = atan2(r32, r33) / PI * 180;\\n \\n rmat, _ = cv2.Rodrigues(rvec)\\n pose_mat = cv2.hconcat((rmat, tvec))\\n _, _, _, _, _, _, euler_angles = cv2.decomposeProjectionMatrix(pose_mat)\\n return map(lambda k: k[0], euler_angles) # euler_angles contain (pitch, yaw, roll)\",\n \"def camera_transformation_from_pose(azimutal, elevation):\\n azimutal, elevation = azimutal * 2. * np.pi / 360., elevation * 2. * np.pi / 360.\\n azimutal *= -1.\\n elevation *= -1.\\n r_y = np.array([[np.cos(elevation), 0, np.sin(elevation)],\\n [0, 1, 0],\\n [-np.sin(elevation), 0, np.cos(elevation)]])\\n r_z = np.array([[np.cos(azimutal), -np.sin(azimutal), 0],\\n [np.sin(azimutal), np.cos(azimutal), 0],\\n [0, 0, 1]])\\n r = r_z.dot(r_y)\\n # world_to_camera matrix, camera_to_world matrix\\n return r, np.linalg.inv(r)\",\n \"def setBillboardMatrix(self):\\n \\n wolrd_matrix_plug = OpenMaya.MPlug(self.thisObj, self.worldMatrix).elementByLogicalIndex(0)\\n world_matrix = OpenMaya.MFnMatrixData(wolrd_matrix_plug.asMObject()).matrix()\\n float_matrix = self.matrixToFloatMatrix(world_matrix)\\n wolrd_rot_matrix = self.removeMatrixTranslate(float_matrix.inverse())\\n\\n camera_DagPath = OpenMaya.MDagPath()\\n self.view.getCamera(camera_DagPath)\\n camera_matrix = self.matrixToFloatMatrix(camera_DagPath.inclusiveMatrix())\\n camera_rot_matrix = self.removeMatrixTranslate(camera_matrix)\\n \\n mult_matrix = camera_rot_matrix * wolrd_rot_matrix\\n mult_float_matrix = self.matrixToFloatMatrix(mult_matrix)\\n \\n # set matrix\\n float16_ptr = self.floatArrayToPrt(mult_float_matrix)\\n glFT.glMultMatrixf(float16_ptr)\\n \\n # set scale\\n sX, sY, sZ = self.getScale()\\n glFT.glScalef(sX, sY, sZ)\",\n \"def calibration_matrix(resolution_px, diagonal_mm, focal_len_mm, skew=0.):\\n # Camera intrinsics parameters\\n resolution_x_px, resolution_y_px = resolution_px # image resolution in pixels\\n diagonal_px = np.sqrt(resolution_x_px**2 + resolution_y_px**2)\\n\\n resolution_x_mm = resolution_x_px / diagonal_px * diagonal_mm\\n resolution_y_mm = resolution_y_px / diagonal_px * diagonal_mm\\n\\n skew = skew # \\\"skew param will be zero for most normal cameras\\\" Hartley, Zisserman\\n\\n m_x = resolution_x_px / resolution_x_mm\\n m_y = resolution_y_px / resolution_y_mm\\n\\n alpha_x = focal_len_mm * m_x # focal length of the camera in pixels\\n alpha_y = focal_len_mm * m_y # focal length of the camera in pixels\\n\\n x_0 = resolution_x_px / 2\\n y_0 = resolution_y_px / 2\\n\\n return np.array([[alpha_x, skew, x_0], [0, alpha_y, y_0], [0, 0, 1]])\",\n \"def show_planes(im, spacing=10): # pragma: no cover\\n s = spacing\\n if np.squeeze(im.ndim) < 3:\\n raise Exception('This view is only necessary for 3D images')\\n x, y, z = (np.array(im.shape)/2).astype(int)\\n im_xy = im[:, :, z]\\n im_xz = im[:, y, :]\\n im_yz = np.rot90(im[x, :, :])\\n\\n new_x = im_xy.shape[0] + im_yz.shape[0] + s\\n\\n new_y = im_xy.shape[1] + im_xz.shape[1] + s\\n\\n new_im = np.zeros([new_x + 2*s, new_y + 2*s], dtype=im.dtype)\\n\\n # Add xy image to upper left corner\\n new_im[s:im_xy.shape[0] + s,\\n s:im_xy.shape[1] + s] = im_xy\\n # Add xz image to lower left coner\\n x_off = im_xy.shape[0] + 2*s\\n y_off = im_xy.shape[1] + 2*s\\n new_im[s:s + im_xz.shape[0],\\n y_off:y_off + im_xz.shape[1]] = im_xz\\n new_im[x_off:x_off + im_yz.shape[0],\\n s:s + im_yz.shape[1]] = im_yz\\n\\n return new_im\",\n \"def perspectiveNormalizationXform(self):\\n return np.array([[1.0/np.tan(self.view_angle_h), 0, 0, 0],\\n [0, 1.0/np.tan(self.view_angle_v), 0, 0],\\n [0, 0, (self.far + self.near)/(self.far - self.near),\\n 2*self.far*self.near/(self.far - self.near)],\\n [0, 0, -1, 0]])\",\n \"def lookAtLH(eye, target, up):\\n zaxis = (target - eye).normalize()\\n xaxis = up.cross(zaxis).normalize()\\n yaxis = zaxis.cross(xaxis).normalize()\\n\\n ex = -xaxis.dot(eye)\\n ey = -yaxis.dot(eye)\\n ez = -zaxis.dot(eye)\\n\\n m = [\\n [xaxis.x, yaxis.x, zaxis.x, 0],\\n [xaxis.y, yaxis.y, zaxis.y, 0],\\n [xaxis.z, yaxis.z, zaxis.z, 0],\\n [ex, ey, ez, 1]\\n ]\\n return Matrix(m)\",\n \"def CameraToImage(self, cameraPoints):\\n # setting up the required matrices\\n a0 = self.innerOrientationParameters[0]\\n b0 = self.innerOrientationParameters[1]\\n a1 = self.innerOrientationParameters[2]\\n a2 = self.innerOrientationParameters[3]\\n b1 = self.innerOrientationParameters[4]\\n b2 = self.innerOrientationParameters[5]\\n\\n if np.isscalar(a0):\\n\\n R = np.array([[a1, a2], [b1, b2]])\\n T = np.array([[a0], [b0]])\\n\\n else:\\n R = np.array([[a1[0], a2[0]], [b1[0], b2[0]]])\\n T = np.array([[a0[0]], [b0[0]]])\\n\\n cameraPoints = cameraPoints.T\\n # computing the transformation to the image system\\n return (T + np.dot(R, cameraPoints)).T\",\n \"def d4out():\\n\\td4x.moveTo(d4x_out)\\n\\td4y.moveTo(d4y_out)\",\n \"def camera(self):\\n return self.__camera\",\n \"def base_projection_matrix(self, fiber):\\n return matrix(ZZ, fiber.vertices()).right_kernel_matrix()\",\n \"def camera_to_object_transform(self):\\n # form the full object to camera transform\\n T_stp_camera = self.stp_to_camera_transform()\\n T_obj_stp = self.object_to_stp_transform()\\n T_obj_camera = T_stp_camera.dot(T_obj_stp)\\n return T_obj_camera\",\n \"def transpose(self):\\r\\n m11,m12,m13,m14,m21,m22,m23,m24,m31,m32,m33,m34,m41,m42,m43,m44 = self.mlist\\r\\n return mat4(m11,m21,m31,m41,\\r\\n m12,m22,m32,m42,\\r\\n m13,m23,m33,m43,\\r\\n m14,m24,m34,m44)\",\n \"def render_4d(polyhedron, **kwds):\\n projection_direction = None\\n try: \\n projection_direction = kwds.pop('projection_directior')\\n except KeyError:\\n for ineq in polyhedron.inequality_generator():\\n center = [v() for v in ineq.incident() if v.is_vertex()]\\n center = sum(center) / len(center)\\n if not center.is_zero(): \\n projection_direction = center\\n break\\n projection_3d = Projection(polyhedron).schlegel(projection_direction)\\n return render_3d(projection_3d, **kwds)\",\n \"def project(points, camera_params):\\n points_proj = rotate(points, camera_params[:, :3])\\n points_proj += camera_params[:, 3:6]\\n points_proj = -points_proj[:, :2] / points_proj[:, 2, np.newaxis]\\n f = camera_params[:, 6]\\n k1 = camera_params[:, 7]\\n k2 = camera_params[:, 8]\\n n = np.sum(points_proj ** 2, axis=1)\\n r = 1 + k1 * n + k2 * n ** 2\\n points_proj *= (r * f)[:, np.newaxis]\\n return points_proj\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.604629","0.5690877","0.566058","0.546934","0.5419739","0.53992414","0.53747255","0.53564847","0.53442174","0.533645","0.53151274","0.52816457","0.52754575","0.5259618","0.5208826","0.5179219","0.5169666","0.51681334","0.51548636","0.5148781","0.5135079","0.5129656","0.51102906","0.510059","0.50935936","0.50799334","0.506196","0.5019972","0.50160646","0.5014166","0.4992957","0.49922663","0.49894023","0.4979712","0.497291","0.49460602","0.49332026","0.49332026","0.4916826","0.49033675","0.4895077","0.48719153","0.48700872","0.48668402","0.48549613","0.4849591","0.48452377","0.48340413","0.48208877","0.48179552","0.48134172","0.4805835","0.47955754","0.4795031","0.47946337","0.4794265","0.47938424","0.47729883","0.47717756","0.4770576","0.476721","0.476661","0.4755227","0.47552216","0.4748851","0.4748851","0.47414738","0.47407869","0.47377774","0.47364053","0.472324","0.47118616","0.47070926","0.4706413","0.46991473","0.46990076","0.4694677","0.46840933","0.467323","0.46727622","0.4671016","0.46689487","0.46601865","0.4658534","0.46521857","0.46371907","0.4634041","0.46288824","0.4628208","0.461608","0.46109062","0.46093792","0.4608542","0.46055278","0.4602683","0.45934075","0.45856035","0.45809686","0.45800996","0.4576044","0.45745492"],"string":"[\n \"0.604629\",\n \"0.5690877\",\n \"0.566058\",\n \"0.546934\",\n \"0.5419739\",\n \"0.53992414\",\n \"0.53747255\",\n \"0.53564847\",\n \"0.53442174\",\n \"0.533645\",\n \"0.53151274\",\n \"0.52816457\",\n \"0.52754575\",\n \"0.5259618\",\n \"0.5208826\",\n \"0.5179219\",\n \"0.5169666\",\n \"0.51681334\",\n \"0.51548636\",\n \"0.5148781\",\n \"0.5135079\",\n \"0.5129656\",\n \"0.51102906\",\n \"0.510059\",\n \"0.50935936\",\n \"0.50799334\",\n \"0.506196\",\n \"0.5019972\",\n \"0.50160646\",\n \"0.5014166\",\n \"0.4992957\",\n \"0.49922663\",\n \"0.49894023\",\n \"0.4979712\",\n \"0.497291\",\n \"0.49460602\",\n \"0.49332026\",\n \"0.49332026\",\n \"0.4916826\",\n \"0.49033675\",\n \"0.4895077\",\n \"0.48719153\",\n \"0.48700872\",\n \"0.48668402\",\n \"0.48549613\",\n \"0.4849591\",\n \"0.48452377\",\n \"0.48340413\",\n \"0.48208877\",\n \"0.48179552\",\n \"0.48134172\",\n \"0.4805835\",\n \"0.47955754\",\n \"0.4795031\",\n \"0.47946337\",\n \"0.4794265\",\n \"0.47938424\",\n \"0.47729883\",\n \"0.47717756\",\n \"0.4770576\",\n \"0.476721\",\n \"0.476661\",\n \"0.4755227\",\n \"0.47552216\",\n \"0.4748851\",\n \"0.4748851\",\n \"0.47414738\",\n \"0.47407869\",\n \"0.47377774\",\n \"0.47364053\",\n \"0.472324\",\n \"0.47118616\",\n \"0.47070926\",\n \"0.4706413\",\n \"0.46991473\",\n \"0.46990076\",\n \"0.4694677\",\n \"0.46840933\",\n \"0.467323\",\n \"0.46727622\",\n \"0.4671016\",\n \"0.46689487\",\n \"0.46601865\",\n \"0.4658534\",\n \"0.46521857\",\n \"0.46371907\",\n \"0.4634041\",\n \"0.46288824\",\n \"0.4628208\",\n \"0.461608\",\n \"0.46109062\",\n \"0.46093792\",\n \"0.4608542\",\n \"0.46055278\",\n \"0.4602683\",\n \"0.45934075\",\n \"0.45856035\",\n \"0.45809686\",\n \"0.45800996\",\n \"0.4576044\",\n \"0.45745492\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84689,"cells":{"query":{"kind":"string","value":"Get the ratio of ICX to sICX."},"document":{"kind":"string","value":"def getRate(self) -> int:\n if (self._total_stake.get() + self._daily_reward.get()) == 0:\n rate = DENOMINATOR\n else:\n rate = (self._total_stake.get() + self._daily_reward.get()) * DENOMINATOR // self.sICX_score.totalSupply()\n return rate"},"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 csi(self):\n return self.table[0, 0] / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0])","def cci(self) -> float:\n return self._cci","def coi(self, s):\n return 2 ** 0.5 * s","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass","def icx(self) -> int:\n return self._icx","def calculate_cci(hunterlab):\n return 1000 * (hunterlab[1]) / (hunterlab[0] * hunterlab[2])","def Insurance(Md,X):\n u = X[iu]\n b = Md.b()\n return u/b - u/(1-u+u*b)","def pixels_to_inches(self, px: float) -> float:\r\n \r\n return (px / self.ratio[0]) * self.ratio[1]","def sampling_ratio(self):\n return self.coincidences / self.n","def resolution_from_icov(icov):\n #- force symmetry since due to rounding it might not be exactly symmetric\n icov = 0.5*(icov + icov.T)\n \n if issparse(icov):\n icov = icov.toarray()\n\n sqrt_icov = sym_sqrt(icov)\n norm_vector = np.sum(sqrt_icov, axis=1)\n R = np.outer(norm_vector**(-1), np.ones(norm_vector.size)) * sqrt_icov\n ivar = norm_vector**2 #- Bolton & Schlegel 2010 Eqn 13\n return R, ivar","def get_at_gc_ratio(at, gc):\n return at / gc","def get_at_gc_ratio(at, gc):\n return at / gc","def IntToCoverage(intensity, caliConst):\n return (np.sqrt((intensity - caliConst[0])))/caliConst[1];","def cash_ratio(self):\n return self.cash / self.current_liabilities","def _compute_isometric_ratio(self, threshold):\n perimeter = 0 # dS\n volume = 0\n\n # A - inside set; B - outside set\n set_A = self.x >= threshold\n set_B = self.x < threshold\n \n for a_idx in np.where(set_A)[0]:\n # Compute inside set volume\n volume += self.degree[a_idx]\n\n for b_idx in np.where(set_B)[0]:\n # Compute boundaey betwen inside and outside sets\n perimeter += self.weights[a_idx, b_idx]\n \n # Compute isometric ratio\n iso_ratio = perimeter / volume\n return iso_ratio","def CIS(self):\n return self.get_class_average(self.CIS_class_level)","def get_meters_to_pixels_coefficient():\n return 1/get_pixels_to_meters_coefficient()","def calculateR(sapienses: list) -> float:\n r = 0\n for i in sapienses:\n r = r + i.numberInfected\n r=r/I0\n r = r*S/(S+R+D)\n return r","def _chisquare_value(self):\n x2 = np.sum((np.absolute(self.observed - self.expected) - (0.5 * self.continuity_correction)) ** 2 /\n self.expected)\n\n return x2","def aspect_ratio(self):\n ar = (self._block[1] >> 2) & 0x03\n asp_ratio = ''\n\n if ar == 0x00:\n asp_ratio = '4:3 AR'\n elif ar == 0x01:\n asp_ratio = '16:9 AR'\n elif ar == 0x02:\n asp_ratio = '16:10 AR'\n elif ar == 0x03:\n asp_ratio = '15:9 AR'\n\n return asp_ratio","def _get_n(self):#@Needs to fix it for general case\n n_60 = 0.55 * 1 * 1 * 0.75 * self._data[SoilProperty.SPT_N] /0.6\n if not self.is_clayey() and n_60>15: #apply dilitracy correction\n n_60 = 15 + 0.5 * (n_60 - 15)\n return n_60","def idog_conv(sc):\n return math.sqrt(sc*2)","def __calculate_si_cf(self) -> Tuple[np.ndarray, np.ndarray]:\n for image in self.it:\n im = ImageMetrics(image)\n si, cf = im.calculate_si_cf()\n self.si.append(si)\n self.cf.append(cf)\n self.norm_si.append(si / self.max_db_si)\n self.norm_cf.append(cf / self.max_db_cf)\n return (\n np.vstack((self.cf, self.si)).T,\n np.vstack((self.norm_cf, self.norm_si)).T,\n )","def _ratio(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray:\n out = sim / ref\n out.attrs[\"units\"] = \"\"\n return out","def cm2inch(x: Union[float, Sequence[float], NDArray]) -> Sequence[float]:\n return list(np.array(x) / 2.54)","def exchange_ratio(delta_x, salience, power, dominator):\n\treturn (delta_x * salience * power) / dominator","def inflation_ratio(old_year,new_year):\n # todo memoization\n amount = 1\n url_address = \"https://data.bls.gov/cgi-bin/cpicalc.pl?cost1={}&year1={}&year2={}\".format(int(amount),int(old_year),int(new_year))\n print(url_address)\n with urllib.request.urlopen(url_address) as url:\n\n html_doc = url.read()\n\n soup = BeautifulSoup(html_doc,\"lxml\")\n\n\n return float(soup.find(\"span\", {\"id\": \"answer\"}).contents[0][1:])","def get_scaling_ratio(img):\n\n healthy_img_area = 4872 * 6496\n input_img_area = img.shape[0] * img.shape[1]\n ratio = input_img_area / healthy_img_area\n return ratio","def norm_icdf(x):\n return norm.ppf(x)","def getUIQM(x):\n x = x.astype(np.float32)\n ### from https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7300447\n # c1 = 0.4680; c2 = 0.2745; c3 = 0.2576\n ### from https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7300447\n c1 = 0.0282\n c2 = 0.2953\n c3 = 3.5753\n\n uicm = _uicm(x)\n uism = _uism(x)\n uiconm = _uiconm(x, 8)\n uiqm = (c1 * uicm) + (c2 * uism) + (c3 * uiconm)\n return uiqm","def s_multiplier(self):\n return 4 * np.pi * (self.bins[:, 1]/2)**2","def _get_cm_per_pixel(self, diameter):\n CM_PER_INCH = 2.54\n pixels_per_inch = 2 / diameter\n cm_per_pixel = CM_PER_INCH * pixels_per_inch\n return cm_per_pixel","def get_ICC(A,B):\n n = float(A.size)\n mean_img = (A + B)/2.\n\n MS_w = np.sum((A - mean_img)**2 + (B-mean_img)**2)/n\n MS_b = 2/(n-1) * np.sum((mean_img - np.mean(mean_img))**2)\n\n return (MS_b - MS_w)/(MS_b + MS_w)","def diffuse_ratio(DIFF_data,ghi_data): \n K = DIFF_data/ghi_data\n \n return K","def ci_OLS(OLSMod):\r\n if hasattr(OLSMod, 'xtx'):\r\n xtx = OLSMod.xtx # (array) k x k projection matrix (includes constant)\r\n elif hasattr(OLSMod, 'hth'):\r\n xtx = OLSMod.hth # (array) k x k projection matrix (includes constant)\r\n diag = np.diagonal(xtx)\r\n scale = xtx/diag \r\n eigval = np.linalg.eigvals(scale)\r\n max_eigval = max(eigval)\r\n min_eigval = min(eigval)\r\n ci_result = sqrt(max_eigval/min_eigval)\r\n \r\n return ci_result","def aic_c(self):\n if hasattr(self, '_aic_c'):\n return self._aic_c\n else:\n k = len(self.params)\n n = self.data['n'].sum()\n self._aic_c = self.aic() + (2*k**2 + 2*k)/(n - k - 1)\n return self._aic_c","def pss(self):\n return (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / \\\n ((self.table[0, 0] + self.table[1, 0]) * (self.table[0, 1] + self.table[1, 1]))","def _get_cu(self):\n c_undrained=0\n #group_index = self._data['GI']\n if self.is_clayey():\n c_undrained = self.qu(self._data[SoilProperty.N60])/2\n #c_undrained=_clamp(c_undrained, 10, 103)\n # Plasix calculation needs very small c_undrained\n #if c_undrained<0.21:\n # c_undrained = 0.21\n #use 0.2 as per plasix recommendation\n return c_undrained#the cu is always 103 check with small value of n_60, some mistake maybe","def coherence_from_spectral(Sw):\r\n\r\n Sxx = Sw[0, 0].real\r\n Syy = Sw[1, 1].real\r\n\r\n Sxy_mod_sq = (Sw[0, 1] * Sw[1, 0]).real\r\n Sxy_mod_sq /= Sxx\r\n Sxy_mod_sq /= Syy\r\n return Sxy_mod_sq","def rectifiercap(Iload, fswitch, dVout):\n C = Iload / (fswitch * dVout)\n return C","def anti_squat_percent(ic_xz, wheel_center, wheel_base, center_gravity_height):\n # using angle finder from longitudinal instant center to wheel center.\n as_angle = (two_d_horizontal_angle([ic_xz[0], ic_xz[1]], [wheel_center[0], wheel_center[2]])) * math.pi / 180\n # calculates anti-squat percent from tan(angle)*(WB/c of g height) * 100\n as_tan = math.tan(as_angle)\n as_percent = (as_tan / (center_gravity_height / wheel_base)) * 100\n return as_percent","def infected_ratio(self):\n if self.max_pop != 0:\n return int(self.infected_pop) / self.max_pop\n else:\n return 1","def calc_iqr(sig):\n # iqr = subtract(*percentile(sig, [75, 25]))\n return np.percentile(sig, 75) - np.percentile(sig, 25)","def compratio(self) :\n\t\ttry :\n\t\t\treturn self._compratio\n\t\texcept Exception as e:\n\t\t\traise e","def x_rate(self):\n values = self._interpolate_table(\"x\", derivative_order=1)\n # values += self._corrections(('ortho_eop', iers.ortho_eop, 0, 1e-6),\n # ('pmsdnut2', iers.pmsdnut2, 0, 1e-6))\n return values","def proper_annulus_centres(self) -> Quantity:\n return self._proper_ann_centres","def _icmf(self, ms):\n return self._pot.a * numpy.sqrt(ms) / (1 - numpy.sqrt(ms))","def impurityBis(x,iw,size):\n Vi = 0\n ai =2*a0+iw*1.5*a0+0.5*(iw-1)*a0\n \n if (x > ai-size and x < ai):\n Vi = 300/Eh\n elif(x == ai or x == ai-size):\n Vi = 150/Eh\n \n return Vi","def _get_scaling(root):\n dpi = root.winfo_fpixels(\"1i\")\n scaling = dpi / 72.0\n logger.debug(\"dpi: %s, scaling: %s'\", dpi, scaling)\n return scaling","def div(self):\n a = self.nums()\n x = LibraryFunctions.per(a, 0.9) - LibraryFunctions.per(a, 0.1)\n return x / 2.58","def clarity_conversion(string):\n if (string == 'I1'):\n return 0.125\n if (string == 'SI2'):\n return 0.25\n if (string == 'SI1'):\n return 0.375\n if (string == 'VS2'):\n return 0.5\n if (string == 'VS1'):\n return 0.625\n if (string == 'VVS2'):\n return 0.75\n if (string == 'VVS1'):\n return 0.875\n if (string == 'IF'):\n return 1","def p2cx(self, client, percent):\r\n pixel = client.p2cx(percent)\r\n return pixel","def bla_ipr(x):\n phi = x / np.sqrt(np.sum(x**2))\n return np.sum(phi**4)\n # if s2 < MACH_EPSILON:\n # # Zero sum. Could happen for veeery small overall prevalence.\n # return 0.\n # else:\n # return np.sum(x2 * x2 / (s2 * s2))","def getResolution(s) -> int:\n unit = getDurationUnit(s)\n #number of ticks is 1 / unit (if that is an integer)\n ticksPerQuarter = unit.denominator / unit.numerator\n if ticksPerQuarter.is_integer():\n return int(unit.denominator / unit.numerator)\n else:\n print(s.filePath, ' non integer number of ticks per Quarter')\n return 0","def __conv_inch(length_mm):\n return length_mm / 25.4","def current_ratio(self):\n return self.current_assets / self.current_liabilities","def ds_ratio(group):\n nix_count = (group=='nix').sum()\n top_count = (group=='top').sum()\n ratio = nix_count/(nix_count+top_count) #could smooth this\n return ratio","def cpi_adjust(row, CPI_tf):\n CPI_ts = row['CPIAUCSL']\n x_ts = row.iloc[0]\n \n x_tf = x_ts * (CPI_ts / CPI_tf)\n return x_tf","def get_number_aliens_x(si_settings, alien_width):\r\n available_space_x = si_settings.screen_width * (1.75/3)\r\n number_aliens_x = int(available_space_x / alien_width)\r\n return number_aliens_x","def x(self) -> float:\n return self._ohms.imag","def get_i(self, x):\n return (x - self.__xmin) * (self.__width - 1) // (self.__xmax - self.__xmin)","def ret_vol_ratio(self) -> float:\n return self.geo_ret / self.vol","def calc_anisotropy(self):\n ## no Anisotropic values, we have a spherical isotropic atom\n if self.U is None:\n return 1.0\n\n evals = linalg.eigenvalues(self.U)\n ansotropy = min(evals) / max(evals)\n return ansotropy","def span_rbw_ratio(self):\r\n res = self._visa.query(f\"SENSE{self._screen()}:BANDWIDTH:RESOLUTION:RATIO?\")\r\n return 1 / float(res)","def approximate_optimal_cs_ratio(self):\n norm_sq_C = norm(self.covariance) ** 2\n norm_sq_K_c = norm(self.skewness) ** 2\n return norm_sq_K_c / (norm_sq_K_c + norm_sq_C)","def getGateRatio(self, channel, unitCode=0):\n resp = self.XAPCommand('GRATIO', channel, unitCode=unitCode)\n return float(resp)","def compute_county_cirle(county_population):\n return SCATTER_SCALE * county_population","def note2ratio(note, cents=0):\n ratio = 2 ** ((note + cents / 100) / 12)\n return ratio","def prescaler(self) -> int:","def odds_ratio(ct):\n a = np.array(ct).astype(float)\n return a[0, 0] * a[1, 1] / (a[1, 0] * a[0, 1])","def cdf(s, x):\r\n x = Basic.sympify(x)\r\n if not isinstance(x, Number):\r\n raise NotImplementedError(\"SymPy does not yet support\"\r\n \"piecewise functions\")\r\n if x <= s.a:\r\n return Rational(0)\r\n if x >= s.b:\r\n return Rational(1)\r\n return (x-s.a)/(s.b-s.a)","def cm2inch(size):\n return size / 2.54","def cm2inch(size):\n return size / 2.54","def cm2inch(size):\n return size / 2.54","def calc_process_coupling_cohesion_ratio(partitions, graph):\n cp = calc_process_coupling(partitions, graph)\n ch = calc_process_cohesion(partitions, graph)\n if cp == 0 or ch == 0:\n pccr = 0\n else:\n pccr = cp / ch\n return float(pccr)","def ci2se(ci):\n\n ci = sorted(ci)\n\n return (ci[1] - ci[0]) / (2 * 1.96)","def chi_c_real(params):\n Qi = Q_i(params)\n Qc = params['Q_e_real'].value\n return ((4 * Qc * Qi) /\n (Qc + Qi) ** 2)","def metastable_ratio(nuc, rx, temp=300.0, group_struct=None, phi_g=None, xs_cache=None):\n if isinstance(nuc, int) or isinstance(nuc, basestring):\n xs_cache = cache.xs_cache if xs_cache is None else xs_cache\n _prep_cache(xs_cache, group_struct, phi_g)\n nuc = nucname.id(nuc)\n key = (nuc, rx + \"_x_ratio\", temp)\n if key in xs_cache:\n return xs_cache[key]\n\n # Get the cross-sections\n sigma_rx = sigma_a_reaction(nuc, rx, temp, group_struct, phi_g, xs_cache)\n sigma_rx_x = sigma_a_reaction(nuc, rx + \"_1\", temp, group_struct, phi_g, xs_cache)\n\n # Get the ratio\n ratio_rx_g = sigma_rx_x / sigma_rx\n ratio_rx_g[ratio_rx_g < 0.0] = 0.0\n ratio_rx_g[ratio_rx_g == np.inf] = 0.0\n ratio_rx_g[np.isnan(ratio_rx_g)] = 0.0\n\n if isinstance(nuc, int):\n xs_cache[key] = ratio_rx_g\n return ratio_rx_g","def get_icdf(self, xx):\n return self.parent.ppf(xx)","def func_Ic_318(cp, cd):\n return cp/(np.pi*(cd/2)**2)","def ionic_fraction(self) -> Real:\n return self._ionic_fraction","def ratio_calc(first_strandI, second_strandI):\n if first_strandI + second_strandI != 0:\n Ratio = first_strandI / float(first_strandI + second_strandI)\n return Ratio\n else:\n return np.nan","def hss(self):\n return 2 * (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / (\n (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 1] + self.table[1, 1]) +\n (self.table[0, 0] + self.table[1, 0]) * (self.table[1, 0] + self.table[1, 1]))","def horizontal_ratio(self):\n if self.pupils_located:\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\n return (pupil_left + pupil_right) / 2","def frame_rate():\n def r(x):\n return 6E7/x\n\n def w(x):\n return int(6E7/x)\n return r, w","def zsx_s(self):\n\n return self.glb[user_params_index[\"Zs\"]]/self.glb[user_params_index[\"Xs\"]]"],"string":"[\n \"def csi(self):\\n return self.table[0, 0] / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0])\",\n \"def cci(self) -> float:\\n return self._cci\",\n \"def coi(self, s):\\n return 2 ** 0.5 * s\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def as_integer_ratio(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def icx(self) -> int:\\n return self._icx\",\n \"def calculate_cci(hunterlab):\\n return 1000 * (hunterlab[1]) / (hunterlab[0] * hunterlab[2])\",\n \"def Insurance(Md,X):\\n u = X[iu]\\n b = Md.b()\\n return u/b - u/(1-u+u*b)\",\n \"def pixels_to_inches(self, px: float) -> float:\\r\\n \\r\\n return (px / self.ratio[0]) * self.ratio[1]\",\n \"def sampling_ratio(self):\\n return self.coincidences / self.n\",\n \"def resolution_from_icov(icov):\\n #- force symmetry since due to rounding it might not be exactly symmetric\\n icov = 0.5*(icov + icov.T)\\n \\n if issparse(icov):\\n icov = icov.toarray()\\n\\n sqrt_icov = sym_sqrt(icov)\\n norm_vector = np.sum(sqrt_icov, axis=1)\\n R = np.outer(norm_vector**(-1), np.ones(norm_vector.size)) * sqrt_icov\\n ivar = norm_vector**2 #- Bolton & Schlegel 2010 Eqn 13\\n return R, ivar\",\n \"def get_at_gc_ratio(at, gc):\\n return at / gc\",\n \"def get_at_gc_ratio(at, gc):\\n return at / gc\",\n \"def IntToCoverage(intensity, caliConst):\\n return (np.sqrt((intensity - caliConst[0])))/caliConst[1];\",\n \"def cash_ratio(self):\\n return self.cash / self.current_liabilities\",\n \"def _compute_isometric_ratio(self, threshold):\\n perimeter = 0 # dS\\n volume = 0\\n\\n # A - inside set; B - outside set\\n set_A = self.x >= threshold\\n set_B = self.x < threshold\\n \\n for a_idx in np.where(set_A)[0]:\\n # Compute inside set volume\\n volume += self.degree[a_idx]\\n\\n for b_idx in np.where(set_B)[0]:\\n # Compute boundaey betwen inside and outside sets\\n perimeter += self.weights[a_idx, b_idx]\\n \\n # Compute isometric ratio\\n iso_ratio = perimeter / volume\\n return iso_ratio\",\n \"def CIS(self):\\n return self.get_class_average(self.CIS_class_level)\",\n \"def get_meters_to_pixels_coefficient():\\n return 1/get_pixels_to_meters_coefficient()\",\n \"def calculateR(sapienses: list) -> float:\\n r = 0\\n for i in sapienses:\\n r = r + i.numberInfected\\n r=r/I0\\n r = r*S/(S+R+D)\\n return r\",\n \"def _chisquare_value(self):\\n x2 = np.sum((np.absolute(self.observed - self.expected) - (0.5 * self.continuity_correction)) ** 2 /\\n self.expected)\\n\\n return x2\",\n \"def aspect_ratio(self):\\n ar = (self._block[1] >> 2) & 0x03\\n asp_ratio = ''\\n\\n if ar == 0x00:\\n asp_ratio = '4:3 AR'\\n elif ar == 0x01:\\n asp_ratio = '16:9 AR'\\n elif ar == 0x02:\\n asp_ratio = '16:10 AR'\\n elif ar == 0x03:\\n asp_ratio = '15:9 AR'\\n\\n return asp_ratio\",\n \"def _get_n(self):#@Needs to fix it for general case\\n n_60 = 0.55 * 1 * 1 * 0.75 * self._data[SoilProperty.SPT_N] /0.6\\n if not self.is_clayey() and n_60>15: #apply dilitracy correction\\n n_60 = 15 + 0.5 * (n_60 - 15)\\n return n_60\",\n \"def idog_conv(sc):\\n return math.sqrt(sc*2)\",\n \"def __calculate_si_cf(self) -> Tuple[np.ndarray, np.ndarray]:\\n for image in self.it:\\n im = ImageMetrics(image)\\n si, cf = im.calculate_si_cf()\\n self.si.append(si)\\n self.cf.append(cf)\\n self.norm_si.append(si / self.max_db_si)\\n self.norm_cf.append(cf / self.max_db_cf)\\n return (\\n np.vstack((self.cf, self.si)).T,\\n np.vstack((self.norm_cf, self.norm_si)).T,\\n )\",\n \"def _ratio(sim: xr.DataArray, ref: xr.DataArray) -> xr.DataArray:\\n out = sim / ref\\n out.attrs[\\\"units\\\"] = \\\"\\\"\\n return out\",\n \"def cm2inch(x: Union[float, Sequence[float], NDArray]) -> Sequence[float]:\\n return list(np.array(x) / 2.54)\",\n \"def exchange_ratio(delta_x, salience, power, dominator):\\n\\treturn (delta_x * salience * power) / dominator\",\n \"def inflation_ratio(old_year,new_year):\\n # todo memoization\\n amount = 1\\n url_address = \\\"https://data.bls.gov/cgi-bin/cpicalc.pl?cost1={}&year1={}&year2={}\\\".format(int(amount),int(old_year),int(new_year))\\n print(url_address)\\n with urllib.request.urlopen(url_address) as url:\\n\\n html_doc = url.read()\\n\\n soup = BeautifulSoup(html_doc,\\\"lxml\\\")\\n\\n\\n return float(soup.find(\\\"span\\\", {\\\"id\\\": \\\"answer\\\"}).contents[0][1:])\",\n \"def get_scaling_ratio(img):\\n\\n healthy_img_area = 4872 * 6496\\n input_img_area = img.shape[0] * img.shape[1]\\n ratio = input_img_area / healthy_img_area\\n return ratio\",\n \"def norm_icdf(x):\\n return norm.ppf(x)\",\n \"def getUIQM(x):\\n x = x.astype(np.float32)\\n ### from https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7300447\\n # c1 = 0.4680; c2 = 0.2745; c3 = 0.2576\\n ### from https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7300447\\n c1 = 0.0282\\n c2 = 0.2953\\n c3 = 3.5753\\n\\n uicm = _uicm(x)\\n uism = _uism(x)\\n uiconm = _uiconm(x, 8)\\n uiqm = (c1 * uicm) + (c2 * uism) + (c3 * uiconm)\\n return uiqm\",\n \"def s_multiplier(self):\\n return 4 * np.pi * (self.bins[:, 1]/2)**2\",\n \"def _get_cm_per_pixel(self, diameter):\\n CM_PER_INCH = 2.54\\n pixels_per_inch = 2 / diameter\\n cm_per_pixel = CM_PER_INCH * pixels_per_inch\\n return cm_per_pixel\",\n \"def get_ICC(A,B):\\n n = float(A.size)\\n mean_img = (A + B)/2.\\n\\n MS_w = np.sum((A - mean_img)**2 + (B-mean_img)**2)/n\\n MS_b = 2/(n-1) * np.sum((mean_img - np.mean(mean_img))**2)\\n\\n return (MS_b - MS_w)/(MS_b + MS_w)\",\n \"def diffuse_ratio(DIFF_data,ghi_data): \\n K = DIFF_data/ghi_data\\n \\n return K\",\n \"def ci_OLS(OLSMod):\\r\\n if hasattr(OLSMod, 'xtx'):\\r\\n xtx = OLSMod.xtx # (array) k x k projection matrix (includes constant)\\r\\n elif hasattr(OLSMod, 'hth'):\\r\\n xtx = OLSMod.hth # (array) k x k projection matrix (includes constant)\\r\\n diag = np.diagonal(xtx)\\r\\n scale = xtx/diag \\r\\n eigval = np.linalg.eigvals(scale)\\r\\n max_eigval = max(eigval)\\r\\n min_eigval = min(eigval)\\r\\n ci_result = sqrt(max_eigval/min_eigval)\\r\\n \\r\\n return ci_result\",\n \"def aic_c(self):\\n if hasattr(self, '_aic_c'):\\n return self._aic_c\\n else:\\n k = len(self.params)\\n n = self.data['n'].sum()\\n self._aic_c = self.aic() + (2*k**2 + 2*k)/(n - k - 1)\\n return self._aic_c\",\n \"def pss(self):\\n return (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / \\\\\\n ((self.table[0, 0] + self.table[1, 0]) * (self.table[0, 1] + self.table[1, 1]))\",\n \"def _get_cu(self):\\n c_undrained=0\\n #group_index = self._data['GI']\\n if self.is_clayey():\\n c_undrained = self.qu(self._data[SoilProperty.N60])/2\\n #c_undrained=_clamp(c_undrained, 10, 103)\\n # Plasix calculation needs very small c_undrained\\n #if c_undrained<0.21:\\n # c_undrained = 0.21\\n #use 0.2 as per plasix recommendation\\n return c_undrained#the cu is always 103 check with small value of n_60, some mistake maybe\",\n \"def coherence_from_spectral(Sw):\\r\\n\\r\\n Sxx = Sw[0, 0].real\\r\\n Syy = Sw[1, 1].real\\r\\n\\r\\n Sxy_mod_sq = (Sw[0, 1] * Sw[1, 0]).real\\r\\n Sxy_mod_sq /= Sxx\\r\\n Sxy_mod_sq /= Syy\\r\\n return Sxy_mod_sq\",\n \"def rectifiercap(Iload, fswitch, dVout):\\n C = Iload / (fswitch * dVout)\\n return C\",\n \"def anti_squat_percent(ic_xz, wheel_center, wheel_base, center_gravity_height):\\n # using angle finder from longitudinal instant center to wheel center.\\n as_angle = (two_d_horizontal_angle([ic_xz[0], ic_xz[1]], [wheel_center[0], wheel_center[2]])) * math.pi / 180\\n # calculates anti-squat percent from tan(angle)*(WB/c of g height) * 100\\n as_tan = math.tan(as_angle)\\n as_percent = (as_tan / (center_gravity_height / wheel_base)) * 100\\n return as_percent\",\n \"def infected_ratio(self):\\n if self.max_pop != 0:\\n return int(self.infected_pop) / self.max_pop\\n else:\\n return 1\",\n \"def calc_iqr(sig):\\n # iqr = subtract(*percentile(sig, [75, 25]))\\n return np.percentile(sig, 75) - np.percentile(sig, 25)\",\n \"def compratio(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._compratio\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def x_rate(self):\\n values = self._interpolate_table(\\\"x\\\", derivative_order=1)\\n # values += self._corrections(('ortho_eop', iers.ortho_eop, 0, 1e-6),\\n # ('pmsdnut2', iers.pmsdnut2, 0, 1e-6))\\n return values\",\n \"def proper_annulus_centres(self) -> Quantity:\\n return self._proper_ann_centres\",\n \"def _icmf(self, ms):\\n return self._pot.a * numpy.sqrt(ms) / (1 - numpy.sqrt(ms))\",\n \"def impurityBis(x,iw,size):\\n Vi = 0\\n ai =2*a0+iw*1.5*a0+0.5*(iw-1)*a0\\n \\n if (x > ai-size and x < ai):\\n Vi = 300/Eh\\n elif(x == ai or x == ai-size):\\n Vi = 150/Eh\\n \\n return Vi\",\n \"def _get_scaling(root):\\n dpi = root.winfo_fpixels(\\\"1i\\\")\\n scaling = dpi / 72.0\\n logger.debug(\\\"dpi: %s, scaling: %s'\\\", dpi, scaling)\\n return scaling\",\n \"def div(self):\\n a = self.nums()\\n x = LibraryFunctions.per(a, 0.9) - LibraryFunctions.per(a, 0.1)\\n return x / 2.58\",\n \"def clarity_conversion(string):\\n if (string == 'I1'):\\n return 0.125\\n if (string == 'SI2'):\\n return 0.25\\n if (string == 'SI1'):\\n return 0.375\\n if (string == 'VS2'):\\n return 0.5\\n if (string == 'VS1'):\\n return 0.625\\n if (string == 'VVS2'):\\n return 0.75\\n if (string == 'VVS1'):\\n return 0.875\\n if (string == 'IF'):\\n return 1\",\n \"def p2cx(self, client, percent):\\r\\n pixel = client.p2cx(percent)\\r\\n return pixel\",\n \"def bla_ipr(x):\\n phi = x / np.sqrt(np.sum(x**2))\\n return np.sum(phi**4)\\n # if s2 < MACH_EPSILON:\\n # # Zero sum. Could happen for veeery small overall prevalence.\\n # return 0.\\n # else:\\n # return np.sum(x2 * x2 / (s2 * s2))\",\n \"def getResolution(s) -> int:\\n unit = getDurationUnit(s)\\n #number of ticks is 1 / unit (if that is an integer)\\n ticksPerQuarter = unit.denominator / unit.numerator\\n if ticksPerQuarter.is_integer():\\n return int(unit.denominator / unit.numerator)\\n else:\\n print(s.filePath, ' non integer number of ticks per Quarter')\\n return 0\",\n \"def __conv_inch(length_mm):\\n return length_mm / 25.4\",\n \"def current_ratio(self):\\n return self.current_assets / self.current_liabilities\",\n \"def ds_ratio(group):\\n nix_count = (group=='nix').sum()\\n top_count = (group=='top').sum()\\n ratio = nix_count/(nix_count+top_count) #could smooth this\\n return ratio\",\n \"def cpi_adjust(row, CPI_tf):\\n CPI_ts = row['CPIAUCSL']\\n x_ts = row.iloc[0]\\n \\n x_tf = x_ts * (CPI_ts / CPI_tf)\\n return x_tf\",\n \"def get_number_aliens_x(si_settings, alien_width):\\r\\n available_space_x = si_settings.screen_width * (1.75/3)\\r\\n number_aliens_x = int(available_space_x / alien_width)\\r\\n return number_aliens_x\",\n \"def x(self) -> float:\\n return self._ohms.imag\",\n \"def get_i(self, x):\\n return (x - self.__xmin) * (self.__width - 1) // (self.__xmax - self.__xmin)\",\n \"def ret_vol_ratio(self) -> float:\\n return self.geo_ret / self.vol\",\n \"def calc_anisotropy(self):\\n ## no Anisotropic values, we have a spherical isotropic atom\\n if self.U is None:\\n return 1.0\\n\\n evals = linalg.eigenvalues(self.U)\\n ansotropy = min(evals) / max(evals)\\n return ansotropy\",\n \"def span_rbw_ratio(self):\\r\\n res = self._visa.query(f\\\"SENSE{self._screen()}:BANDWIDTH:RESOLUTION:RATIO?\\\")\\r\\n return 1 / float(res)\",\n \"def approximate_optimal_cs_ratio(self):\\n norm_sq_C = norm(self.covariance) ** 2\\n norm_sq_K_c = norm(self.skewness) ** 2\\n return norm_sq_K_c / (norm_sq_K_c + norm_sq_C)\",\n \"def getGateRatio(self, channel, unitCode=0):\\n resp = self.XAPCommand('GRATIO', channel, unitCode=unitCode)\\n return float(resp)\",\n \"def compute_county_cirle(county_population):\\n return SCATTER_SCALE * county_population\",\n \"def note2ratio(note, cents=0):\\n ratio = 2 ** ((note + cents / 100) / 12)\\n return ratio\",\n \"def prescaler(self) -> int:\",\n \"def odds_ratio(ct):\\n a = np.array(ct).astype(float)\\n return a[0, 0] * a[1, 1] / (a[1, 0] * a[0, 1])\",\n \"def cdf(s, x):\\r\\n x = Basic.sympify(x)\\r\\n if not isinstance(x, Number):\\r\\n raise NotImplementedError(\\\"SymPy does not yet support\\\"\\r\\n \\\"piecewise functions\\\")\\r\\n if x <= s.a:\\r\\n return Rational(0)\\r\\n if x >= s.b:\\r\\n return Rational(1)\\r\\n return (x-s.a)/(s.b-s.a)\",\n \"def cm2inch(size):\\n return size / 2.54\",\n \"def cm2inch(size):\\n return size / 2.54\",\n \"def cm2inch(size):\\n return size / 2.54\",\n \"def calc_process_coupling_cohesion_ratio(partitions, graph):\\n cp = calc_process_coupling(partitions, graph)\\n ch = calc_process_cohesion(partitions, graph)\\n if cp == 0 or ch == 0:\\n pccr = 0\\n else:\\n pccr = cp / ch\\n return float(pccr)\",\n \"def ci2se(ci):\\n\\n ci = sorted(ci)\\n\\n return (ci[1] - ci[0]) / (2 * 1.96)\",\n \"def chi_c_real(params):\\n Qi = Q_i(params)\\n Qc = params['Q_e_real'].value\\n return ((4 * Qc * Qi) /\\n (Qc + Qi) ** 2)\",\n \"def metastable_ratio(nuc, rx, temp=300.0, group_struct=None, phi_g=None, xs_cache=None):\\n if isinstance(nuc, int) or isinstance(nuc, basestring):\\n xs_cache = cache.xs_cache if xs_cache is None else xs_cache\\n _prep_cache(xs_cache, group_struct, phi_g)\\n nuc = nucname.id(nuc)\\n key = (nuc, rx + \\\"_x_ratio\\\", temp)\\n if key in xs_cache:\\n return xs_cache[key]\\n\\n # Get the cross-sections\\n sigma_rx = sigma_a_reaction(nuc, rx, temp, group_struct, phi_g, xs_cache)\\n sigma_rx_x = sigma_a_reaction(nuc, rx + \\\"_1\\\", temp, group_struct, phi_g, xs_cache)\\n\\n # Get the ratio\\n ratio_rx_g = sigma_rx_x / sigma_rx\\n ratio_rx_g[ratio_rx_g < 0.0] = 0.0\\n ratio_rx_g[ratio_rx_g == np.inf] = 0.0\\n ratio_rx_g[np.isnan(ratio_rx_g)] = 0.0\\n\\n if isinstance(nuc, int):\\n xs_cache[key] = ratio_rx_g\\n return ratio_rx_g\",\n \"def get_icdf(self, xx):\\n return self.parent.ppf(xx)\",\n \"def func_Ic_318(cp, cd):\\n return cp/(np.pi*(cd/2)**2)\",\n \"def ionic_fraction(self) -> Real:\\n return self._ionic_fraction\",\n \"def ratio_calc(first_strandI, second_strandI):\\n if first_strandI + second_strandI != 0:\\n Ratio = first_strandI / float(first_strandI + second_strandI)\\n return Ratio\\n else:\\n return np.nan\",\n \"def hss(self):\\n return 2 * (self.table[0, 0] * self.table[1, 1] - self.table[0, 1] * self.table[1, 0]) / (\\n (self.table[0, 0] + self.table[0, 1]) * (self.table[0, 1] + self.table[1, 1]) +\\n (self.table[0, 0] + self.table[1, 0]) * (self.table[1, 0] + self.table[1, 1]))\",\n \"def horizontal_ratio(self):\\n if self.pupils_located:\\n pupil_left = self.eye_left.pupil.x / (self.eye_left.center[0] * 2 - 10)\\n pupil_right = self.eye_right.pupil.x / (self.eye_right.center[0] * 2 - 10)\\n return (pupil_left + pupil_right) / 2\",\n \"def frame_rate():\\n def r(x):\\n return 6E7/x\\n\\n def w(x):\\n return int(6E7/x)\\n return r, w\",\n \"def zsx_s(self):\\n\\n return self.glb[user_params_index[\\\"Zs\\\"]]/self.glb[user_params_index[\\\"Xs\\\"]]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60738033","0.5845884","0.583743","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.57556456","0.56797916","0.56538606","0.5611219","0.5602497","0.5600878","0.5599964","0.5542232","0.5542232","0.5515763","0.5457258","0.54496616","0.5444744","0.54287463","0.5421705","0.5405462","0.538904","0.53811353","0.53753555","0.5345643","0.5338371","0.5328886","0.5304778","0.5294235","0.52773964","0.5277275","0.52747846","0.52579725","0.52565455","0.5254713","0.525429","0.52524745","0.52518976","0.52517956","0.52444446","0.5224292","0.52205884","0.51891625","0.51818657","0.5178849","0.5172562","0.51669604","0.51637566","0.5156996","0.5156715","0.5154841","0.51528513","0.5147765","0.514577","0.51408815","0.5140242","0.51396567","0.51344615","0.513372","0.51324725","0.512428","0.51215184","0.5120621","0.5118433","0.51182544","0.5115855","0.5111519","0.5103517","0.5092136","0.5086404","0.5085447","0.5079975","0.50796133","0.5074303","0.5074303","0.5074303","0.5071087","0.50662184","0.5065152","0.50630194","0.5061391","0.5060336","0.5055067","0.5052201","0.5050695","0.5046312","0.5043999","0.504211"],"string":"[\n \"0.60738033\",\n \"0.5845884\",\n \"0.583743\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.57556456\",\n \"0.56797916\",\n \"0.56538606\",\n \"0.5611219\",\n \"0.5602497\",\n \"0.5600878\",\n \"0.5599964\",\n \"0.5542232\",\n \"0.5542232\",\n \"0.5515763\",\n \"0.5457258\",\n \"0.54496616\",\n \"0.5444744\",\n \"0.54287463\",\n \"0.5421705\",\n \"0.5405462\",\n \"0.538904\",\n \"0.53811353\",\n \"0.53753555\",\n \"0.5345643\",\n \"0.5338371\",\n \"0.5328886\",\n \"0.5304778\",\n \"0.5294235\",\n \"0.52773964\",\n \"0.5277275\",\n \"0.52747846\",\n \"0.52579725\",\n \"0.52565455\",\n \"0.5254713\",\n \"0.525429\",\n \"0.52524745\",\n \"0.52518976\",\n \"0.52517956\",\n \"0.52444446\",\n \"0.5224292\",\n \"0.52205884\",\n \"0.51891625\",\n \"0.51818657\",\n \"0.5178849\",\n \"0.5172562\",\n \"0.51669604\",\n \"0.51637566\",\n \"0.5156996\",\n \"0.5156715\",\n \"0.5154841\",\n \"0.51528513\",\n \"0.5147765\",\n \"0.514577\",\n \"0.51408815\",\n \"0.5140242\",\n \"0.51396567\",\n \"0.51344615\",\n \"0.513372\",\n \"0.51324725\",\n \"0.512428\",\n \"0.51215184\",\n \"0.5120621\",\n \"0.5118433\",\n \"0.51182544\",\n \"0.5115855\",\n \"0.5111519\",\n \"0.5103517\",\n \"0.5092136\",\n \"0.5086404\",\n \"0.5085447\",\n \"0.5079975\",\n \"0.50796133\",\n \"0.5074303\",\n \"0.5074303\",\n \"0.5074303\",\n \"0.5071087\",\n \"0.50662184\",\n \"0.5065152\",\n \"0.50630194\",\n \"0.5061391\",\n \"0.5060336\",\n \"0.5055067\",\n \"0.5052201\",\n \"0.5050695\",\n \"0.5046312\",\n \"0.5043999\",\n \"0.504211\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84690,"cells":{"query":{"kind":"string","value":"Only necessary for the dummy contract."},"document":{"kind":"string","value":"def setSicxSupply(self) -> None:\n self._sICX_supply.set(self.sICX_score.totalSupply())"},"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 RequiredContract(self) -> _n_0_t_1:","def dummy(self):\n pass","def contract_pepo_pbc():\n pass","def test_stub(self):\n pass","def _dummy(ticket):\r\n return True","def test_block_bad_signature(self):\n pass","def dummy_fn(self):\n\t\tpass","def __call__(self) -> None:","def _verify(self):\n pass","def __call__(self):\n raise NotImplementedError","def test(self):\n raise NotImplementedError","def __call__(self):\n pass","def __call__(self):\n pass","def test_4_4_1_1(self):\n pass","def __call__(self):\n raise NotImplementedError()","def test_create_contract(token, carrier):\n assert token.call().dividendsCarrier() == carrier.address","def test_init(self):\n DummyCryptographicObject()","def test_08(self):\n assert 'False' == Api.requestBlock('test-08', differentOrderId=True)","def _create_impl(self):","def test_kyc_put_legal_share_holder(self):\n pass","def test_create_unexpected_problem(self):\n pass","def _prepare(self):","def _prepare(self):","def test_block_bad_consensus(self):\n pass","def test_34(self):\n assert 'False' == Api.requestBlock('test-34')","def test_rpcCall(self):\n pass","def test_27(self):\n assert 'False' == Api.requestBlock('test-27')","def test_46(self):\n assert 'False' == Api.requestBlock('test-46')","def test_28(self):\n assert 'False' == Api.requestBlock('test-28')","def __init__(self):\n self.Name = None\n self.Type = None\n self.Signature = None\n self.Contract = None","def test_44(self):\n assert 'False' == Api.requestBlock('test-44')","def test_kyc_put_legal(self):\n pass","def __call__(self):\n\t\treturn","def bad(self):\n raise NotImplementedError","def bad(self):\n raise NotImplementedError","def basic(self):\n pass","def test_kyc_put_request_legal(self):\n pass","def test_kyc_post_legal_share_holder(self):\n pass","def test_14(self):\n assert 'False' == Api.requestBlock('test-14')","def test_21(self):\n assert 'False' == Api.requestBlock('test-21')","def test_03(self):\n assert 'False' == Api.requestBlock('test-03')","def test_22(self):\n assert 'True' == Api.requestBlock('test-22')","def test_42(self):\n assert 'True' == Api.requestBlock('test-42')","def test_52(self):\n assert 'False' == Api.requestBlock('test-52')","def __call__( self ):\n pass","def test_45(self):\n assert 'True' == Api.requestBlock('test-45')","def test_32(self):\n assert 'False' == Api.requestBlock('test-32')","def test_kyc_get_legal(self):\n pass","def test_16(self):\n assert 'False' == Api.requestBlock('test-16')","def test_01(self):\n assert 'True' == Api.requestBlock('test-01')","def test_43(self):\n assert 'False' == Api.requestBlock('test-43')","def test_trade(self):\n pass","def test_02(self):\n assert 'False' == Api.requestBlock('test-02')","def test_23(self):\n assert 'False' == Api.requestBlock('test-23')","def test_48(self):\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)","def init():\n try:\n compile_contract(\n \"fishcake\", f\"Fishcake(sp.address('{pub_key_hash}'),{default_supply})\")\n fishcake_addr = deploy(\"fishcake\")\n print(\"\\n\")\n compile_contract(\n \"fishcakeBox\", f\"FishcakeBox({default_redeem_amt}, sp.address('{fishcake_addr}'))\")\n fishcake_box_addr = deploy(\"fishcakeBox\")\n setup(fishcake_addr, fishcake_box_addr)\n print(\"\\n\\n[!] Details :\\n\")\n print(f\"-- Fishcake Token Address : {fishcake_addr}\")\n print(f\"-- Fishcake Box Address : {fishcake_box_addr}\")\n except Exception as e:\n print(\"Failed to originate Contracts : \", e)","def test_37(self):\n assert 'False' == Api.requestBlock('test-37')","def test_41(self):\n assert 'False' == Api.requestBlock('test-41')","def sanity_check(self):\n pass","def test_13(self):\n assert 'False' == Api.requestBlock('test-13')","def test_35(self):\n assert 'False' == Api.requestBlock('test-35')","def test_26(self):\n assert 'False' == Api.requestBlock('test-26')","def verify(self):\n raise NotImplementedError","def inner_test(param: bytes):\n pass","def test_31(self):\n assert 'True' == Api.requestBlock('test-31')","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def test_47(self):\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)","def _build_impl(self):","def mockup(cls):\n pass","def test_51(self):\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)","def test_dummy():","def __init__(self):\n raise","def test_33(self):\n assert 'False' == Api.requestBlock('test-33')","def verify(self):\r\n pass","def test_04(self):\n assert 'False' == Api.requestBlock('test-04', charOrder='')","def test_12(self):\n assert 'False' == Api.requestBlock('test-12')","def test_36(self):\n assert 'False' == Api.requestBlock('test-36')","def test_11(self):\n assert 'False' == Api.requestBlock('test-11')","def test_15(self):\n assert 'False' == Api.requestBlock('test-15')","def test_balance_tracking(self):\n # TODO\n pass","def test_client_verification_create(self):\n pass","def verify(self):\n pass","def verify(self):\n pass","def __init__(self, proto):\r\n _meta.OwnsSingleOrder.__init__(self, proto)","def implement(self):\n\t#@DEBUG remove comments","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def __init__(self):\n raise NotImplementedError","def test_should_implement(self):\n pass","def test_09(self):\n assert 'False' == Api.requestBlock('test-09')","def test_24(self):\n assert 'False' == Api.requestBlock('test-24')","def test_25(self):\n assert 'False' == Api.requestBlock('test-25')","def test_29(self):\n assert 'True' == Api.requestBlock('test-29')","def test_49(self):\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)","def test_40(self):\n assert 'False' == Api.requestBlock('test-40')","def __init__(self):\n raise NotImplementedError()","def dummy_request():\n return DummyRequest()","def _dummy(*args, **kwargs):\n err_str = \"\"\n raise NotImplementedError()"],"string":"[\n \"def RequiredContract(self) -> _n_0_t_1:\",\n \"def dummy(self):\\n pass\",\n \"def contract_pepo_pbc():\\n pass\",\n \"def test_stub(self):\\n pass\",\n \"def _dummy(ticket):\\r\\n return True\",\n \"def test_block_bad_signature(self):\\n pass\",\n \"def dummy_fn(self):\\n\\t\\tpass\",\n \"def __call__(self) -> None:\",\n \"def _verify(self):\\n pass\",\n \"def __call__(self):\\n raise NotImplementedError\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def __call__(self):\\n pass\",\n \"def __call__(self):\\n pass\",\n \"def test_4_4_1_1(self):\\n pass\",\n \"def __call__(self):\\n raise NotImplementedError()\",\n \"def test_create_contract(token, carrier):\\n assert token.call().dividendsCarrier() == carrier.address\",\n \"def test_init(self):\\n DummyCryptographicObject()\",\n \"def test_08(self):\\n assert 'False' == Api.requestBlock('test-08', differentOrderId=True)\",\n \"def _create_impl(self):\",\n \"def test_kyc_put_legal_share_holder(self):\\n pass\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def _prepare(self):\",\n \"def _prepare(self):\",\n \"def test_block_bad_consensus(self):\\n pass\",\n \"def test_34(self):\\n assert 'False' == Api.requestBlock('test-34')\",\n \"def test_rpcCall(self):\\n pass\",\n \"def test_27(self):\\n assert 'False' == Api.requestBlock('test-27')\",\n \"def test_46(self):\\n assert 'False' == Api.requestBlock('test-46')\",\n \"def test_28(self):\\n assert 'False' == Api.requestBlock('test-28')\",\n \"def __init__(self):\\n self.Name = None\\n self.Type = None\\n self.Signature = None\\n self.Contract = None\",\n \"def test_44(self):\\n assert 'False' == Api.requestBlock('test-44')\",\n \"def test_kyc_put_legal(self):\\n pass\",\n \"def __call__(self):\\n\\t\\treturn\",\n \"def bad(self):\\n raise NotImplementedError\",\n \"def bad(self):\\n raise NotImplementedError\",\n \"def basic(self):\\n pass\",\n \"def test_kyc_put_request_legal(self):\\n pass\",\n \"def test_kyc_post_legal_share_holder(self):\\n pass\",\n \"def test_14(self):\\n assert 'False' == Api.requestBlock('test-14')\",\n \"def test_21(self):\\n assert 'False' == Api.requestBlock('test-21')\",\n \"def test_03(self):\\n assert 'False' == Api.requestBlock('test-03')\",\n \"def test_22(self):\\n assert 'True' == Api.requestBlock('test-22')\",\n \"def test_42(self):\\n assert 'True' == Api.requestBlock('test-42')\",\n \"def test_52(self):\\n assert 'False' == Api.requestBlock('test-52')\",\n \"def __call__( self ):\\n pass\",\n \"def test_45(self):\\n assert 'True' == Api.requestBlock('test-45')\",\n \"def test_32(self):\\n assert 'False' == Api.requestBlock('test-32')\",\n \"def test_kyc_get_legal(self):\\n pass\",\n \"def test_16(self):\\n assert 'False' == Api.requestBlock('test-16')\",\n \"def test_01(self):\\n assert 'True' == Api.requestBlock('test-01')\",\n \"def test_43(self):\\n assert 'False' == Api.requestBlock('test-43')\",\n \"def test_trade(self):\\n pass\",\n \"def test_02(self):\\n assert 'False' == Api.requestBlock('test-02')\",\n \"def test_23(self):\\n assert 'False' == Api.requestBlock('test-23')\",\n \"def test_48(self):\\n assert 'False' == Api.requestBlock('test-48', CustomFields=True)\",\n \"def init():\\n try:\\n compile_contract(\\n \\\"fishcake\\\", f\\\"Fishcake(sp.address('{pub_key_hash}'),{default_supply})\\\")\\n fishcake_addr = deploy(\\\"fishcake\\\")\\n print(\\\"\\\\n\\\")\\n compile_contract(\\n \\\"fishcakeBox\\\", f\\\"FishcakeBox({default_redeem_amt}, sp.address('{fishcake_addr}'))\\\")\\n fishcake_box_addr = deploy(\\\"fishcakeBox\\\")\\n setup(fishcake_addr, fishcake_box_addr)\\n print(\\\"\\\\n\\\\n[!] Details :\\\\n\\\")\\n print(f\\\"-- Fishcake Token Address : {fishcake_addr}\\\")\\n print(f\\\"-- Fishcake Box Address : {fishcake_box_addr}\\\")\\n except Exception as e:\\n print(\\\"Failed to originate Contracts : \\\", e)\",\n \"def test_37(self):\\n assert 'False' == Api.requestBlock('test-37')\",\n \"def test_41(self):\\n assert 'False' == Api.requestBlock('test-41')\",\n \"def sanity_check(self):\\n pass\",\n \"def test_13(self):\\n assert 'False' == Api.requestBlock('test-13')\",\n \"def test_35(self):\\n assert 'False' == Api.requestBlock('test-35')\",\n \"def test_26(self):\\n assert 'False' == Api.requestBlock('test-26')\",\n \"def verify(self):\\n raise NotImplementedError\",\n \"def inner_test(param: bytes):\\n pass\",\n \"def test_31(self):\\n assert 'True' == Api.requestBlock('test-31')\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def test_47(self):\\n assert 'False' == Api.requestBlock('test-47', CustomFields=True)\",\n \"def _build_impl(self):\",\n \"def mockup(cls):\\n pass\",\n \"def test_51(self):\\n assert 'False' == Api.requestBlock('test-51', CustomFields=True)\",\n \"def test_dummy():\",\n \"def __init__(self):\\n raise\",\n \"def test_33(self):\\n assert 'False' == Api.requestBlock('test-33')\",\n \"def verify(self):\\r\\n pass\",\n \"def test_04(self):\\n assert 'False' == Api.requestBlock('test-04', charOrder='')\",\n \"def test_12(self):\\n assert 'False' == Api.requestBlock('test-12')\",\n \"def test_36(self):\\n assert 'False' == Api.requestBlock('test-36')\",\n \"def test_11(self):\\n assert 'False' == Api.requestBlock('test-11')\",\n \"def test_15(self):\\n assert 'False' == Api.requestBlock('test-15')\",\n \"def test_balance_tracking(self):\\n # TODO\\n pass\",\n \"def test_client_verification_create(self):\\n pass\",\n \"def verify(self):\\n pass\",\n \"def verify(self):\\n pass\",\n \"def __init__(self, proto):\\r\\n _meta.OwnsSingleOrder.__init__(self, proto)\",\n \"def implement(self):\\n\\t#@DEBUG remove comments\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def __init__(self):\\n raise NotImplementedError\",\n \"def test_should_implement(self):\\n pass\",\n \"def test_09(self):\\n assert 'False' == Api.requestBlock('test-09')\",\n \"def test_24(self):\\n assert 'False' == Api.requestBlock('test-24')\",\n \"def test_25(self):\\n assert 'False' == Api.requestBlock('test-25')\",\n \"def test_29(self):\\n assert 'True' == Api.requestBlock('test-29')\",\n \"def test_49(self):\\n assert 'False' == Api.requestBlock('test-49', CustomFields=True)\",\n \"def test_40(self):\\n assert 'False' == Api.requestBlock('test-40')\",\n \"def __init__(self):\\n raise NotImplementedError()\",\n \"def dummy_request():\\n return DummyRequest()\",\n \"def _dummy(*args, **kwargs):\\n err_str = \\\"\\\"\\n raise NotImplementedError()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6988934","0.6948609","0.66215193","0.6288151","0.606796","0.604304","0.597733","0.5960648","0.5929356","0.5910414","0.5864295","0.5847082","0.5847082","0.5843603","0.5816594","0.5808959","0.58019507","0.57961833","0.5791844","0.57686216","0.57359856","0.57015723","0.57015723","0.56975496","0.5697054","0.5693758","0.56931216","0.5667473","0.56656975","0.56624484","0.5660522","0.5653844","0.5649015","0.56446254","0.56446254","0.5644074","0.564159","0.56406116","0.56297636","0.5629427","0.5628117","0.5626666","0.5625251","0.56217414","0.5615852","0.5614851","0.5614352","0.561176","0.5599812","0.5598114","0.5597898","0.5597379","0.5590196","0.559017","0.5589301","0.5582883","0.55807567","0.55733967","0.55670893","0.5565298","0.55629134","0.5559103","0.55543107","0.55504364","0.554799","0.55443823","0.55443823","0.55443823","0.5539107","0.5536623","0.55365956","0.5536133","0.5529375","0.55248505","0.5518456","0.55166984","0.55132955","0.5510615","0.5498883","0.54934007","0.5489378","0.54877526","0.54764473","0.5475114","0.5475114","0.5472006","0.5472005","0.54701376","0.54701376","0.54701376","0.54701376","0.5466437","0.546539","0.5464104","0.5461215","0.54597205","0.5458753","0.5450906","0.5449379","0.54416823","0.5433422"],"string":"[\n \"0.6988934\",\n \"0.6948609\",\n \"0.66215193\",\n \"0.6288151\",\n \"0.606796\",\n \"0.604304\",\n \"0.597733\",\n \"0.5960648\",\n \"0.5929356\",\n \"0.5910414\",\n \"0.5864295\",\n \"0.5847082\",\n \"0.5847082\",\n \"0.5843603\",\n \"0.5816594\",\n \"0.5808959\",\n \"0.58019507\",\n \"0.57961833\",\n \"0.5791844\",\n \"0.57686216\",\n \"0.57359856\",\n \"0.57015723\",\n \"0.57015723\",\n \"0.56975496\",\n \"0.5697054\",\n \"0.5693758\",\n \"0.56931216\",\n \"0.5667473\",\n \"0.56656975\",\n \"0.56624484\",\n \"0.5660522\",\n \"0.5653844\",\n \"0.5649015\",\n \"0.56446254\",\n \"0.56446254\",\n \"0.5644074\",\n \"0.564159\",\n \"0.56406116\",\n \"0.56297636\",\n \"0.5629427\",\n \"0.5628117\",\n \"0.5626666\",\n \"0.5625251\",\n \"0.56217414\",\n \"0.5615852\",\n \"0.5614851\",\n \"0.5614352\",\n \"0.561176\",\n \"0.5599812\",\n \"0.5598114\",\n \"0.5597898\",\n \"0.5597379\",\n \"0.5590196\",\n \"0.559017\",\n \"0.5589301\",\n \"0.5582883\",\n \"0.55807567\",\n \"0.55733967\",\n \"0.55670893\",\n \"0.5565298\",\n \"0.55629134\",\n \"0.5559103\",\n \"0.55543107\",\n \"0.55504364\",\n \"0.554799\",\n \"0.55443823\",\n \"0.55443823\",\n \"0.55443823\",\n \"0.5539107\",\n \"0.5536623\",\n \"0.55365956\",\n \"0.5536133\",\n \"0.5529375\",\n \"0.55248505\",\n \"0.5518456\",\n \"0.55166984\",\n \"0.55132955\",\n \"0.5510615\",\n \"0.5498883\",\n \"0.54934007\",\n \"0.5489378\",\n \"0.54877526\",\n \"0.54764473\",\n \"0.5475114\",\n \"0.5475114\",\n \"0.5472006\",\n \"0.5472005\",\n \"0.54701376\",\n \"0.54701376\",\n \"0.54701376\",\n \"0.54701376\",\n \"0.5466437\",\n \"0.546539\",\n \"0.5464104\",\n \"0.5461215\",\n \"0.54597205\",\n \"0.5458753\",\n \"0.5450906\",\n \"0.5449379\",\n \"0.54416823\",\n \"0.5433422\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84691,"cells":{"query":{"kind":"string","value":"Get the address of sICX token contract."},"document":{"kind":"string","value":"def getSicxAddress(self) -> Address:\n return self._sICX_address.get()"},"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_address(self):\n if self.address:\n return self.address","def get_address(self, ):\n return self.get_parameter('address')","def _get_address(self):\n return self.__address","def address(self) -> str:\n return pulumi.get(self, \"address\")","def address(self) -> str:\n return pulumi.get(self, \"address\")","def address(self) -> str:\n return pulumi.get(self, \"address\")","def getAddress(self):\r\n return self._container.getAddress()","def get_address(self):\n \n return self._addr","def get_address(self):\n \n return self._addr","def getAddress(self):\r\n raise NotImplementedError('Endpoint can not be used directly.')","def account_deposit_address(self, currency_symbol):\n return self.get(f'addresses/{currency_symbol}', auth=True)","def get_address(self):\n return logic.address(self.get_program())","def get_current_address(self):\n pass","def address(self):\n return self._address","def address(self):\n return self._address","def address(self):\n return self._address","def address(self):\n return self._address","def address(self):\n return self._address","def address(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"address\")","def get_address(self, symbol):\n return self.table[symbol]","def getAddress(self):\r\n return self._endpoint.getAddress()","def address(self):\n return str(self._address)","def get_address(self):\n self.rs485.clear_buffers()\n self.rs485.write_command('#00?0')\n response = self.rs485.read_response()\n pattern = '\\$.*? (.*?) \\r\\n'\n hexval = re.findall(pattern,response).pop()\n address = int(hexval,16)\n return address","def get_address(self) -> Optional[str]:\n raise NotImplementedError()","def stellar_address(self) -> str:\n return kin_utils.encode_check('account', bytes(self._verify_key)).decode()","def address(self) -> str:\n return self._address","def address(self) -> str:\n return self._address","def address(self):\n\n return self._address","def signer_address(private_key):\n return get_ethereum_address_from_private_key(private_key)","def address(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"address\")","def address(self):\n return self._ref_address","def _get_address(self):\n return utf82unicode(pn_terminus_get_address(self._impl))","def address(self) -> object:\n return self._address","def address(self):\n return self.data.get('address')","def address(self):\n \n return self.__ip","def token(uncapped_token: Contract):\n return uncapped_token","def address(self, symbol):\r\n return self.s_table[symbol]","def getAddress(self) -> int:\n ...","def address(self):\n\n\t\telement = Element(driver=self.driver,\n\t\t explicit_wait_time=self.explicit_wait_time,\n\t\t locator=BillPayPageLocator.ADDRESS_INPUT)\n\t\treturn element.element_value","def contract_number(self):\n return self._contract_number","def getSymbolAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Symbol:\n ...","def get_address(self):\n return self.get_ipv4_address()","def addr(self):\r\n return self._addr","def address(self) -> Optional[str]:\n return pulumi.get(self, \"address\")","def address(self) -> Optional[str]:\n return pulumi.get(self, \"address\")","def get_deposit_address(self, currency):\n return self.__call__('balance', \"getdepositaddress\", \n {\"currencyname\": currency})","def getaccountaddress(self, account):\n return self.proxy.getaccountaddress(account)","def mk_contract_address(sender: str, nonce: int) -> str:\n sender_bytes = to_bytes(hexstr=sender)\n raw = rlp.encode([sender_bytes, nonce])\n h = keccak(raw)\n address_bytes = h[12:]\n return to_checksum_address(address_bytes)","def address(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"address\")","def get_address(self, address=None):\n return self.__get_addr_grp('address', address)","def get_address(self):\r\n return \"iDigi\"","def _make_benchcontract_address(name):\n\n print(\"name: {}\".format(name))\n print(\"namespace: {}\".format(namespace))\n return namespace + hashlib.sha512(name.encode(\"utf-8\")).hexdigest()[0:64]","def instant_messaging_address(self) -> str:\n return self._instant_messaging_address","def address(self) -> str:\n return self._backend.address","def paymentAddress(self):\n return self.selectedAccount.paymentAddress()","def address(self) -> int:\n return self._address","def getAddressOfgoods(account_address):\n\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\n function_selector = 'getAddressOfGoodFromWallet(address)',\n fee_limit=1000000000,\n call_value=0,\n parameters=[{'type': 'address', 'value':account_address}],\n issuer_address=account_address\n )\n addresses = addresses['constant_result']\n decodeH = decode_hex(addresses[0])\n decodeA= decode_abi(('uint256[]',),decodeH)\n print(\"----------------------------------------------------\")\n print(decodeA)\n return decodeA[0]","def get_keystone_token(con):\n return con.get_token(con.session)","def get_address(xpub):\n return xpub.to_address() # p2pkh","def get_mac_address(self):\n\t\treturn call_sdk_function('PrlSrvCfgNet_GetMacAddress', self.handle)","def get_mac_address(self):\n\t\treturn call_sdk_function('PrlVmDevNet_GetMacAddress', self.handle)","def token_id_hex(self) -> str: # this is *ALSO* a MINT property\n return self.token_id.hex()","def get_remit_to_address(self): \n return self.remit_to_address","def fetch_address(cpr: str) -> str:\n\n return \"Åbogade 15, 8200 Aarhus N\"","def deposit_address(self):\n response = self.query('deposit_address')\n return response","def address(self):\n if self._address:\n pass\n elif 'address' in self.keystore:\n self._address = decode_hex(self.keystore['address'])\n elif not self.locked:\n self._address = keys.privtoaddr(self.privkey)\n else:\n return None\n return self._address","def get_central_address():\n scoreboard_config = CHAINBALL_CONFIGURATION.retrieve_configuration(\n \"scoreboard\"\n )\n\n return (\n scoreboard_config[\"chainball_server\"],\n scoreboard_config[\"chainball_server_token\"],\n )","def getSymbolAt(self, address: ghidra.program.model.address.Address, name: unicode, namespace: ghidra.program.model.symbol.Namespace) -> ghidra.program.model.symbol.Symbol:\n ...","def getTokens_utils(account_address, value=30000000000):\n e = {'txid':'Error!'} \n logsOfError = ''\n try:\n trigger = tron.transaction_builder.trigger_smart_contract(contract_address = TOKEN_CONTRACT,\n function_selector = 'transfer(address,uint256)', #без пробелов!\n fee_limit=1000000000,\n call_value=0,\n parameters=[{'type':'address','value':account_address},{'type': 'int256','value':value}],\n issuer_address=TOKEN_CREATOR\n )\n\n tron.private_key = TOKEN_CREATOR_PRIVATE_KEY\n transaction = trigger['transaction']\n signed1_tx = tron.trx.sign(transaction,True,False)\n e = tron.trx.broadcast(signed1_tx)\n except Exception as ex:\n logsOfError = logsOfError + str(ex)\n return {'txID':e['txid'], 'logs':logsOfError}","def Address(self) -> _n_5_t_0:","def _get_address(self, symbol):\n if symbol.isdigit():\n \n return symbol\n else:\n if not self.symbols_table.contains(symbol):\n self.symbols_table.add_entry(symbol, self.symbol_address)\n self.symbol_address += 1\n \n return self.symbols_table.get_address(symbol)","def get_addr(self):\n return Server.t_addresses.get(threading.get_ident())","def __get_mac_address(self):\n str_hex_mac = uuid.UUID(int=uuid.getnode()).hex[-12:]\n return str_hex_mac","def gen_quote(token):\n\tmpk = global_storage.get_collector_master_public_key()\n\n\tif not sanetoken(token):\n\t\traise rpc_lib.RPCException(\"Token not sane.\")\n\n\t# FIXME: Should we be worried about race conditions here?\n\tdbentry = SellerDB.get(token=token)\n\tif dbentry != None: # This token is already in the database.\n\t\tindex, address, price = dbentry['index'], dbentry['address'], dbentry['price']\n\t\tassert address == bitcoin.electrum_address(mpk, index) # Index is the index used to generate address.(deterministic key generation)\n\telse:\n\t\t# Index is a large random number that combines with the master public key to yield the address. This combination takes constant time -- it doesn't hurt us to use a very large index. An attacker which knows index, mpk, address, and the _private_ key for address can get the private key for _any_ public key generated using mpk. To limit the damage if one private key gets leaked, we'll make index cryptographically securely random, even though it's probably unnecessary.\n\t\tindex = random.SystemRandom().getrandbits(128)\n\t\taddress = bitcoin.electrum_address(mpk, index)\n\t\t# Price is the price to buy a bond, in satoshi. (We don't use BTC because we don't want floating point errors.)\n\t\tprice = global_storage.bond_price\n\t\tSellerDB.put(token=token, index=index, address=address, price=price)\n\treturn (address, price)","def generate_deposit_address(self, currency):\n return self.__call__('balance', \"generatedepositaddress\", \n {\"currencyname\": currency})","def get_contract_by_address(self, address: str):\n try:\n contract_records = self._registry.search(contract_address=address)\n except RuntimeError:\n raise self.InterfaceError('Corrupted Registrar') # TODO: Integrate with Registry\n else:\n if not contract_records:\n raise self.InterfaceError(\"No such contract with address {}\".format(address))\n return contract_records[0]","def get_address_abi(name, mode):\n dict_event = get_smart_contracts_dict(mode)\n address, abi = dict_event[name]\n\n return address, abi","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def token(self) -> str:\n return pulumi.get(self, \"token\")","def get_address(self):\n return self.address.line[0]+\", \"+self.address.city+\", \"+self.address.state+\", \"+self.address.country","def nomad_address():\n\n print(nomad.get_address())","def getSymbolAt(self, address: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.symbol.Symbol:\n ...","def symbol(self) -> str:\n return self.current_token","def get_offset_address():\n return command(\"O\")","def service_account_email_address(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"service_account_email_address\")","def address(self, name):\n return self.query(name).response.answer[0].items[0].address","def get_address(machine: Machine) -> str:\n default_route, _ = machine.run(\"ip route get 8.8.8.8\")\n return re.search(\" src ([0-9.]+) \", default_route).group(1)","def read_address(self, opcode: int) -> int:\n\n if self.insight:\n self.insight.address(opcode)\n\n return opcode & 0xFFF","def getNodeAddress(self, node):\n return self.backend.configuration.getAddress(node)","def endpoint_address(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"endpoint_address\")","def do_getaddress(self,args):\n ppdict(bitstamp.get_depositaddress())","def token(self):\n return self[\"token\"]","def address(self):\n return \"%s:%s\" % (self.ip, self.port)","def generate(self):\n return self.rpc.call(MsfRpcMethod.AuthTokenGenerate)['token']","def get_mac_address(self):\n self.__not_implemented()","def address(self):\n if self.con_strategy == \"local\":\n return self.address_local()\n if self.con_strategy == \"remote\":\n return self.address_remote()\n return None","def token_cert(self):\n return self._token_cert","def token(chain: BaseChain) -> Contract:\n return deploy_contract(chain, 'DSToken', args=['VIEW'])","def get_address_id(self):\n return self.complete_address[-1]"],"string":"[\n \"def get_address(self):\\n if self.address:\\n return self.address\",\n \"def get_address(self, ):\\n return self.get_parameter('address')\",\n \"def _get_address(self):\\n return self.__address\",\n \"def address(self) -> str:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def address(self) -> str:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def address(self) -> str:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def getAddress(self):\\r\\n return self._container.getAddress()\",\n \"def get_address(self):\\n \\n return self._addr\",\n \"def get_address(self):\\n \\n return self._addr\",\n \"def getAddress(self):\\r\\n raise NotImplementedError('Endpoint can not be used directly.')\",\n \"def account_deposit_address(self, currency_symbol):\\n return self.get(f'addresses/{currency_symbol}', auth=True)\",\n \"def get_address(self):\\n return logic.address(self.get_program())\",\n \"def get_current_address(self):\\n pass\",\n \"def address(self):\\n return self._address\",\n \"def address(self):\\n return self._address\",\n \"def address(self):\\n return self._address\",\n \"def address(self):\\n return self._address\",\n \"def address(self):\\n return self._address\",\n \"def address(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def get_address(self, symbol):\\n return self.table[symbol]\",\n \"def getAddress(self):\\r\\n return self._endpoint.getAddress()\",\n \"def address(self):\\n return str(self._address)\",\n \"def get_address(self):\\n self.rs485.clear_buffers()\\n self.rs485.write_command('#00?0')\\n response = self.rs485.read_response()\\n pattern = '\\\\$.*? (.*?) \\\\r\\\\n'\\n hexval = re.findall(pattern,response).pop()\\n address = int(hexval,16)\\n return address\",\n \"def get_address(self) -> Optional[str]:\\n raise NotImplementedError()\",\n \"def stellar_address(self) -> str:\\n return kin_utils.encode_check('account', bytes(self._verify_key)).decode()\",\n \"def address(self) -> str:\\n return self._address\",\n \"def address(self) -> str:\\n return self._address\",\n \"def address(self):\\n\\n return self._address\",\n \"def signer_address(private_key):\\n return get_ethereum_address_from_private_key(private_key)\",\n \"def address(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def address(self):\\n return self._ref_address\",\n \"def _get_address(self):\\n return utf82unicode(pn_terminus_get_address(self._impl))\",\n \"def address(self) -> object:\\n return self._address\",\n \"def address(self):\\n return self.data.get('address')\",\n \"def address(self):\\n \\n return self.__ip\",\n \"def token(uncapped_token: Contract):\\n return uncapped_token\",\n \"def address(self, symbol):\\r\\n return self.s_table[symbol]\",\n \"def getAddress(self) -> int:\\n ...\",\n \"def address(self):\\n\\n\\t\\telement = Element(driver=self.driver,\\n\\t\\t explicit_wait_time=self.explicit_wait_time,\\n\\t\\t locator=BillPayPageLocator.ADDRESS_INPUT)\\n\\t\\treturn element.element_value\",\n \"def contract_number(self):\\n return self._contract_number\",\n \"def getSymbolAt(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def get_address(self):\\n return self.get_ipv4_address()\",\n \"def addr(self):\\r\\n return self._addr\",\n \"def address(self) -> Optional[str]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def address(self) -> Optional[str]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def get_deposit_address(self, currency):\\n return self.__call__('balance', \\\"getdepositaddress\\\", \\n {\\\"currencyname\\\": currency})\",\n \"def getaccountaddress(self, account):\\n return self.proxy.getaccountaddress(account)\",\n \"def mk_contract_address(sender: str, nonce: int) -> str:\\n sender_bytes = to_bytes(hexstr=sender)\\n raw = rlp.encode([sender_bytes, nonce])\\n h = keccak(raw)\\n address_bytes = h[12:]\\n return to_checksum_address(address_bytes)\",\n \"def address(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def get_address(self, address=None):\\n return self.__get_addr_grp('address', address)\",\n \"def get_address(self):\\r\\n return \\\"iDigi\\\"\",\n \"def _make_benchcontract_address(name):\\n\\n print(\\\"name: {}\\\".format(name))\\n print(\\\"namespace: {}\\\".format(namespace))\\n return namespace + hashlib.sha512(name.encode(\\\"utf-8\\\")).hexdigest()[0:64]\",\n \"def instant_messaging_address(self) -> str:\\n return self._instant_messaging_address\",\n \"def address(self) -> str:\\n return self._backend.address\",\n \"def paymentAddress(self):\\n return self.selectedAccount.paymentAddress()\",\n \"def address(self) -> int:\\n return self._address\",\n \"def getAddressOfgoods(account_address):\\n\\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\\n function_selector = 'getAddressOfGoodFromWallet(address)',\\n fee_limit=1000000000,\\n call_value=0,\\n parameters=[{'type': 'address', 'value':account_address}],\\n issuer_address=account_address\\n )\\n addresses = addresses['constant_result']\\n decodeH = decode_hex(addresses[0])\\n decodeA= decode_abi(('uint256[]',),decodeH)\\n print(\\\"----------------------------------------------------\\\")\\n print(decodeA)\\n return decodeA[0]\",\n \"def get_keystone_token(con):\\n return con.get_token(con.session)\",\n \"def get_address(xpub):\\n return xpub.to_address() # p2pkh\",\n \"def get_mac_address(self):\\n\\t\\treturn call_sdk_function('PrlSrvCfgNet_GetMacAddress', self.handle)\",\n \"def get_mac_address(self):\\n\\t\\treturn call_sdk_function('PrlVmDevNet_GetMacAddress', self.handle)\",\n \"def token_id_hex(self) -> str: # this is *ALSO* a MINT property\\n return self.token_id.hex()\",\n \"def get_remit_to_address(self): \\n return self.remit_to_address\",\n \"def fetch_address(cpr: str) -> str:\\n\\n return \\\"Åbogade 15, 8200 Aarhus N\\\"\",\n \"def deposit_address(self):\\n response = self.query('deposit_address')\\n return response\",\n \"def address(self):\\n if self._address:\\n pass\\n elif 'address' in self.keystore:\\n self._address = decode_hex(self.keystore['address'])\\n elif not self.locked:\\n self._address = keys.privtoaddr(self.privkey)\\n else:\\n return None\\n return self._address\",\n \"def get_central_address():\\n scoreboard_config = CHAINBALL_CONFIGURATION.retrieve_configuration(\\n \\\"scoreboard\\\"\\n )\\n\\n return (\\n scoreboard_config[\\\"chainball_server\\\"],\\n scoreboard_config[\\\"chainball_server_token\\\"],\\n )\",\n \"def getSymbolAt(self, address: ghidra.program.model.address.Address, name: unicode, namespace: ghidra.program.model.symbol.Namespace) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def getTokens_utils(account_address, value=30000000000):\\n e = {'txid':'Error!'} \\n logsOfError = ''\\n try:\\n trigger = tron.transaction_builder.trigger_smart_contract(contract_address = TOKEN_CONTRACT,\\n function_selector = 'transfer(address,uint256)', #без пробелов!\\n fee_limit=1000000000,\\n call_value=0,\\n parameters=[{'type':'address','value':account_address},{'type': 'int256','value':value}],\\n issuer_address=TOKEN_CREATOR\\n )\\n\\n tron.private_key = TOKEN_CREATOR_PRIVATE_KEY\\n transaction = trigger['transaction']\\n signed1_tx = tron.trx.sign(transaction,True,False)\\n e = tron.trx.broadcast(signed1_tx)\\n except Exception as ex:\\n logsOfError = logsOfError + str(ex)\\n return {'txID':e['txid'], 'logs':logsOfError}\",\n \"def Address(self) -> _n_5_t_0:\",\n \"def _get_address(self, symbol):\\n if symbol.isdigit():\\n \\n return symbol\\n else:\\n if not self.symbols_table.contains(symbol):\\n self.symbols_table.add_entry(symbol, self.symbol_address)\\n self.symbol_address += 1\\n \\n return self.symbols_table.get_address(symbol)\",\n \"def get_addr(self):\\n return Server.t_addresses.get(threading.get_ident())\",\n \"def __get_mac_address(self):\\n str_hex_mac = uuid.UUID(int=uuid.getnode()).hex[-12:]\\n return str_hex_mac\",\n \"def gen_quote(token):\\n\\tmpk = global_storage.get_collector_master_public_key()\\n\\n\\tif not sanetoken(token):\\n\\t\\traise rpc_lib.RPCException(\\\"Token not sane.\\\")\\n\\n\\t# FIXME: Should we be worried about race conditions here?\\n\\tdbentry = SellerDB.get(token=token)\\n\\tif dbentry != None: # This token is already in the database.\\n\\t\\tindex, address, price = dbentry['index'], dbentry['address'], dbentry['price']\\n\\t\\tassert address == bitcoin.electrum_address(mpk, index) # Index is the index used to generate address.(deterministic key generation)\\n\\telse:\\n\\t\\t# Index is a large random number that combines with the master public key to yield the address. This combination takes constant time -- it doesn't hurt us to use a very large index. An attacker which knows index, mpk, address, and the _private_ key for address can get the private key for _any_ public key generated using mpk. To limit the damage if one private key gets leaked, we'll make index cryptographically securely random, even though it's probably unnecessary.\\n\\t\\tindex = random.SystemRandom().getrandbits(128)\\n\\t\\taddress = bitcoin.electrum_address(mpk, index)\\n\\t\\t# Price is the price to buy a bond, in satoshi. (We don't use BTC because we don't want floating point errors.)\\n\\t\\tprice = global_storage.bond_price\\n\\t\\tSellerDB.put(token=token, index=index, address=address, price=price)\\n\\treturn (address, price)\",\n \"def generate_deposit_address(self, currency):\\n return self.__call__('balance', \\\"generatedepositaddress\\\", \\n {\\\"currencyname\\\": currency})\",\n \"def get_contract_by_address(self, address: str):\\n try:\\n contract_records = self._registry.search(contract_address=address)\\n except RuntimeError:\\n raise self.InterfaceError('Corrupted Registrar') # TODO: Integrate with Registry\\n else:\\n if not contract_records:\\n raise self.InterfaceError(\\\"No such contract with address {}\\\".format(address))\\n return contract_records[0]\",\n \"def get_address_abi(name, mode):\\n dict_event = get_smart_contracts_dict(mode)\\n address, abi = dict_event[name]\\n\\n return address, abi\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def token(self) -> str:\\n return pulumi.get(self, \\\"token\\\")\",\n \"def get_address(self):\\n return self.address.line[0]+\\\", \\\"+self.address.city+\\\", \\\"+self.address.state+\\\", \\\"+self.address.country\",\n \"def nomad_address():\\n\\n print(nomad.get_address())\",\n \"def getSymbolAt(self, address: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.symbol.Symbol:\\n ...\",\n \"def symbol(self) -> str:\\n return self.current_token\",\n \"def get_offset_address():\\n return command(\\\"O\\\")\",\n \"def service_account_email_address(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"service_account_email_address\\\")\",\n \"def address(self, name):\\n return self.query(name).response.answer[0].items[0].address\",\n \"def get_address(machine: Machine) -> str:\\n default_route, _ = machine.run(\\\"ip route get 8.8.8.8\\\")\\n return re.search(\\\" src ([0-9.]+) \\\", default_route).group(1)\",\n \"def read_address(self, opcode: int) -> int:\\n\\n if self.insight:\\n self.insight.address(opcode)\\n\\n return opcode & 0xFFF\",\n \"def getNodeAddress(self, node):\\n return self.backend.configuration.getAddress(node)\",\n \"def endpoint_address(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"endpoint_address\\\")\",\n \"def do_getaddress(self,args):\\n ppdict(bitstamp.get_depositaddress())\",\n \"def token(self):\\n return self[\\\"token\\\"]\",\n \"def address(self):\\n return \\\"%s:%s\\\" % (self.ip, self.port)\",\n \"def generate(self):\\n return self.rpc.call(MsfRpcMethod.AuthTokenGenerate)['token']\",\n \"def get_mac_address(self):\\n self.__not_implemented()\",\n \"def address(self):\\n if self.con_strategy == \\\"local\\\":\\n return self.address_local()\\n if self.con_strategy == \\\"remote\\\":\\n return self.address_remote()\\n return None\",\n \"def token_cert(self):\\n return self._token_cert\",\n \"def token(chain: BaseChain) -> Contract:\\n return deploy_contract(chain, 'DSToken', args=['VIEW'])\",\n \"def get_address_id(self):\\n return self.complete_address[-1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6026088","0.6024718","0.6004629","0.5933634","0.5933634","0.5933634","0.5915871","0.5914371","0.5914371","0.59061444","0.5879427","0.58482677","0.5840453","0.5836381","0.5836381","0.5836381","0.5836381","0.5836381","0.5824099","0.58240896","0.5750373","0.5724404","0.5722317","0.5720737","0.57156396","0.5699539","0.5699539","0.5697395","0.56853724","0.56657887","0.56640273","0.5627282","0.5592411","0.55922085","0.5586938","0.5576224","0.5574696","0.5557741","0.55174816","0.5509829","0.5507365","0.54657584","0.545815","0.5453983","0.5453983","0.54428774","0.54080296","0.5383","0.5382189","0.5374889","0.53504026","0.53466886","0.53263825","0.53212047","0.53157574","0.52926326","0.5282958","0.5269165","0.5268918","0.5265806","0.5251184","0.52457714","0.5243663","0.523634","0.52334744","0.5229377","0.521917","0.52144116","0.5214339","0.5211959","0.5199572","0.5195896","0.5191317","0.51817983","0.51778686","0.51708955","0.5170892","0.51691264","0.51691264","0.51691264","0.5165624","0.5163943","0.5158016","0.51486343","0.5144857","0.5136051","0.5119675","0.51163733","0.5109107","0.51047707","0.50831133","0.50817686","0.5080667","0.5066075","0.5063638","0.5053329","0.5045461","0.5042788","0.50374544","0.5036624"],"string":"[\n \"0.6026088\",\n \"0.6024718\",\n \"0.6004629\",\n \"0.5933634\",\n \"0.5933634\",\n \"0.5933634\",\n \"0.5915871\",\n \"0.5914371\",\n \"0.5914371\",\n \"0.59061444\",\n \"0.5879427\",\n \"0.58482677\",\n \"0.5840453\",\n \"0.5836381\",\n \"0.5836381\",\n \"0.5836381\",\n \"0.5836381\",\n \"0.5836381\",\n \"0.5824099\",\n \"0.58240896\",\n \"0.5750373\",\n \"0.5724404\",\n \"0.5722317\",\n \"0.5720737\",\n \"0.57156396\",\n \"0.5699539\",\n \"0.5699539\",\n \"0.5697395\",\n \"0.56853724\",\n \"0.56657887\",\n \"0.56640273\",\n \"0.5627282\",\n \"0.5592411\",\n \"0.55922085\",\n \"0.5586938\",\n \"0.5576224\",\n \"0.5574696\",\n \"0.5557741\",\n \"0.55174816\",\n \"0.5509829\",\n \"0.5507365\",\n \"0.54657584\",\n \"0.545815\",\n \"0.5453983\",\n \"0.5453983\",\n \"0.54428774\",\n \"0.54080296\",\n \"0.5383\",\n \"0.5382189\",\n \"0.5374889\",\n \"0.53504026\",\n \"0.53466886\",\n \"0.53263825\",\n \"0.53212047\",\n \"0.53157574\",\n \"0.52926326\",\n \"0.5282958\",\n \"0.5269165\",\n \"0.5268918\",\n \"0.5265806\",\n \"0.5251184\",\n \"0.52457714\",\n \"0.5243663\",\n \"0.523634\",\n \"0.52334744\",\n \"0.5229377\",\n \"0.521917\",\n \"0.52144116\",\n \"0.5214339\",\n \"0.5211959\",\n \"0.5199572\",\n \"0.5195896\",\n \"0.5191317\",\n \"0.51817983\",\n \"0.51778686\",\n \"0.51708955\",\n \"0.5170892\",\n \"0.51691264\",\n \"0.51691264\",\n \"0.51691264\",\n \"0.5165624\",\n \"0.5163943\",\n \"0.5158016\",\n \"0.51486343\",\n \"0.5144857\",\n \"0.5136051\",\n \"0.5119675\",\n \"0.51163733\",\n \"0.5109107\",\n \"0.51047707\",\n \"0.50831133\",\n \"0.50817686\",\n \"0.5080667\",\n \"0.5066075\",\n \"0.5063638\",\n \"0.5053329\",\n \"0.5045461\",\n \"0.5042788\",\n \"0.50374544\",\n \"0.5036624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6808541"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84692,"cells":{"query":{"kind":"string","value":"Returns the total staked amount stored in a vardb _total_stake."},"document":{"kind":"string","value":"def getTotalStake(self) -> int:\n return self._total_stake.get()"},"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 total_spent(self):\n total_sum = Order.objects.filter(\n email=self.email).aggregate(\n Sum('total_price')\n ).get('total_price__sum')\n return round(total_sum, 4) if total_sum else 0","def total_sold(album):\n return album.total_sold","def total(self):\n if self.dynamic:\n self._update_db_obj()\n return self._db_obj.total","def get_total(self):\r\n \r\n return str(round(self._total, 2))","def total(self) -> float:\n return self._total","def total(self):\n\t\treturn self._total","def get_total(self):\n\n base_price = self.get_base_price()\n if self.species == \"christmas melon\":\n base_price = base_price * 1.5\n\n total = ((1 + self.tax) * self.qty * base_price)\n\n return total","def GetTotal(self):\n return(self.total)","def get_total(self):\n\n self.base_price = self.get_base_price()\n\n if self.species == \"christmas melon\":\n self.base_price = self.base_price * 1.5\n\n total = (1 + self.tax) * self.qty * self.base_price\n return total","def get_total(self):\n\n base_price = self.get_base_price()\n\n if self.species == \"Christmas\":\n base_price = base_price * 1.5\n\n total = (1 + self.tax) * self.qty * base_price\n\n return total","def get_total_spent() -> int:\n return base.Balances(balance_of).get(bank_account)","def get_total(self):\n\n total = super().get_total()\n if self.qty < 10:\n total += 3.00\n return total","def total_spent(self):\n\n approved_jobs = self.approved_jobs()\n expenses = self.expenses()\n\n total = 0\n for job in approved_jobs:\n total += job.total_paid\n\n for expense in expenses:\n total += expense.amount\n\n return float(round(total, 2))","def total(self) -> int:\n return self._total","def totalValue(self):\n\n\t\tvalue = 0\n\t\tfor bottle in self.bottles:\n\t\t\tvalue += bottle.inflatedCost\n\n\t\treturn value","def get_total_supply() -> int:\n return total_supply","def som(getallenlijst):\r\n total = sum(getallenlijst)\r\n return total","def get_fuel_total_saved (self):\n return self.electric_diesel_reduction + self.reduction_diesel_used","def get_total(self):\n # method on the class DomesticMelonOrder\n base_price = 5\n\n if self.species == \"Christmas melons\":\n base_price = base_price * 1.5\n\n total = (1 + self.tax) * self.qty * base_price\n\n return total","def get_total(self):\n\n base_price = self.get_base_price()\n\n # Christmas Melons are more x1.5 expensive than other melons\n if self.species == \"Christmas Melon\":\n base_price = base_price * 1.5\n\n total = (1 + self.tax) * self.qty * base_price\n\n return total","def get_total(self):\n\n base_price = 5\n \n if self.species == \"Christmas melon\":\n base_price = base_price * 1.5 \n\n total = (1 + self.tax) * self.qty * base_price \n\n if self.order_type == \"international\" and self.qty>10:\n total += 3\n\n\n return total","def get_total_redeem(self):\n total = 0\n for redeem in self.get_redeems():\n total += redeem.get_total()\n return total","def get_total_of_saleman(self, id):\n try:\n MySQLConnector().execute_query('select sum(price) from orders where saleman_id = {0};'.format(id))\n total_saleman = MySQLConnector().get_results()[0][0]\n except Error as er:\n logging.getLogger(__name__).error(\"Something went wrong with database %s\" % er)\n return total_saleman","def totalStations(analyzer):\n return model.totalStations(analyzer)","def get_total(self):\n total = super().get_total()\n\n if self.qty < 10:\n total += 3\n\n return total","def get_total(self):\n\n base_price=5\n if self.species == \"Christmas\":\n base_price=1.5*base_price\n \n total = (1 + self.tax) * self.qty * base_price\n\n if self.order_type==\"international\" and self.qty<10:\n total+=3\n\n return total","def guesstotal(self, message, db_session):\n user = self.ts.get_user(message)\n if db_session.query(db.MiscValue).filter(db.MiscValue.mv_key == 'guess-total-enabled').one().mv_value == \"True\":\n msg_list = self.ts.get_human_readable_message(message).split(' ')\n if len(msg_list) > 1:\n guess = msg_list[1]\n if guess.isdigit() and int(guess) >= 0:\n self._set_total_guess(user, guess, db_session)\n self._add_to_whisper_queue(user, \"{} your guess has been recorded.\".format(user))\n else:\n self._add_to_whisper_queue(user, \"Sorry {}, that's not a non-negative integer.\".format(user))\n else:\n self._add_to_whisper_queue(user,\n \"Sorry {}, you need to include a number after your guess.\".format(user))\n else:\n self._add_to_whisper_queue(user,\n \"Sorry {}, guessing for the total number of deaths is disabled.\".format(user))","def get_total(self):\n total = 0.00\n\n for _drink in self.drinks:\n total = total + _drink.get_price()\n\n for _food in self.food:\n total = total + _food.get_price()\n\n return total","def total_purchase(self):\n\n total_amount = 0\n #grab all the item\n items = self.item_set.all()\n for item in items:\n total_amount += item.price\n return total_amount","def total_points(self):\n total_points = 0.0\n for ingredient in self.ingredients:\n if (ingredient.has_property('ppg')):\n # Use given value if specified\n total_points += ingredient.property('ppg').to('ppg') * ingredient.quantity.to('lb')\n else:\n total_points += EXTRACTS[ingredient.type] * ingredient.quantity.to('lb')\n return(Quantity(total_points, 'points'))","def GOAL_TOTAL() -> int:\n return 21","def get_gst_subtotals(self):\n self.__subtotal_gst = 0\n for current_item in self.__items_list:\n self.__subtotal_gst += current_item.calculate_gst()\n return self.__subtotal_gst","def get_total(self):\n\n base_price = 5\n total = (1 + int(self.tax)) * int(self.qty) * base_price\n\n return total","def total(self):\n return self._evaluate()['hits']['total']","def total(self):\n return self._total_name","def get_total(contents):\n total = 0\n for line in contents:\n total += float(line.split(' || ')[3].split(' ')[0])\n\n return total","def get_total_paid(self):\n return sum(self.paid)","def test_total(self):\n result = self.test_client.total\n\n assert result == 730","def total(self):\n total_price = self.get_total_amount()\n discounts = self.get_total_discount()\n\n return total_price - discounts","def get_total(self) -> float:\n if self.__open:\n raise RuntimeError(\"Cash drawer must be closed to count.\")\n total: float = 0.0\n for denom in CashDenomination:\n total += self.__contents[denom] * denom.amount\n return total","def get_fuel_total_saved (self):\n #~ print self.lost_heat_recovery\n #~ print self.intertie_offset_generation_fuel_used\n #~ print self.pre_intertie_generation_fuel_used\n #~ gen_eff = self.cd[\"diesel generation efficiency\"]\n #~ fuel_used = self.intertie_offset_generation / gen_eff\n\n generation_diesel_reduction = \\\n np.array(self.pre_intertie_generation_fuel_used\\\n [:self.actual_project_life])\n return - np.array(self.lost_heat_recovery[:self.actual_project_life]) +\\\n generation_diesel_reduction","def total(self):\n return self._results.total","def total_sales(self):\n total_sales = 0\n items = self.item_set.filter(status=\"sold\")\n for item in items:\n total_sales += item.price\n return total_sales","def get_total(self):\n\n # Total sum\n self.sum = 0.00\n\n # Determine which Check buttons are selected\n # and add the charges to find the total\n if self.check_1.get() == 1:\n self.sum += 30.00\n if self.check_2.get() == 1:\n self.sum += 20.00\n if self.check_3.get() == 1:\n self.sum += 40.00\n if self.check_4.get() == 1:\n self.sum += 100.00\n if self.check_5.get() == 1:\n self.sum += 35.00\n if self.check_6.get() == 1:\n self.sum += 200.00\n if self.check_7.get() == 1:\n self.sum += 20.00\n\n # Convert the sum to string\n # and store in StringVar object\n # to automatically update the total_val label\n self.sum_str.set(self.sum)","def get_total_bets(self) -> int:\n return self._total_bet_count.get() + self._daily_bet_count.get()","def count_total(self):\n total = 0\n rpk_total = 0.0\n with open(self.filename, 'rU') as my_htseq:\n for line in my_htseq:\n if '_' not in line:\n line = line.rstrip('\\n').split('\\t')\n ensg_id = line[0]\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) / 1000.0\n count = int(line[1])\n total += count\n rpk_total += float(count/gene_len)\n return total, rpk_total","def total(self) -> int:\n if self._total is None:\n self._total = self.counts.sum()\n return self._total","def total_amount(self):\n total_amount = 0\n for cart_item in self.get_cart_items():\n total_amount += cart_item.total_price\n return total_amount","def _grand_total(self):\n count = 0\n for product in self.products:\n count += product.price\n return count","def sub_total():\n return sum(SAVE_PRICE)","def calc_total_money(stock):\n tot_amount = stock[\"five\"] * 5\n tot_amount += stock[\"one\"]\n tot_amount += stock[\"quarter\"] / 4\n tot_amount += stock[\"dime\"] / 10\n tot_amount += stock[\"nickel\"] / 20\n \n return (int(tot_amount), int(str(tot_amount)[str(tot_amount).find('.')+1::]))","def get_total_distributed(self) -> int:\n return self._total_distributed.get()","def update_total(self):\r\n likes = 0.00\r\n\r\n if self.get_hamburger.get():\r\n likes += 1.35\r\n\r\n if self.get_cheeseburger.get():\r\n likes += 1.59\r\n\r\n if self.get_bacon.get():\r\n likes += 1.79\r\n\r\n if self.get_drink.get():\r\n likes += 0.49\r\n \r\n self.result_txt.delete(0.0, END)\r\n self.result_txt.insert(0.0, likes)","def total(self):\n return sum(self.d.values())","def get_todays_bet_total(self) -> int:\n return self._daily_bet_count.get()","def total_qty(self):\n return sum(self.quantities)","def sum_total_amount(self):\n\n my_sumtotal = 0\n \n total_amount = self.data['Total Amount Due']\n \n for i in total_amount:\n my_sumtotal = my_sumtotal + float(i)\n\n return my_sumtotal","def concrete_total_force(self,strain, newFOS=None):\r\n\t\tstress = self.concrete_stress(strain, newFOS)\r\n\t\treturn sum(stress*(self.width*self.mesh_dz))","def calculate_total(self):\n if self.total_price == 0:\n for discount in self.discounts:\n for item in self.items:\n item.add_discount(discount)\n\n for item in self.items:\n self.total_price += item.final_price()\n\n return self.total_price","def display_sum_sold():\n sold_games = reports.sum_sold(filename)\n print(\n \"Total sold copies from {} file is: {} millions\\n\".format(\n filename,\n sold_games))","def get_inbound_statement_details_total_amount(self):\n return self.get_text_from_element(self.inbound_statements_details_total_amount_locator, True)","async def get_total(self, payload: str = None):\n if payload is None:\n raise RequiredPayload(\"You must provide at least one payload.\")\n data = await self._send_payload(payload)\n return data['total']","def total_amount(self):\n full_price = sum(item.price for item in self._products) if self._products else 0.0\n return full_price - self._get_discount()","def get_total_price(self):\n return sum(Decimal(item[\"price\"]) * item[\"qty\"] for item in self.cart.values())","def get_sum(self):\n return self.__tree[0]","def total(self):\n total = sum(self.d.values())\n return total","def total_money(self) -> LocationInitialMoneyModel:\n return self._total_money","def total_sold_quantity(self, total_sold_quantity):\n\n self._total_sold_quantity = total_sold_quantity","def budget_used(self):\n return int(self.total_spent() / self.budget() * 100.0)","def get_total_stateless(db):\n pass","def total_seconds_rested(self):\n pipeline = [\n {\"$match\": {'device': self._device, 'string': self._string}},\n {\"$group\": {\"_id\": '$device', 'total': {\"$sum\": '$duration'}}}\n ]\n results = list(self._db.aggregate(pipeline))\n try:\n return results[0].get('total', None)\n except Exception as e:\n self._logger.warning(\"No duration results found {}\".format(e.message))\n return 0","def get_total(self, _property=None):\n return self._get_total(\"event\", _property)","def total_market_value(self):\n return self.pos_handler.total_market_value()","def get_order_total(self):\n order_total = 0\n for item in self.cart_items:\n order_total += item['price']\n return order_total","def transfered_amount(self):\n return self.our_state.transfer_amount","def table_total(self):\n total = 0.00\n\n for customer in self.customers:\n total = total + customer.get_total()\n\n return total","def basket_total_before_discounts_incl_tax(self):\n result = self.lines.aggregate(total=Sum(\"line_price_before_discounts_incl_tax\"))\n return result[\"total\"]","def get_qst_subtotals(self):\n self.__subtotal_qst = 0\n for current_item in self.__items_list:\n self.__subtotal_qst += current_item.calculate_qst()\n return self.__subtotal_qst","def amount_on_field(self):\n\n query = \"\"\" SELECT SUM(field_entry.value::DOUBLE PRECISION)\n FROM crowdataapp_documentsetfieldentry field_entry\n INNER JOIN crowdataapp_documentsetformentry form_entry ON form_entry.id = field_entry.entry_id\n INNER JOIN crowdataapp_document document ON document.id = form_entry.document_id\n WHERE document.document_set_id = %d\n AND field_entry.verified = TRUE\n AND field_entry.field_id = %d\"\"\" % ( self.id, self.tosum_field.id)\n\n cursor = connection.cursor()\n cursor.execute(query)\n\n amount = cursor.fetchall()[0][0]\n\n return amount","def get_total_score(self):\n\n # Return the player's total score\n return self._total_score","def _total_d(self):\n debit = 0.0\n for l in self.data:\n debit += l['debit']\n self.t_credit += l['credit']\n self.t_balance += l['balance']\n return debit","def patrimony_total(self):\n pass","def test_total(snaptype):\n filename = DIR / snaptype.filename\n snap = plonk.load_snap(filename)\n\n total.accreted_mass(snap=snap)\n total.angular_momentum(snap=snap)\n total.center_of_mass(snap=snap)\n total.kinetic_energy(snap=snap)\n total.mass(snap=snap)\n total.momentum(snap=snap)\n total.specific_angular_momentum(snap=snap)\n total.specific_kinetic_energy(snap=snap)\n\n snap.close_file()","def get_total_price(self):\n subtotal = sum(Decimal(item['price']) * item['qty'] for item in self.basket.values())\n\n if subtotal == 0:\n shipping = Decimal(0.00)\n else:\n shipping = Decimal(11.50)\n\n total = subtotal + Decimal(shipping)\n return total","def amount(self):\n return self.subtotal + self.tax_subtotal + self.shipping","def update_total(self):\n self.objects[self.ids.AMOUNT].setText(\"Total Spend: \\xA3%.2f\" % (self.owner.total_price() / 100))","def get_total_price(self):\n i = self.get_copy_with_resolved_dependencies()\n total_price = Decimal(0)\n for product in i['products']:\n billed_price = Decimal(str(product.get('price', 0))) * Decimal(str(product.get('quantity')))\n total_price += billed_price\n return total_price","def totalSaved(self, fromdt, todt):\r\n return sum(self._buildTotalsDict(fromdt, todt).values()) \\\r\n + self.initialBalance","def calculate_total_cost(state):\r\n return state.cost()","def tot(self):\n return self.det + self.out + self.faint + self.late","def total_value(self):\n return self.parent.child_total_value[self.action]","def get_total_to_pay(self):\n self.__total_to_pay = Order.get_price_subtotals(self) + \\\n Order.get_qst_subtotals(self) + \\\n Order.get_gst_subtotals(self)\n return self.__total_to_pay","def amount_raised_by_tickets(self):\r\n return self.stats.amount_raised_by_tickets","def total_price(self):\n return self.owner.total_price()","def total(self, total):\n if self.local_vars_configuration.client_side_validation and total is None: # noqa: E501\n raise ValueError(\"Invalid value for `total`, must not be `None`\") # noqa: E501\n\n self._total = total","def ss_tot(self):\n return np.squeeze(self._ss_tot)","def calculate_total_price(total, taxes):\n total_price = total + taxes\n return total_price","def calc_total_btc():\n total_btc_val = 0\n for holding in val[\"accHoldings\"]:\n free = val[\"accHoldings\"][holding][\"free\"]\n locked = val[\"accHoldings\"][holding][\"locked\"]\n total = float(free) + float(locked)\n\n if holding + \"BTC\" in val[\"coins\"]:\n if holding != \"BTC\" and total * float(val[\"tickers\"][holding + \"BTC\"][\"lastPrice\"]) > 0.001:\n\n coin_total = total * float(val[\"tickers\"][holding + \"BTC\"][\"lastPrice\"])\n total_btc_val += coin_total\n\n elif holding == \"BTC\":\n total_btc_val += total\n\n total_formatted = '{number:.{digits}f}'.format(number=float(total_btc_val), digits=8) + \" BTC\"\n # print(\"total: \" + total_formatted)\n return total_formatted","def fs_size_total(self):\n return self._fs_size_total","def extras_total(self):\n total = self.wides + self.no_balls + self.byes + self.leg_byes\n return total"],"string":"[\n \"def total_spent(self):\\n total_sum = Order.objects.filter(\\n email=self.email).aggregate(\\n Sum('total_price')\\n ).get('total_price__sum')\\n return round(total_sum, 4) if total_sum else 0\",\n \"def total_sold(album):\\n return album.total_sold\",\n \"def total(self):\\n if self.dynamic:\\n self._update_db_obj()\\n return self._db_obj.total\",\n \"def get_total(self):\\r\\n \\r\\n return str(round(self._total, 2))\",\n \"def total(self) -> float:\\n return self._total\",\n \"def total(self):\\n\\t\\treturn self._total\",\n \"def get_total(self):\\n\\n base_price = self.get_base_price()\\n if self.species == \\\"christmas melon\\\":\\n base_price = base_price * 1.5\\n\\n total = ((1 + self.tax) * self.qty * base_price)\\n\\n return total\",\n \"def GetTotal(self):\\n return(self.total)\",\n \"def get_total(self):\\n\\n self.base_price = self.get_base_price()\\n\\n if self.species == \\\"christmas melon\\\":\\n self.base_price = self.base_price * 1.5\\n\\n total = (1 + self.tax) * self.qty * self.base_price\\n return total\",\n \"def get_total(self):\\n\\n base_price = self.get_base_price()\\n\\n if self.species == \\\"Christmas\\\":\\n base_price = base_price * 1.5\\n\\n total = (1 + self.tax) * self.qty * base_price\\n\\n return total\",\n \"def get_total_spent() -> int:\\n return base.Balances(balance_of).get(bank_account)\",\n \"def get_total(self):\\n\\n total = super().get_total()\\n if self.qty < 10:\\n total += 3.00\\n return total\",\n \"def total_spent(self):\\n\\n approved_jobs = self.approved_jobs()\\n expenses = self.expenses()\\n\\n total = 0\\n for job in approved_jobs:\\n total += job.total_paid\\n\\n for expense in expenses:\\n total += expense.amount\\n\\n return float(round(total, 2))\",\n \"def total(self) -> int:\\n return self._total\",\n \"def totalValue(self):\\n\\n\\t\\tvalue = 0\\n\\t\\tfor bottle in self.bottles:\\n\\t\\t\\tvalue += bottle.inflatedCost\\n\\n\\t\\treturn value\",\n \"def get_total_supply() -> int:\\n return total_supply\",\n \"def som(getallenlijst):\\r\\n total = sum(getallenlijst)\\r\\n return total\",\n \"def get_fuel_total_saved (self):\\n return self.electric_diesel_reduction + self.reduction_diesel_used\",\n \"def get_total(self):\\n # method on the class DomesticMelonOrder\\n base_price = 5\\n\\n if self.species == \\\"Christmas melons\\\":\\n base_price = base_price * 1.5\\n\\n total = (1 + self.tax) * self.qty * base_price\\n\\n return total\",\n \"def get_total(self):\\n\\n base_price = self.get_base_price()\\n\\n # Christmas Melons are more x1.5 expensive than other melons\\n if self.species == \\\"Christmas Melon\\\":\\n base_price = base_price * 1.5\\n\\n total = (1 + self.tax) * self.qty * base_price\\n\\n return total\",\n \"def get_total(self):\\n\\n base_price = 5\\n \\n if self.species == \\\"Christmas melon\\\":\\n base_price = base_price * 1.5 \\n\\n total = (1 + self.tax) * self.qty * base_price \\n\\n if self.order_type == \\\"international\\\" and self.qty>10:\\n total += 3\\n\\n\\n return total\",\n \"def get_total_redeem(self):\\n total = 0\\n for redeem in self.get_redeems():\\n total += redeem.get_total()\\n return total\",\n \"def get_total_of_saleman(self, id):\\n try:\\n MySQLConnector().execute_query('select sum(price) from orders where saleman_id = {0};'.format(id))\\n total_saleman = MySQLConnector().get_results()[0][0]\\n except Error as er:\\n logging.getLogger(__name__).error(\\\"Something went wrong with database %s\\\" % er)\\n return total_saleman\",\n \"def totalStations(analyzer):\\n return model.totalStations(analyzer)\",\n \"def get_total(self):\\n total = super().get_total()\\n\\n if self.qty < 10:\\n total += 3\\n\\n return total\",\n \"def get_total(self):\\n\\n base_price=5\\n if self.species == \\\"Christmas\\\":\\n base_price=1.5*base_price\\n \\n total = (1 + self.tax) * self.qty * base_price\\n\\n if self.order_type==\\\"international\\\" and self.qty<10:\\n total+=3\\n\\n return total\",\n \"def guesstotal(self, message, db_session):\\n user = self.ts.get_user(message)\\n if db_session.query(db.MiscValue).filter(db.MiscValue.mv_key == 'guess-total-enabled').one().mv_value == \\\"True\\\":\\n msg_list = self.ts.get_human_readable_message(message).split(' ')\\n if len(msg_list) > 1:\\n guess = msg_list[1]\\n if guess.isdigit() and int(guess) >= 0:\\n self._set_total_guess(user, guess, db_session)\\n self._add_to_whisper_queue(user, \\\"{} your guess has been recorded.\\\".format(user))\\n else:\\n self._add_to_whisper_queue(user, \\\"Sorry {}, that's not a non-negative integer.\\\".format(user))\\n else:\\n self._add_to_whisper_queue(user,\\n \\\"Sorry {}, you need to include a number after your guess.\\\".format(user))\\n else:\\n self._add_to_whisper_queue(user,\\n \\\"Sorry {}, guessing for the total number of deaths is disabled.\\\".format(user))\",\n \"def get_total(self):\\n total = 0.00\\n\\n for _drink in self.drinks:\\n total = total + _drink.get_price()\\n\\n for _food in self.food:\\n total = total + _food.get_price()\\n\\n return total\",\n \"def total_purchase(self):\\n\\n total_amount = 0\\n #grab all the item\\n items = self.item_set.all()\\n for item in items:\\n total_amount += item.price\\n return total_amount\",\n \"def total_points(self):\\n total_points = 0.0\\n for ingredient in self.ingredients:\\n if (ingredient.has_property('ppg')):\\n # Use given value if specified\\n total_points += ingredient.property('ppg').to('ppg') * ingredient.quantity.to('lb')\\n else:\\n total_points += EXTRACTS[ingredient.type] * ingredient.quantity.to('lb')\\n return(Quantity(total_points, 'points'))\",\n \"def GOAL_TOTAL() -> int:\\n return 21\",\n \"def get_gst_subtotals(self):\\n self.__subtotal_gst = 0\\n for current_item in self.__items_list:\\n self.__subtotal_gst += current_item.calculate_gst()\\n return self.__subtotal_gst\",\n \"def get_total(self):\\n\\n base_price = 5\\n total = (1 + int(self.tax)) * int(self.qty) * base_price\\n\\n return total\",\n \"def total(self):\\n return self._evaluate()['hits']['total']\",\n \"def total(self):\\n return self._total_name\",\n \"def get_total(contents):\\n total = 0\\n for line in contents:\\n total += float(line.split(' || ')[3].split(' ')[0])\\n\\n return total\",\n \"def get_total_paid(self):\\n return sum(self.paid)\",\n \"def test_total(self):\\n result = self.test_client.total\\n\\n assert result == 730\",\n \"def total(self):\\n total_price = self.get_total_amount()\\n discounts = self.get_total_discount()\\n\\n return total_price - discounts\",\n \"def get_total(self) -> float:\\n if self.__open:\\n raise RuntimeError(\\\"Cash drawer must be closed to count.\\\")\\n total: float = 0.0\\n for denom in CashDenomination:\\n total += self.__contents[denom] * denom.amount\\n return total\",\n \"def get_fuel_total_saved (self):\\n #~ print self.lost_heat_recovery\\n #~ print self.intertie_offset_generation_fuel_used\\n #~ print self.pre_intertie_generation_fuel_used\\n #~ gen_eff = self.cd[\\\"diesel generation efficiency\\\"]\\n #~ fuel_used = self.intertie_offset_generation / gen_eff\\n\\n generation_diesel_reduction = \\\\\\n np.array(self.pre_intertie_generation_fuel_used\\\\\\n [:self.actual_project_life])\\n return - np.array(self.lost_heat_recovery[:self.actual_project_life]) +\\\\\\n generation_diesel_reduction\",\n \"def total(self):\\n return self._results.total\",\n \"def total_sales(self):\\n total_sales = 0\\n items = self.item_set.filter(status=\\\"sold\\\")\\n for item in items:\\n total_sales += item.price\\n return total_sales\",\n \"def get_total(self):\\n\\n # Total sum\\n self.sum = 0.00\\n\\n # Determine which Check buttons are selected\\n # and add the charges to find the total\\n if self.check_1.get() == 1:\\n self.sum += 30.00\\n if self.check_2.get() == 1:\\n self.sum += 20.00\\n if self.check_3.get() == 1:\\n self.sum += 40.00\\n if self.check_4.get() == 1:\\n self.sum += 100.00\\n if self.check_5.get() == 1:\\n self.sum += 35.00\\n if self.check_6.get() == 1:\\n self.sum += 200.00\\n if self.check_7.get() == 1:\\n self.sum += 20.00\\n\\n # Convert the sum to string\\n # and store in StringVar object\\n # to automatically update the total_val label\\n self.sum_str.set(self.sum)\",\n \"def get_total_bets(self) -> int:\\n return self._total_bet_count.get() + self._daily_bet_count.get()\",\n \"def count_total(self):\\n total = 0\\n rpk_total = 0.0\\n with open(self.filename, 'rU') as my_htseq:\\n for line in my_htseq:\\n if '_' not in line:\\n line = line.rstrip('\\\\n').split('\\\\t')\\n ensg_id = line[0]\\n gene_len = len(set(self.gtf.gene_coords[ensg_id])) / 1000.0\\n count = int(line[1])\\n total += count\\n rpk_total += float(count/gene_len)\\n return total, rpk_total\",\n \"def total(self) -> int:\\n if self._total is None:\\n self._total = self.counts.sum()\\n return self._total\",\n \"def total_amount(self):\\n total_amount = 0\\n for cart_item in self.get_cart_items():\\n total_amount += cart_item.total_price\\n return total_amount\",\n \"def _grand_total(self):\\n count = 0\\n for product in self.products:\\n count += product.price\\n return count\",\n \"def sub_total():\\n return sum(SAVE_PRICE)\",\n \"def calc_total_money(stock):\\n tot_amount = stock[\\\"five\\\"] * 5\\n tot_amount += stock[\\\"one\\\"]\\n tot_amount += stock[\\\"quarter\\\"] / 4\\n tot_amount += stock[\\\"dime\\\"] / 10\\n tot_amount += stock[\\\"nickel\\\"] / 20\\n \\n return (int(tot_amount), int(str(tot_amount)[str(tot_amount).find('.')+1::]))\",\n \"def get_total_distributed(self) -> int:\\n return self._total_distributed.get()\",\n \"def update_total(self):\\r\\n likes = 0.00\\r\\n\\r\\n if self.get_hamburger.get():\\r\\n likes += 1.35\\r\\n\\r\\n if self.get_cheeseburger.get():\\r\\n likes += 1.59\\r\\n\\r\\n if self.get_bacon.get():\\r\\n likes += 1.79\\r\\n\\r\\n if self.get_drink.get():\\r\\n likes += 0.49\\r\\n \\r\\n self.result_txt.delete(0.0, END)\\r\\n self.result_txt.insert(0.0, likes)\",\n \"def total(self):\\n return sum(self.d.values())\",\n \"def get_todays_bet_total(self) -> int:\\n return self._daily_bet_count.get()\",\n \"def total_qty(self):\\n return sum(self.quantities)\",\n \"def sum_total_amount(self):\\n\\n my_sumtotal = 0\\n \\n total_amount = self.data['Total Amount Due']\\n \\n for i in total_amount:\\n my_sumtotal = my_sumtotal + float(i)\\n\\n return my_sumtotal\",\n \"def concrete_total_force(self,strain, newFOS=None):\\r\\n\\t\\tstress = self.concrete_stress(strain, newFOS)\\r\\n\\t\\treturn sum(stress*(self.width*self.mesh_dz))\",\n \"def calculate_total(self):\\n if self.total_price == 0:\\n for discount in self.discounts:\\n for item in self.items:\\n item.add_discount(discount)\\n\\n for item in self.items:\\n self.total_price += item.final_price()\\n\\n return self.total_price\",\n \"def display_sum_sold():\\n sold_games = reports.sum_sold(filename)\\n print(\\n \\\"Total sold copies from {} file is: {} millions\\\\n\\\".format(\\n filename,\\n sold_games))\",\n \"def get_inbound_statement_details_total_amount(self):\\n return self.get_text_from_element(self.inbound_statements_details_total_amount_locator, True)\",\n \"async def get_total(self, payload: str = None):\\n if payload is None:\\n raise RequiredPayload(\\\"You must provide at least one payload.\\\")\\n data = await self._send_payload(payload)\\n return data['total']\",\n \"def total_amount(self):\\n full_price = sum(item.price for item in self._products) if self._products else 0.0\\n return full_price - self._get_discount()\",\n \"def get_total_price(self):\\n return sum(Decimal(item[\\\"price\\\"]) * item[\\\"qty\\\"] for item in self.cart.values())\",\n \"def get_sum(self):\\n return self.__tree[0]\",\n \"def total(self):\\n total = sum(self.d.values())\\n return total\",\n \"def total_money(self) -> LocationInitialMoneyModel:\\n return self._total_money\",\n \"def total_sold_quantity(self, total_sold_quantity):\\n\\n self._total_sold_quantity = total_sold_quantity\",\n \"def budget_used(self):\\n return int(self.total_spent() / self.budget() * 100.0)\",\n \"def get_total_stateless(db):\\n pass\",\n \"def total_seconds_rested(self):\\n pipeline = [\\n {\\\"$match\\\": {'device': self._device, 'string': self._string}},\\n {\\\"$group\\\": {\\\"_id\\\": '$device', 'total': {\\\"$sum\\\": '$duration'}}}\\n ]\\n results = list(self._db.aggregate(pipeline))\\n try:\\n return results[0].get('total', None)\\n except Exception as e:\\n self._logger.warning(\\\"No duration results found {}\\\".format(e.message))\\n return 0\",\n \"def get_total(self, _property=None):\\n return self._get_total(\\\"event\\\", _property)\",\n \"def total_market_value(self):\\n return self.pos_handler.total_market_value()\",\n \"def get_order_total(self):\\n order_total = 0\\n for item in self.cart_items:\\n order_total += item['price']\\n return order_total\",\n \"def transfered_amount(self):\\n return self.our_state.transfer_amount\",\n \"def table_total(self):\\n total = 0.00\\n\\n for customer in self.customers:\\n total = total + customer.get_total()\\n\\n return total\",\n \"def basket_total_before_discounts_incl_tax(self):\\n result = self.lines.aggregate(total=Sum(\\\"line_price_before_discounts_incl_tax\\\"))\\n return result[\\\"total\\\"]\",\n \"def get_qst_subtotals(self):\\n self.__subtotal_qst = 0\\n for current_item in self.__items_list:\\n self.__subtotal_qst += current_item.calculate_qst()\\n return self.__subtotal_qst\",\n \"def amount_on_field(self):\\n\\n query = \\\"\\\"\\\" SELECT SUM(field_entry.value::DOUBLE PRECISION)\\n FROM crowdataapp_documentsetfieldentry field_entry\\n INNER JOIN crowdataapp_documentsetformentry form_entry ON form_entry.id = field_entry.entry_id\\n INNER JOIN crowdataapp_document document ON document.id = form_entry.document_id\\n WHERE document.document_set_id = %d\\n AND field_entry.verified = TRUE\\n AND field_entry.field_id = %d\\\"\\\"\\\" % ( self.id, self.tosum_field.id)\\n\\n cursor = connection.cursor()\\n cursor.execute(query)\\n\\n amount = cursor.fetchall()[0][0]\\n\\n return amount\",\n \"def get_total_score(self):\\n\\n # Return the player's total score\\n return self._total_score\",\n \"def _total_d(self):\\n debit = 0.0\\n for l in self.data:\\n debit += l['debit']\\n self.t_credit += l['credit']\\n self.t_balance += l['balance']\\n return debit\",\n \"def patrimony_total(self):\\n pass\",\n \"def test_total(snaptype):\\n filename = DIR / snaptype.filename\\n snap = plonk.load_snap(filename)\\n\\n total.accreted_mass(snap=snap)\\n total.angular_momentum(snap=snap)\\n total.center_of_mass(snap=snap)\\n total.kinetic_energy(snap=snap)\\n total.mass(snap=snap)\\n total.momentum(snap=snap)\\n total.specific_angular_momentum(snap=snap)\\n total.specific_kinetic_energy(snap=snap)\\n\\n snap.close_file()\",\n \"def get_total_price(self):\\n subtotal = sum(Decimal(item['price']) * item['qty'] for item in self.basket.values())\\n\\n if subtotal == 0:\\n shipping = Decimal(0.00)\\n else:\\n shipping = Decimal(11.50)\\n\\n total = subtotal + Decimal(shipping)\\n return total\",\n \"def amount(self):\\n return self.subtotal + self.tax_subtotal + self.shipping\",\n \"def update_total(self):\\n self.objects[self.ids.AMOUNT].setText(\\\"Total Spend: \\\\xA3%.2f\\\" % (self.owner.total_price() / 100))\",\n \"def get_total_price(self):\\n i = self.get_copy_with_resolved_dependencies()\\n total_price = Decimal(0)\\n for product in i['products']:\\n billed_price = Decimal(str(product.get('price', 0))) * Decimal(str(product.get('quantity')))\\n total_price += billed_price\\n return total_price\",\n \"def totalSaved(self, fromdt, todt):\\r\\n return sum(self._buildTotalsDict(fromdt, todt).values()) \\\\\\r\\n + self.initialBalance\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def tot(self):\\n return self.det + self.out + self.faint + self.late\",\n \"def total_value(self):\\n return self.parent.child_total_value[self.action]\",\n \"def get_total_to_pay(self):\\n self.__total_to_pay = Order.get_price_subtotals(self) + \\\\\\n Order.get_qst_subtotals(self) + \\\\\\n Order.get_gst_subtotals(self)\\n return self.__total_to_pay\",\n \"def amount_raised_by_tickets(self):\\r\\n return self.stats.amount_raised_by_tickets\",\n \"def total_price(self):\\n return self.owner.total_price()\",\n \"def total(self, total):\\n if self.local_vars_configuration.client_side_validation and total is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `total`, must not be `None`\\\") # noqa: E501\\n\\n self._total = total\",\n \"def ss_tot(self):\\n return np.squeeze(self._ss_tot)\",\n \"def calculate_total_price(total, taxes):\\n total_price = total + taxes\\n return total_price\",\n \"def calc_total_btc():\\n total_btc_val = 0\\n for holding in val[\\\"accHoldings\\\"]:\\n free = val[\\\"accHoldings\\\"][holding][\\\"free\\\"]\\n locked = val[\\\"accHoldings\\\"][holding][\\\"locked\\\"]\\n total = float(free) + float(locked)\\n\\n if holding + \\\"BTC\\\" in val[\\\"coins\\\"]:\\n if holding != \\\"BTC\\\" and total * float(val[\\\"tickers\\\"][holding + \\\"BTC\\\"][\\\"lastPrice\\\"]) > 0.001:\\n\\n coin_total = total * float(val[\\\"tickers\\\"][holding + \\\"BTC\\\"][\\\"lastPrice\\\"])\\n total_btc_val += coin_total\\n\\n elif holding == \\\"BTC\\\":\\n total_btc_val += total\\n\\n total_formatted = '{number:.{digits}f}'.format(number=float(total_btc_val), digits=8) + \\\" BTC\\\"\\n # print(\\\"total: \\\" + total_formatted)\\n return total_formatted\",\n \"def fs_size_total(self):\\n return self._fs_size_total\",\n \"def extras_total(self):\\n total = self.wides + self.no_balls + self.byes + self.leg_byes\\n return total\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65858716","0.6538318","0.62111753","0.6138218","0.6135569","0.6123897","0.6095115","0.60794395","0.60766083","0.6074283","0.6031743","0.5965689","0.5964389","0.59520096","0.5926538","0.59139526","0.590713","0.5894734","0.58571315","0.5856632","0.58303833","0.5819759","0.5796858","0.5795439","0.5788535","0.5772919","0.57423455","0.5681619","0.56556714","0.5653375","0.56508493","0.5641583","0.5640442","0.5633924","0.5631415","0.5620986","0.56127584","0.56125087","0.56065613","0.55900776","0.55687064","0.55511975","0.5545289","0.552788","0.5509765","0.5508298","0.550696","0.5505528","0.5504585","0.55034906","0.54993486","0.54911137","0.5490865","0.5489029","0.5477603","0.5476934","0.5476323","0.5464888","0.546272","0.5461257","0.5449248","0.54466146","0.5437684","0.54338586","0.5431561","0.54226214","0.5410405","0.5404595","0.539409","0.53922725","0.5390874","0.538691","0.53825736","0.5377831","0.5375089","0.53714406","0.5370909","0.53620094","0.5361673","0.5356262","0.53424275","0.5339523","0.53354573","0.5332385","0.532902","0.53235704","0.5321676","0.5316434","0.5313571","0.53132695","0.5310902","0.5309123","0.5297917","0.5277569","0.5274426","0.5272788","0.52672946","0.5259121","0.52526295","0.52345735"],"string":"[\n \"0.65858716\",\n \"0.6538318\",\n \"0.62111753\",\n \"0.6138218\",\n \"0.6135569\",\n \"0.6123897\",\n \"0.6095115\",\n \"0.60794395\",\n \"0.60766083\",\n \"0.6074283\",\n \"0.6031743\",\n \"0.5965689\",\n \"0.5964389\",\n \"0.59520096\",\n \"0.5926538\",\n \"0.59139526\",\n \"0.590713\",\n \"0.5894734\",\n \"0.58571315\",\n \"0.5856632\",\n \"0.58303833\",\n \"0.5819759\",\n \"0.5796858\",\n \"0.5795439\",\n \"0.5788535\",\n \"0.5772919\",\n \"0.57423455\",\n \"0.5681619\",\n \"0.56556714\",\n \"0.5653375\",\n \"0.56508493\",\n \"0.5641583\",\n \"0.5640442\",\n \"0.5633924\",\n \"0.5631415\",\n \"0.5620986\",\n \"0.56127584\",\n \"0.56125087\",\n \"0.56065613\",\n \"0.55900776\",\n \"0.55687064\",\n \"0.55511975\",\n \"0.5545289\",\n \"0.552788\",\n \"0.5509765\",\n \"0.5508298\",\n \"0.550696\",\n \"0.5505528\",\n \"0.5504585\",\n \"0.55034906\",\n \"0.54993486\",\n \"0.54911137\",\n \"0.5490865\",\n \"0.5489029\",\n \"0.5477603\",\n \"0.5476934\",\n \"0.5476323\",\n \"0.5464888\",\n \"0.546272\",\n \"0.5461257\",\n \"0.5449248\",\n \"0.54466146\",\n \"0.5437684\",\n \"0.54338586\",\n \"0.5431561\",\n \"0.54226214\",\n \"0.5410405\",\n \"0.5404595\",\n \"0.539409\",\n \"0.53922725\",\n \"0.5390874\",\n \"0.538691\",\n \"0.53825736\",\n \"0.5377831\",\n \"0.5375089\",\n \"0.53714406\",\n \"0.5370909\",\n \"0.53620094\",\n \"0.5361673\",\n \"0.5356262\",\n \"0.53424275\",\n \"0.5339523\",\n \"0.53354573\",\n \"0.5332385\",\n \"0.532902\",\n \"0.53235704\",\n \"0.5321676\",\n \"0.5316434\",\n \"0.5313571\",\n \"0.53132695\",\n \"0.5310902\",\n \"0.5309123\",\n \"0.5297917\",\n \"0.5277569\",\n \"0.5274426\",\n \"0.5272788\",\n \"0.52672946\",\n \"0.5259121\",\n \"0.52526295\",\n \"0.52345735\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8146318"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84693,"cells":{"query":{"kind":"string","value":"Returns the total rewards earned up to now by the staking contract."},"document":{"kind":"string","value":"def getLifetimeReward(self) -> int:\n return self._total_lifetime_reward.get()"},"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 total_rewards(self) -> float:\n return self.__total_rewards","def getTotalReward(self):\n return self.cumreward","def getTotalReward(self):\n return self.cumreward","def getTotalReward(self):\n return self.lastFitness","def total_reward(self):\n return np.sum(self.rewards)","def total_earnings(self):\n return self.total_balance - self.net_invested","def get_ave_reward(self):\n return sum(self._gameRewards) / len(self._gameRewards)","def get_ave_reward(self):\n return sum(self._gameRewards) / len(self._gameRewards)","def get_ave_reward(self):\n return sum(self._gameRewards) / len(self._gameRewards)","def _get_reward(self):\n if self.is_game_done:\n return self.price - 1\n else:\n return 0.0","def get_total_redeem(self):\n total = 0\n for redeem in self.get_redeems():\n total += redeem.get_total()\n return total","def average_reward(self):\n T = len(self)\n return np.sum(self.rewards / T)","def remaining(self):\n if self.goal:\n return self.goal - self.total_donated()\n else:\n return 0","def amount_raised(self):\r\n return self.stats.amount_raised","def get_reward(self):\n \n ##get total reward value from Q\n total_reward = 0.0\n for value in self.Q.itervalues():\n total_reward = total_reward + value\n \n ##return the average reward\n return total_reward","def get_reward(self):\n \n ##get total reward value from Q\n total_reward = 0.0\n for value in self.Q.itervalues():\n total_reward = total_reward + value\n \n ##return the average reward\n return total_reward","def _get_reward(self):\n if self.status():\n return self.current_step/self.ep_length # the reward is proportional to the duration \n else:\n return 0","def get_actions_remaining(self):\n return self.get_max_praises() - self.current_used","def _compute_reward(self):\n reward = 0.0\n return reward","def rewards(self):\n return self._rewards.getSlice(0)","def _reward(self):\n\n return 1-self.step_count/ self.max_steps","def rewards(self):\n\n return self._rewards.getSlice(0)","def total_clearance(self):\n total_clearances = 0\n debit = 0 #variable to track the remaining debit\n clearances = self.clearance_set.all() #grab all the previous clerances\n for clearance in clearances:\n total_clearances += clearance.paid_value\n return total_clearances","def example_reward(self,stock=None, action=None, current_date = None, products=None, orders=None, procurements=None):\n\n out = 0\n for key in stock:\n out += stock[key]\n return out * -1","def decreases_remaining(self):\n return 2 - self.decreases_today","def calculate_reward(self):\n if AT.REWARD not in self.attributes:\n return (0, 1)\n return self.attributes[AT.REWARD].calculate(self)","def get_reward(self):\n return self.calc_reward(self.sim.pose[:3], self.sim.v)","def reward(self):\n return self._reward","def total_raised(self):\n return self.total_donated() + (self.community_contribution or 0)","def reward(self):\n if self._state is None:\n return 0\n return self.reward_fn(self._state)","def balance(self):\n total_money = 0\n for item in self.ledger:\n total_money += item['amount']\n return total_money","def get_reward(self):\n\t\tdist = np.sqrt(np.sum(np.square(np.asarray(self.state) - np.asarray(self.goal))))\n\n\t\tdist_diff = self.prev_dist - dist\n\t\tself.reward = dist_diff * 10\n\n\t\tself.prev_dist = dist","def _compute_reward(self):\n last_score = self.episode_qualities[-2]\n new_score = self.episode_qualities[-1]\n reward = new_score - last_score\n return reward","def _compute_reward(self): \n reward = -1\n return reward","def get_balance(self):\n final_amount = 0\n for i in range(len(self.ledger)):\n final_amount += self.ledger[i]['amount']\n return final_amount","def block_reward_calc(block_number):\n\n # FIXME: Magic number? Unify\n return int((remaining_emission(config.dev.max_coin_supply, block_number - 1)\n - remaining_emission(config.dev.max_coin_supply, block_number)) * 100000000)","def outstanding(self):\n return sum(\n transfer.lock.amount\n for transfer in self.locked.values()\n )","def net_gains(self):\n if self.shares == 0:\n self.debug += '\\nNo shares owned.'\n else:\n price = self.daily['Adj Close'][-1]\n gains = self.shares * (price - self.avg_paid)\n percent = (price / self.avg_paid - 1) * 100\n gains = round(gains, 2)\n percent = round(percent, 2)\n if gains < 0:\n penalty = self.sells - int(round(self.sells / 3.0, 0))\n self.debug += '\\nNET LOSS: {}, {}%, AVOID SELLING! sells - {}'.format(gains, percent, penalty)\n self.sells -= penalty\n else:\n self.debug += '\\nNet gains: ${}, {}%'.format(gains, percent)","def reward(self) -> float:\n\n if not self._reward_provided:\n self._reward_provided = True\n return self._reward\n\n return 0","def get_reward(self, done):\n reward = 0\n self.calc_pos_diff_ratio()\n reward = self.calc_base_reward_2(reward)\n\n return reward","def amount_raised_online(self):\r\n return self.stats.amount_raised_online","def get_reward(self):\n\t\t# returns the reward for current state\n\n\t\t#temporary line for testing:\n\t\t#return self.reward_idea() # also not working yet\n\n\t\tcost = self.cost_function()\n\t\tconstraints_violation = self.get_constraints_violation()\n\t\t#old_aug_cost = self.augmented_cost\n\t\t#new_aug_cost = self.get_augmented_cost(cost,constraints_violation)\n\t\t#reward = old_aug_cost - new_aug_cost # reward formula\n\t\t#self.augmented_cost = new_aug_cost # update augmented_cost\n\t\treward = -self.get_augmented_cost(cost,constraints_violation)\n\t\t#print(\"***\\nDEBUG cost: \" +str(cost)+\" constraints_violation: \"+str(constraints_violation))\n\t\t#print(\"DEBUG reward: \"+str(reward))\n\t\t'''\n\t\t#old idea that is probably bad and not necessary:\n\t\tif(self.step_count == 0):\n\t\t\t# old_aug_cost doesn't exist in first step... ACTUALLY IT DOES!\n\t\t\tprint(\"DEBUG step_count == 0, reward would be \"+str(reward))\n\t\t\tprint(\"DEBUG old_aug_cost: \"+str(old_aug_cost) + \" new_aug_cost: \"+str(new_aug_cost) )\n\t\t\treturn 0\n\t\t'''\n\n\t\treturn reward","def calculate_reward(self):\n cur_dist = self.get_xy_distance()\n # reduce agent specific reward such that electricity costs are not\n # higher than moving towards the goal\n reward = self.old_dist - cur_dist + 0.01 * self.agent.specific_reward()\n self.old_dist = cur_dist\n\n return reward","def getReward(game):\n reward = 0\n\n # Reward +10 if destroys asteroid\n if game.gameLevel.asteroidDestroyed():\n reward += 10\n\n # Reward +20 if level cleared\n if game.gameLevel.levelCleared:\n reward += 20\n\n # Reward -10 if hits asteroid\n if game.gameLevel.gameOver:\n reward -= 10\n \n # Reward -1 if a second passes\n # ToDo: implement timeout in gameLevel\n\n return reward","def episode_total_score(self):\n return self.game.get_total_reward()","def wages(self):\n amount = (\n self.farmer.labor_cost()\n + self.reseller.labor_cost()\n + self.cofiring_plant.cofuel_om_wages()\n - self.coal_wages_lost\n )\n return display_as(amount, \"kUSD\")","def get_ave_reward(self):\n return self._sumStat_Reward.get_mean()","def amount_raised_by_tickets(self):\r\n return self.stats.amount_raised_by_tickets","def _accumulate_rewards(self) -> None:\n for agent, reward in self.rewards.items():\n self._cumulative_rewards[agent] += reward","def backCoins(self):\n return self.current.backCoins()","def calculate_reward(self):\n cur_dist = self.get_xy_distance()\n reward = self.old_dist - cur_dist + 0.01 * self.agent.specific_reward()\n self.old_dist = cur_dist\n return reward","def getTotalStake(self) -> int:\n return self._total_stake.get()","def get_reward(self) -> float:\r\n field = self.fields[self.agent_x][self.agent_y]\r\n if field == Field.EMPTY:\r\n return self.rew_empty\r\n elif field == Field.POS_TERMINAL:\r\n return self.rew_pos\r\n elif field == Field.NEG_TERMINAL:\r\n return self.rew_neg\r\n\r\n raise ValueError # Agent is standing on an illegal tile!\r","def get_withdrawals(self):\n withdrawals = 0\n for transaction in self.ledger:\n amount = transaction[\"amount\"]\n if amount < 0:\n withdrawals += abs(amount)\n return withdrawals","def get_reward(self):\n reward, self.reward = self.reward, 0\n return reward","def get_balance(self):\n balance = 0\n for transaction in self.ledger:\n balance += transaction[\"amount\"]\n return balance","def get_rewards(self):\n for i in self.REWARDS:\n self.get_reward(i)","def balance(self) -> int:\r\n if self._top == None:\r\n return 0\r\n return self._top.balance()","def CalcCostForTurn(self):\r\n costsThisTurn = 0\r\n \r\n inventoryStorageCost = self.currentStock * STORAGE_COST_PER_UNIT\r\n backorderPenaltyCost = self.currentOrders * BACKORDER_PENALTY_COST_PER_UNIT\r\n \r\n costsThisTurn = inventoryStorageCost + backorderPenaltyCost\r\n \r\n return costsThisTurn","def get_cumulative_rewards(rewards, # rewards at each step\r\n gamma=0.99 # discount for reward\r\n ):\r\n cumulative_rewards = []\r\n prev = 0\r\n\r\n for r in reversed(rewards):\r\n prev = r + gamma * prev\r\n cumulative_rewards.append(prev)\r\n cumulative_rewards.reverse()\r\n return cumulative_rewards","def _get_reward(self, five_cards):\n \n return 1-self.evaluator.get_five_card_rank_percentage(self.evaluator._five(five_cards))","def get_rewards_score(self) -> Address:\n return self._rewards_score.get()","def reward_from_events(self, events: List[str]) -> int:\n game_rewards = {\n e.COIN_COLLECTED: 10,\n # e.KILLED_OPPONENT: 5,\n e.KILLED_SELF: -100,\n # e.GOT_KILLED: -10,\n # e.OPPONENT_ELIMINATED: 1,\n e.WAITED: -0.1,\n e.BOMB_DROPPED: 0,\n # e.BOMB_EXPLODED: 0,\n e.CRATE_DESTROYED: 4,\n e.COIN_FOUND: 0.5,\n e.INVALID_ACTION: -5,\n e.MOVED_UP: -0.1,\n e.MOVED_DOWN: -0.1,\n e.MOVED_LEFT: -0.1,\n e.MOVED_RIGHT: -0.1,\n e.SURVIVED_ROUND: 0,\n MOVED_AWAY_FROM_BOMB: 3.5,\n MOVED_TOWARDS_BOMB: -3.5,\n USELESS_BOMB: -4,\n USEFUL_BOMB: 2,\n WAITED_IN_DANGER: -2,\n DEAD_END: -25\n }\n\n reward_sum = 0\n\n for event in events:\n if event in game_rewards:\n reward_sum += game_rewards[event]\n\n # print(reward_sum, events)\n\n self.logger.info(f\"Awarded {reward_sum} for events {', '.join(events)}\")\n return reward_sum","def credits_earned(self):\n\n if self.grade() >= 69.5:\n return self.nCredits\n else:\n return 0.0","def get_reward(self, state, reward, done):\n\n # simple reward = position. Don't explicitly incentivise agent to take left hill as well as right hill\n # let it figure it out by itself\n if done and self.success:\n return 100\n else:\n return (state[0]-0.5)/3","def determineAmountToCall(self, player):\n\t\treturn sum(self.currentBet) - sum(player.betAmount)","def discount_rewards(rewards):\r\n discounted_r = np.zeros_like(rewards)\r\n running_add = 0\r\n for t in reversed(range(0, len(rewards))): \r\n running_add = running_add * reward_discount + rewards[t]\r\n discounted_r[t] = running_add\r\n return discounted_r","def hand_total(self):\n\n total = 0\n for card in self.__hand:\n total += card.blackjack_value()\n return total","def payout(self, amt: float):\n total_screen_time = 0\n for character in self.characters:\n total_screen_time += character._screen_time\n for character in self.characters:\n character._money = amt * character._screen_time / total_screen_time\n return # FIXME","def win(self) -> int:\n earnings: int = self._bet\n\n # If it has a blackjack, the earnings increments 1.5 times\n for hand in self._hands:\n if hand.has_blackjack():\n earnings = round(earnings * 1.5)\n\n self._actual_money += earnings\n return earnings","def calculateReward(self, bonus=0):\n reward = -1 + bonus\n\n if ((self.last_system_action[\"action\"]==\"sugg-all\" and self.last_user_action[\"action\"]!=\"eli-sugg-all\") or \n (\"change-page\" in self.last_system_action[\"action\"] and self.last_user_action[\"action\"]!='change-page')):\n reward -= .3\n self.sugg_penalty-=.3\n\n if \"info-all\" in self.last_system_action[\"action\"] and \"info-all\" not in self.last_user_action[\"action\"]:\n reward -= .5\n self.info_penalty -=.5\n\n if self.training:\n new_position = self.dataset.getPosition(self.user.constraints['target_function'])\n if new_position < self.previous_position:\n reward += 5*((self.previous_position-new_position)/self.nb_items)\n self.previous_position = new_position\n\n elif self.wasCommandIgnored(self.last_user_action['action'],self.last_system_action['action']):\n reward -= 10\n\n if self.last_user_action[\"action\"]==\"dont-know\":\n reward -= 2\n\n if \"system_answered\" in self.last_user_action:\n reward += .7\n\n if self.last_system_action[\"action\"] == \"START\" :\n reward -= 20\n\n if self.last_system_action[\"action\"] in [\"info\", \"info-all\"] and self.current_function==None:\n reward -= 20\n\n\n return reward","def calculate_reward(self):\n vel = self.agent.get_linear_velocity()[:2]\n pos = self.agent.get_position()[:2]\n dist = np.linalg.norm(pos)\n # position vector and optimal velocity are orthogonal to each other:\n # optimal reward when position vector and orthogonal velocity\n # point into same direction\n vel_orthogonal = np.array([-vel[1], vel[0]])\n r = 0.1*np.dot(pos, vel_orthogonal)/(1+np.abs(dist-self.circle.radius))\n r += 0.01 * self.agent.specific_reward()\n return r","def calculate_reward(self):\n r = 0.\n for o in self.obstacles:\n if not isinstance(o, Apple):\n continue # only consider apples\n xy_diff = o.get_position()[:2] - self.agent.get_position()[:2]\n dist = np.linalg.norm(xy_diff)\n if o.is_visible and dist < self.detection_distance:\n o.update_visuals(make_visible=False)\n r += self.apple_reward\n if not self.agent.alive:\n r = self.dead_agent_reward\n return r","def get_exchange_reward_per_euro(model):\n exchanged_euros = get_exchanged_euros(model)\n total_euros = get_total_euros(model) \n total_teos = get_total_teos(model)\n exchange_pool = (total_euros - total_teos)*model.buffer_share*model.exchange_reward_share\n if exchanged_euros == 0 or exchange_pool <= 0:\n return 0\n exchange_reward_per_euro = exchange_pool / exchanged_euros \n return round(float(exchange_reward_per_euro),4)","def balance(self):\n return self._rbal - self._lbal","def reward(self, player, winning_state):\n if winning_state == \"Tie\":\n return 1\n elif winning_state == \"Resume\":\n return -1\n else:\n if player == \"agent\":\n return 10\n else:\n return -10","def get_total_supply() -> int:\n return total_supply","def reward_exchanges(self):\n exchange_reward_per_euro = get_exchange_reward_per_euro(self.model)\n #payout to agents according to the number of hours they contributed\n for agent_id, agent in self.model.schedule.agents_by_type['Customer'].items():\n agent.teo_wallet += agent.exchanged_euros * exchange_reward_per_euro\n agent.exchange_surplus += agent.exchanged_euros * exchange_reward_per_euro","def total_spent(self):\n\n approved_jobs = self.approved_jobs()\n expenses = self.expenses()\n\n total = 0\n for job in approved_jobs:\n total += job.total_paid\n\n for expense in expenses:\n total += expense.amount\n\n return float(round(total, 2))","def reward(self):\n current_base_position = self.minitaur.GetBasePosition()\n dt = self.control_time_step\n self._current_vel = velocity = (current_base_position[0] - self._last_base_position[0]) / dt\n vel_clip = np.clip(velocity, -self._goal_limit, self._goal_limit)\n velocity_reward = self._goal_vel - np.abs(self._goal_vel - vel_clip)\n\n action = self._past_actions[self._counter - 1]\n prev_action = self._past_actions[max(self._counter - 2, 0)]\n prev_prev_action = self._past_actions[max(self._counter - 3, 0)]\n acc = action - 2 * prev_action + prev_prev_action\n action_acceleration_penalty = np.mean(np.abs(acc))\n\n reward = 0.0\n reward += 1.0 * velocity_reward\n reward -= 0.01 * action_acceleration_penalty # TODO(krshna): lowering acceleration penalty, try 0.01, 0.002\n\n if self._debug:\n self.pybullet_client.addUserDebugText('Current velocity: {:3.2f}'.format(\n self._current_vel), [0, 0, 1], [1, 0, 0])\n return reward","def _get_reward(self, player_score, opponent_score):\n return player_score - opponent_score","def CalcEffectiveInventory(self):\r\n return (self.currentStock - self.currentOrders)","def total(self):\n for card in self.cards:\n if not card.value:\n return 0\n t = 0\n for card in self.cards:\n t += card.value\n contains_ace = False\n for card in self.cards:\n if card.value == BJ_Card.ACE_VALUE:\n contains_ace = True\n if contains_ace and t <= 11:\n t += 10\n return t","def remaining_space_in_hold(self):\n balls = self.config['balls_to_hold'] - self.balls_held\n if balls < 0:\n balls = 0\n return balls","def find_reward(\r\n self, opponent: Player\r\n ) -> Dict[Action, Dict[Action, Score]]:\r\n return self.payoff_matrix[self.decision][opponent.history[-1]]","def get_todays_bet_total(self) -> int:\n return self._daily_bet_count.get()","def rewards(self, s_p, action):\n r0 = GenerateSuccessor13(s_p, action, self.id).agents[self.id].completed_seqs\n r1 = GetReward(s_p)\n if self.r0 < r0:\n self.r0 = r0\n # print(\"0\",self.r0)\n return self.r0\n elif self.r1 > (r1*(-1)):\n self.r1 = r1*(-1)\n # print(\"1\",self.r1)\n return self.r1\n else:\n return 0","def get_reward(self):\n accuracy = self.state\n # Use accuracy as reward for now.\n reward = accuracy\n return reward","def payout(self):\n user = self.completed_by\n user_node = user.get()\n for key, value in self.v_reward:\n user_node[key] += value\n graph.push(user_node)","def get_total_bets(self) -> int:\n return self._total_bet_count.get() + self._daily_bet_count.get()","def get_remaining_count(self):\n return self.total_count - self.count","def get_score(self):\n rewards, resets = self.runner.get_rewards_resets()\n self.runner.clear_rewards_resets()\n assert rewards.ndim == 1 and resets.ndim == 1, (rewards.ndim, resets.ndim)\n assert rewards.shape[0] == resets.shape[0], (rewards.shape, resets.shape)\n scores = [0]\n for t in reversed(range(rewards.shape[0])):\n if resets[t]:\n scores.append(0)\n scores[-1] += rewards[t]\n return np.mean(scores)","def _rewards(self, action: Action) -> Dict[Text, float]:\n raise NotImplementedError","def reward_from_events(self, events: List[str]) -> int:\n game_rewards = {\n e.COIN_COLLECTED: 20,\n e.KILLED_OPPONENT: 25,\n PLACEHOLDER_EVENT: -.1, # idea: the custom event is bad\n e.MOVED_LEFT: -.1,\n e.MOVED_RIGHT: -.1,\n e.MOVED_UP: -.1,\n e.MOVED_DOWN: -.1,\n e.WAITED: -.1,\n e.KILLED_SELF: -100,\n e.INVALID_ACTION:-5\n }\n reward_sum = 0\n for event in events:\n if event in game_rewards:\n reward_sum += game_rewards[event]\n self.logger.info(f\"Awarded {reward_sum} for events {', '.join(events)}\")\n return reward_sum","def balance(self):\n balance = self.opening_balance\n for trx in Transaction.query.filter_by(kid_id=self.id):\n balance += trx.amount\n return balance","def get_reward(self, done):\n return self.reward_function(done)","def discounted_reward(self, discount):\n\n tl = len(self)\n return (1 - discount) * np.sum(discount ** np.arange(tl) * self.rewards)","def get_rewards(self):\n return np.array(self.rewards)","def calculate_down_payment_invested(self, investment_return_rate):\n money_in_account = self.down_payment_amount\n for _ in range(0, self.length_stay):\n money_in_account += (money_in_account * investment_return_rate) / 100\n\n return money_in_account","def reward(self) -> Reward:\n return self.__reward"],"string":"[\n \"def total_rewards(self) -> float:\\n return self.__total_rewards\",\n \"def getTotalReward(self):\\n return self.cumreward\",\n \"def getTotalReward(self):\\n return self.cumreward\",\n \"def getTotalReward(self):\\n return self.lastFitness\",\n \"def total_reward(self):\\n return np.sum(self.rewards)\",\n \"def total_earnings(self):\\n return self.total_balance - self.net_invested\",\n \"def get_ave_reward(self):\\n return sum(self._gameRewards) / len(self._gameRewards)\",\n \"def get_ave_reward(self):\\n return sum(self._gameRewards) / len(self._gameRewards)\",\n \"def get_ave_reward(self):\\n return sum(self._gameRewards) / len(self._gameRewards)\",\n \"def _get_reward(self):\\n if self.is_game_done:\\n return self.price - 1\\n else:\\n return 0.0\",\n \"def get_total_redeem(self):\\n total = 0\\n for redeem in self.get_redeems():\\n total += redeem.get_total()\\n return total\",\n \"def average_reward(self):\\n T = len(self)\\n return np.sum(self.rewards / T)\",\n \"def remaining(self):\\n if self.goal:\\n return self.goal - self.total_donated()\\n else:\\n return 0\",\n \"def amount_raised(self):\\r\\n return self.stats.amount_raised\",\n \"def get_reward(self):\\n \\n ##get total reward value from Q\\n total_reward = 0.0\\n for value in self.Q.itervalues():\\n total_reward = total_reward + value\\n \\n ##return the average reward\\n return total_reward\",\n \"def get_reward(self):\\n \\n ##get total reward value from Q\\n total_reward = 0.0\\n for value in self.Q.itervalues():\\n total_reward = total_reward + value\\n \\n ##return the average reward\\n return total_reward\",\n \"def _get_reward(self):\\n if self.status():\\n return self.current_step/self.ep_length # the reward is proportional to the duration \\n else:\\n return 0\",\n \"def get_actions_remaining(self):\\n return self.get_max_praises() - self.current_used\",\n \"def _compute_reward(self):\\n reward = 0.0\\n return reward\",\n \"def rewards(self):\\n return self._rewards.getSlice(0)\",\n \"def _reward(self):\\n\\n return 1-self.step_count/ self.max_steps\",\n \"def rewards(self):\\n\\n return self._rewards.getSlice(0)\",\n \"def total_clearance(self):\\n total_clearances = 0\\n debit = 0 #variable to track the remaining debit\\n clearances = self.clearance_set.all() #grab all the previous clerances\\n for clearance in clearances:\\n total_clearances += clearance.paid_value\\n return total_clearances\",\n \"def example_reward(self,stock=None, action=None, current_date = None, products=None, orders=None, procurements=None):\\n\\n out = 0\\n for key in stock:\\n out += stock[key]\\n return out * -1\",\n \"def decreases_remaining(self):\\n return 2 - self.decreases_today\",\n \"def calculate_reward(self):\\n if AT.REWARD not in self.attributes:\\n return (0, 1)\\n return self.attributes[AT.REWARD].calculate(self)\",\n \"def get_reward(self):\\n return self.calc_reward(self.sim.pose[:3], self.sim.v)\",\n \"def reward(self):\\n return self._reward\",\n \"def total_raised(self):\\n return self.total_donated() + (self.community_contribution or 0)\",\n \"def reward(self):\\n if self._state is None:\\n return 0\\n return self.reward_fn(self._state)\",\n \"def balance(self):\\n total_money = 0\\n for item in self.ledger:\\n total_money += item['amount']\\n return total_money\",\n \"def get_reward(self):\\n\\t\\tdist = np.sqrt(np.sum(np.square(np.asarray(self.state) - np.asarray(self.goal))))\\n\\n\\t\\tdist_diff = self.prev_dist - dist\\n\\t\\tself.reward = dist_diff * 10\\n\\n\\t\\tself.prev_dist = dist\",\n \"def _compute_reward(self):\\n last_score = self.episode_qualities[-2]\\n new_score = self.episode_qualities[-1]\\n reward = new_score - last_score\\n return reward\",\n \"def _compute_reward(self): \\n reward = -1\\n return reward\",\n \"def get_balance(self):\\n final_amount = 0\\n for i in range(len(self.ledger)):\\n final_amount += self.ledger[i]['amount']\\n return final_amount\",\n \"def block_reward_calc(block_number):\\n\\n # FIXME: Magic number? Unify\\n return int((remaining_emission(config.dev.max_coin_supply, block_number - 1)\\n - remaining_emission(config.dev.max_coin_supply, block_number)) * 100000000)\",\n \"def outstanding(self):\\n return sum(\\n transfer.lock.amount\\n for transfer in self.locked.values()\\n )\",\n \"def net_gains(self):\\n if self.shares == 0:\\n self.debug += '\\\\nNo shares owned.'\\n else:\\n price = self.daily['Adj Close'][-1]\\n gains = self.shares * (price - self.avg_paid)\\n percent = (price / self.avg_paid - 1) * 100\\n gains = round(gains, 2)\\n percent = round(percent, 2)\\n if gains < 0:\\n penalty = self.sells - int(round(self.sells / 3.0, 0))\\n self.debug += '\\\\nNET LOSS: {}, {}%, AVOID SELLING! sells - {}'.format(gains, percent, penalty)\\n self.sells -= penalty\\n else:\\n self.debug += '\\\\nNet gains: ${}, {}%'.format(gains, percent)\",\n \"def reward(self) -> float:\\n\\n if not self._reward_provided:\\n self._reward_provided = True\\n return self._reward\\n\\n return 0\",\n \"def get_reward(self, done):\\n reward = 0\\n self.calc_pos_diff_ratio()\\n reward = self.calc_base_reward_2(reward)\\n\\n return reward\",\n \"def amount_raised_online(self):\\r\\n return self.stats.amount_raised_online\",\n \"def get_reward(self):\\n\\t\\t# returns the reward for current state\\n\\n\\t\\t#temporary line for testing:\\n\\t\\t#return self.reward_idea() # also not working yet\\n\\n\\t\\tcost = self.cost_function()\\n\\t\\tconstraints_violation = self.get_constraints_violation()\\n\\t\\t#old_aug_cost = self.augmented_cost\\n\\t\\t#new_aug_cost = self.get_augmented_cost(cost,constraints_violation)\\n\\t\\t#reward = old_aug_cost - new_aug_cost # reward formula\\n\\t\\t#self.augmented_cost = new_aug_cost # update augmented_cost\\n\\t\\treward = -self.get_augmented_cost(cost,constraints_violation)\\n\\t\\t#print(\\\"***\\\\nDEBUG cost: \\\" +str(cost)+\\\" constraints_violation: \\\"+str(constraints_violation))\\n\\t\\t#print(\\\"DEBUG reward: \\\"+str(reward))\\n\\t\\t'''\\n\\t\\t#old idea that is probably bad and not necessary:\\n\\t\\tif(self.step_count == 0):\\n\\t\\t\\t# old_aug_cost doesn't exist in first step... ACTUALLY IT DOES!\\n\\t\\t\\tprint(\\\"DEBUG step_count == 0, reward would be \\\"+str(reward))\\n\\t\\t\\tprint(\\\"DEBUG old_aug_cost: \\\"+str(old_aug_cost) + \\\" new_aug_cost: \\\"+str(new_aug_cost) )\\n\\t\\t\\treturn 0\\n\\t\\t'''\\n\\n\\t\\treturn reward\",\n \"def calculate_reward(self):\\n cur_dist = self.get_xy_distance()\\n # reduce agent specific reward such that electricity costs are not\\n # higher than moving towards the goal\\n reward = self.old_dist - cur_dist + 0.01 * self.agent.specific_reward()\\n self.old_dist = cur_dist\\n\\n return reward\",\n \"def getReward(game):\\n reward = 0\\n\\n # Reward +10 if destroys asteroid\\n if game.gameLevel.asteroidDestroyed():\\n reward += 10\\n\\n # Reward +20 if level cleared\\n if game.gameLevel.levelCleared:\\n reward += 20\\n\\n # Reward -10 if hits asteroid\\n if game.gameLevel.gameOver:\\n reward -= 10\\n \\n # Reward -1 if a second passes\\n # ToDo: implement timeout in gameLevel\\n\\n return reward\",\n \"def episode_total_score(self):\\n return self.game.get_total_reward()\",\n \"def wages(self):\\n amount = (\\n self.farmer.labor_cost()\\n + self.reseller.labor_cost()\\n + self.cofiring_plant.cofuel_om_wages()\\n - self.coal_wages_lost\\n )\\n return display_as(amount, \\\"kUSD\\\")\",\n \"def get_ave_reward(self):\\n return self._sumStat_Reward.get_mean()\",\n \"def amount_raised_by_tickets(self):\\r\\n return self.stats.amount_raised_by_tickets\",\n \"def _accumulate_rewards(self) -> None:\\n for agent, reward in self.rewards.items():\\n self._cumulative_rewards[agent] += reward\",\n \"def backCoins(self):\\n return self.current.backCoins()\",\n \"def calculate_reward(self):\\n cur_dist = self.get_xy_distance()\\n reward = self.old_dist - cur_dist + 0.01 * self.agent.specific_reward()\\n self.old_dist = cur_dist\\n return reward\",\n \"def getTotalStake(self) -> int:\\n return self._total_stake.get()\",\n \"def get_reward(self) -> float:\\r\\n field = self.fields[self.agent_x][self.agent_y]\\r\\n if field == Field.EMPTY:\\r\\n return self.rew_empty\\r\\n elif field == Field.POS_TERMINAL:\\r\\n return self.rew_pos\\r\\n elif field == Field.NEG_TERMINAL:\\r\\n return self.rew_neg\\r\\n\\r\\n raise ValueError # Agent is standing on an illegal tile!\\r\",\n \"def get_withdrawals(self):\\n withdrawals = 0\\n for transaction in self.ledger:\\n amount = transaction[\\\"amount\\\"]\\n if amount < 0:\\n withdrawals += abs(amount)\\n return withdrawals\",\n \"def get_reward(self):\\n reward, self.reward = self.reward, 0\\n return reward\",\n \"def get_balance(self):\\n balance = 0\\n for transaction in self.ledger:\\n balance += transaction[\\\"amount\\\"]\\n return balance\",\n \"def get_rewards(self):\\n for i in self.REWARDS:\\n self.get_reward(i)\",\n \"def balance(self) -> int:\\r\\n if self._top == None:\\r\\n return 0\\r\\n return self._top.balance()\",\n \"def CalcCostForTurn(self):\\r\\n costsThisTurn = 0\\r\\n \\r\\n inventoryStorageCost = self.currentStock * STORAGE_COST_PER_UNIT\\r\\n backorderPenaltyCost = self.currentOrders * BACKORDER_PENALTY_COST_PER_UNIT\\r\\n \\r\\n costsThisTurn = inventoryStorageCost + backorderPenaltyCost\\r\\n \\r\\n return costsThisTurn\",\n \"def get_cumulative_rewards(rewards, # rewards at each step\\r\\n gamma=0.99 # discount for reward\\r\\n ):\\r\\n cumulative_rewards = []\\r\\n prev = 0\\r\\n\\r\\n for r in reversed(rewards):\\r\\n prev = r + gamma * prev\\r\\n cumulative_rewards.append(prev)\\r\\n cumulative_rewards.reverse()\\r\\n return cumulative_rewards\",\n \"def _get_reward(self, five_cards):\\n \\n return 1-self.evaluator.get_five_card_rank_percentage(self.evaluator._five(five_cards))\",\n \"def get_rewards_score(self) -> Address:\\n return self._rewards_score.get()\",\n \"def reward_from_events(self, events: List[str]) -> int:\\n game_rewards = {\\n e.COIN_COLLECTED: 10,\\n # e.KILLED_OPPONENT: 5,\\n e.KILLED_SELF: -100,\\n # e.GOT_KILLED: -10,\\n # e.OPPONENT_ELIMINATED: 1,\\n e.WAITED: -0.1,\\n e.BOMB_DROPPED: 0,\\n # e.BOMB_EXPLODED: 0,\\n e.CRATE_DESTROYED: 4,\\n e.COIN_FOUND: 0.5,\\n e.INVALID_ACTION: -5,\\n e.MOVED_UP: -0.1,\\n e.MOVED_DOWN: -0.1,\\n e.MOVED_LEFT: -0.1,\\n e.MOVED_RIGHT: -0.1,\\n e.SURVIVED_ROUND: 0,\\n MOVED_AWAY_FROM_BOMB: 3.5,\\n MOVED_TOWARDS_BOMB: -3.5,\\n USELESS_BOMB: -4,\\n USEFUL_BOMB: 2,\\n WAITED_IN_DANGER: -2,\\n DEAD_END: -25\\n }\\n\\n reward_sum = 0\\n\\n for event in events:\\n if event in game_rewards:\\n reward_sum += game_rewards[event]\\n\\n # print(reward_sum, events)\\n\\n self.logger.info(f\\\"Awarded {reward_sum} for events {', '.join(events)}\\\")\\n return reward_sum\",\n \"def credits_earned(self):\\n\\n if self.grade() >= 69.5:\\n return self.nCredits\\n else:\\n return 0.0\",\n \"def get_reward(self, state, reward, done):\\n\\n # simple reward = position. Don't explicitly incentivise agent to take left hill as well as right hill\\n # let it figure it out by itself\\n if done and self.success:\\n return 100\\n else:\\n return (state[0]-0.5)/3\",\n \"def determineAmountToCall(self, player):\\n\\t\\treturn sum(self.currentBet) - sum(player.betAmount)\",\n \"def discount_rewards(rewards):\\r\\n discounted_r = np.zeros_like(rewards)\\r\\n running_add = 0\\r\\n for t in reversed(range(0, len(rewards))): \\r\\n running_add = running_add * reward_discount + rewards[t]\\r\\n discounted_r[t] = running_add\\r\\n return discounted_r\",\n \"def hand_total(self):\\n\\n total = 0\\n for card in self.__hand:\\n total += card.blackjack_value()\\n return total\",\n \"def payout(self, amt: float):\\n total_screen_time = 0\\n for character in self.characters:\\n total_screen_time += character._screen_time\\n for character in self.characters:\\n character._money = amt * character._screen_time / total_screen_time\\n return # FIXME\",\n \"def win(self) -> int:\\n earnings: int = self._bet\\n\\n # If it has a blackjack, the earnings increments 1.5 times\\n for hand in self._hands:\\n if hand.has_blackjack():\\n earnings = round(earnings * 1.5)\\n\\n self._actual_money += earnings\\n return earnings\",\n \"def calculateReward(self, bonus=0):\\n reward = -1 + bonus\\n\\n if ((self.last_system_action[\\\"action\\\"]==\\\"sugg-all\\\" and self.last_user_action[\\\"action\\\"]!=\\\"eli-sugg-all\\\") or \\n (\\\"change-page\\\" in self.last_system_action[\\\"action\\\"] and self.last_user_action[\\\"action\\\"]!='change-page')):\\n reward -= .3\\n self.sugg_penalty-=.3\\n\\n if \\\"info-all\\\" in self.last_system_action[\\\"action\\\"] and \\\"info-all\\\" not in self.last_user_action[\\\"action\\\"]:\\n reward -= .5\\n self.info_penalty -=.5\\n\\n if self.training:\\n new_position = self.dataset.getPosition(self.user.constraints['target_function'])\\n if new_position < self.previous_position:\\n reward += 5*((self.previous_position-new_position)/self.nb_items)\\n self.previous_position = new_position\\n\\n elif self.wasCommandIgnored(self.last_user_action['action'],self.last_system_action['action']):\\n reward -= 10\\n\\n if self.last_user_action[\\\"action\\\"]==\\\"dont-know\\\":\\n reward -= 2\\n\\n if \\\"system_answered\\\" in self.last_user_action:\\n reward += .7\\n\\n if self.last_system_action[\\\"action\\\"] == \\\"START\\\" :\\n reward -= 20\\n\\n if self.last_system_action[\\\"action\\\"] in [\\\"info\\\", \\\"info-all\\\"] and self.current_function==None:\\n reward -= 20\\n\\n\\n return reward\",\n \"def calculate_reward(self):\\n vel = self.agent.get_linear_velocity()[:2]\\n pos = self.agent.get_position()[:2]\\n dist = np.linalg.norm(pos)\\n # position vector and optimal velocity are orthogonal to each other:\\n # optimal reward when position vector and orthogonal velocity\\n # point into same direction\\n vel_orthogonal = np.array([-vel[1], vel[0]])\\n r = 0.1*np.dot(pos, vel_orthogonal)/(1+np.abs(dist-self.circle.radius))\\n r += 0.01 * self.agent.specific_reward()\\n return r\",\n \"def calculate_reward(self):\\n r = 0.\\n for o in self.obstacles:\\n if not isinstance(o, Apple):\\n continue # only consider apples\\n xy_diff = o.get_position()[:2] - self.agent.get_position()[:2]\\n dist = np.linalg.norm(xy_diff)\\n if o.is_visible and dist < self.detection_distance:\\n o.update_visuals(make_visible=False)\\n r += self.apple_reward\\n if not self.agent.alive:\\n r = self.dead_agent_reward\\n return r\",\n \"def get_exchange_reward_per_euro(model):\\n exchanged_euros = get_exchanged_euros(model)\\n total_euros = get_total_euros(model) \\n total_teos = get_total_teos(model)\\n exchange_pool = (total_euros - total_teos)*model.buffer_share*model.exchange_reward_share\\n if exchanged_euros == 0 or exchange_pool <= 0:\\n return 0\\n exchange_reward_per_euro = exchange_pool / exchanged_euros \\n return round(float(exchange_reward_per_euro),4)\",\n \"def balance(self):\\n return self._rbal - self._lbal\",\n \"def reward(self, player, winning_state):\\n if winning_state == \\\"Tie\\\":\\n return 1\\n elif winning_state == \\\"Resume\\\":\\n return -1\\n else:\\n if player == \\\"agent\\\":\\n return 10\\n else:\\n return -10\",\n \"def get_total_supply() -> int:\\n return total_supply\",\n \"def reward_exchanges(self):\\n exchange_reward_per_euro = get_exchange_reward_per_euro(self.model)\\n #payout to agents according to the number of hours they contributed\\n for agent_id, agent in self.model.schedule.agents_by_type['Customer'].items():\\n agent.teo_wallet += agent.exchanged_euros * exchange_reward_per_euro\\n agent.exchange_surplus += agent.exchanged_euros * exchange_reward_per_euro\",\n \"def total_spent(self):\\n\\n approved_jobs = self.approved_jobs()\\n expenses = self.expenses()\\n\\n total = 0\\n for job in approved_jobs:\\n total += job.total_paid\\n\\n for expense in expenses:\\n total += expense.amount\\n\\n return float(round(total, 2))\",\n \"def reward(self):\\n current_base_position = self.minitaur.GetBasePosition()\\n dt = self.control_time_step\\n self._current_vel = velocity = (current_base_position[0] - self._last_base_position[0]) / dt\\n vel_clip = np.clip(velocity, -self._goal_limit, self._goal_limit)\\n velocity_reward = self._goal_vel - np.abs(self._goal_vel - vel_clip)\\n\\n action = self._past_actions[self._counter - 1]\\n prev_action = self._past_actions[max(self._counter - 2, 0)]\\n prev_prev_action = self._past_actions[max(self._counter - 3, 0)]\\n acc = action - 2 * prev_action + prev_prev_action\\n action_acceleration_penalty = np.mean(np.abs(acc))\\n\\n reward = 0.0\\n reward += 1.0 * velocity_reward\\n reward -= 0.01 * action_acceleration_penalty # TODO(krshna): lowering acceleration penalty, try 0.01, 0.002\\n\\n if self._debug:\\n self.pybullet_client.addUserDebugText('Current velocity: {:3.2f}'.format(\\n self._current_vel), [0, 0, 1], [1, 0, 0])\\n return reward\",\n \"def _get_reward(self, player_score, opponent_score):\\n return player_score - opponent_score\",\n \"def CalcEffectiveInventory(self):\\r\\n return (self.currentStock - self.currentOrders)\",\n \"def total(self):\\n for card in self.cards:\\n if not card.value:\\n return 0\\n t = 0\\n for card in self.cards:\\n t += card.value\\n contains_ace = False\\n for card in self.cards:\\n if card.value == BJ_Card.ACE_VALUE:\\n contains_ace = True\\n if contains_ace and t <= 11:\\n t += 10\\n return t\",\n \"def remaining_space_in_hold(self):\\n balls = self.config['balls_to_hold'] - self.balls_held\\n if balls < 0:\\n balls = 0\\n return balls\",\n \"def find_reward(\\r\\n self, opponent: Player\\r\\n ) -> Dict[Action, Dict[Action, Score]]:\\r\\n return self.payoff_matrix[self.decision][opponent.history[-1]]\",\n \"def get_todays_bet_total(self) -> int:\\n return self._daily_bet_count.get()\",\n \"def rewards(self, s_p, action):\\n r0 = GenerateSuccessor13(s_p, action, self.id).agents[self.id].completed_seqs\\n r1 = GetReward(s_p)\\n if self.r0 < r0:\\n self.r0 = r0\\n # print(\\\"0\\\",self.r0)\\n return self.r0\\n elif self.r1 > (r1*(-1)):\\n self.r1 = r1*(-1)\\n # print(\\\"1\\\",self.r1)\\n return self.r1\\n else:\\n return 0\",\n \"def get_reward(self):\\n accuracy = self.state\\n # Use accuracy as reward for now.\\n reward = accuracy\\n return reward\",\n \"def payout(self):\\n user = self.completed_by\\n user_node = user.get()\\n for key, value in self.v_reward:\\n user_node[key] += value\\n graph.push(user_node)\",\n \"def get_total_bets(self) -> int:\\n return self._total_bet_count.get() + self._daily_bet_count.get()\",\n \"def get_remaining_count(self):\\n return self.total_count - self.count\",\n \"def get_score(self):\\n rewards, resets = self.runner.get_rewards_resets()\\n self.runner.clear_rewards_resets()\\n assert rewards.ndim == 1 and resets.ndim == 1, (rewards.ndim, resets.ndim)\\n assert rewards.shape[0] == resets.shape[0], (rewards.shape, resets.shape)\\n scores = [0]\\n for t in reversed(range(rewards.shape[0])):\\n if resets[t]:\\n scores.append(0)\\n scores[-1] += rewards[t]\\n return np.mean(scores)\",\n \"def _rewards(self, action: Action) -> Dict[Text, float]:\\n raise NotImplementedError\",\n \"def reward_from_events(self, events: List[str]) -> int:\\n game_rewards = {\\n e.COIN_COLLECTED: 20,\\n e.KILLED_OPPONENT: 25,\\n PLACEHOLDER_EVENT: -.1, # idea: the custom event is bad\\n e.MOVED_LEFT: -.1,\\n e.MOVED_RIGHT: -.1,\\n e.MOVED_UP: -.1,\\n e.MOVED_DOWN: -.1,\\n e.WAITED: -.1,\\n e.KILLED_SELF: -100,\\n e.INVALID_ACTION:-5\\n }\\n reward_sum = 0\\n for event in events:\\n if event in game_rewards:\\n reward_sum += game_rewards[event]\\n self.logger.info(f\\\"Awarded {reward_sum} for events {', '.join(events)}\\\")\\n return reward_sum\",\n \"def balance(self):\\n balance = self.opening_balance\\n for trx in Transaction.query.filter_by(kid_id=self.id):\\n balance += trx.amount\\n return balance\",\n \"def get_reward(self, done):\\n return self.reward_function(done)\",\n \"def discounted_reward(self, discount):\\n\\n tl = len(self)\\n return (1 - discount) * np.sum(discount ** np.arange(tl) * self.rewards)\",\n \"def get_rewards(self):\\n return np.array(self.rewards)\",\n \"def calculate_down_payment_invested(self, investment_return_rate):\\n money_in_account = self.down_payment_amount\\n for _ in range(0, self.length_stay):\\n money_in_account += (money_in_account * investment_return_rate) / 100\\n\\n return money_in_account\",\n \"def reward(self) -> Reward:\\n return self.__reward\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74350184","0.7319174","0.7319174","0.6883852","0.67559856","0.67167974","0.6656435","0.6656435","0.6656435","0.66351753","0.65298206","0.6467578","0.6409539","0.63020545","0.6262705","0.6262705","0.62345237","0.6190423","0.6136656","0.61360705","0.61356074","0.6135079","0.61178094","0.61112374","0.6098936","0.60974425","0.6095461","0.60772955","0.6038016","0.60291266","0.6025699","0.60188603","0.5951603","0.59326565","0.59291494","0.59141815","0.59067214","0.5897012","0.5896051","0.586817","0.5863051","0.5862134","0.5847568","0.5846147","0.58459556","0.5841459","0.5834288","0.58188885","0.5816006","0.5813963","0.5811856","0.5806564","0.58045614","0.5788044","0.5782447","0.57701236","0.576791","0.5766188","0.5741693","0.57336617","0.5729287","0.5710019","0.5699873","0.56872296","0.5686486","0.5681066","0.5679119","0.5664077","0.56565267","0.56473356","0.5639302","0.5629511","0.56289375","0.5628681","0.56267095","0.56215215","0.56140196","0.5613907","0.56131","0.5610793","0.56022453","0.5590491","0.55837965","0.5579734","0.55759525","0.5573086","0.5569102","0.5560749","0.55571055","0.5553935","0.55447865","0.55341184","0.55321306","0.55285585","0.55256826","0.5518122","0.5509814","0.550267","0.5493837","0.54923904"],"string":"[\n \"0.74350184\",\n \"0.7319174\",\n \"0.7319174\",\n \"0.6883852\",\n \"0.67559856\",\n \"0.67167974\",\n \"0.6656435\",\n \"0.6656435\",\n \"0.6656435\",\n \"0.66351753\",\n \"0.65298206\",\n \"0.6467578\",\n \"0.6409539\",\n \"0.63020545\",\n \"0.6262705\",\n \"0.6262705\",\n \"0.62345237\",\n \"0.6190423\",\n \"0.6136656\",\n \"0.61360705\",\n \"0.61356074\",\n \"0.6135079\",\n \"0.61178094\",\n \"0.61112374\",\n \"0.6098936\",\n \"0.60974425\",\n \"0.6095461\",\n \"0.60772955\",\n \"0.6038016\",\n \"0.60291266\",\n \"0.6025699\",\n \"0.60188603\",\n \"0.5951603\",\n \"0.59326565\",\n \"0.59291494\",\n \"0.59141815\",\n \"0.59067214\",\n \"0.5897012\",\n \"0.5896051\",\n \"0.586817\",\n \"0.5863051\",\n \"0.5862134\",\n \"0.5847568\",\n \"0.5846147\",\n \"0.58459556\",\n \"0.5841459\",\n \"0.5834288\",\n \"0.58188885\",\n \"0.5816006\",\n \"0.5813963\",\n \"0.5811856\",\n \"0.5806564\",\n \"0.58045614\",\n \"0.5788044\",\n \"0.5782447\",\n \"0.57701236\",\n \"0.576791\",\n \"0.5766188\",\n \"0.5741693\",\n \"0.57336617\",\n \"0.5729287\",\n \"0.5710019\",\n \"0.5699873\",\n \"0.56872296\",\n \"0.5686486\",\n \"0.5681066\",\n \"0.5679119\",\n \"0.5664077\",\n \"0.56565267\",\n \"0.56473356\",\n \"0.5639302\",\n \"0.5629511\",\n \"0.56289375\",\n \"0.5628681\",\n \"0.56267095\",\n \"0.56215215\",\n \"0.56140196\",\n \"0.5613907\",\n \"0.56131\",\n \"0.5610793\",\n \"0.56022453\",\n \"0.5590491\",\n \"0.55837965\",\n \"0.5579734\",\n \"0.55759525\",\n \"0.5573086\",\n \"0.5569102\",\n \"0.5560749\",\n \"0.55571055\",\n \"0.5553935\",\n \"0.55447865\",\n \"0.55341184\",\n \"0.55321306\",\n \"0.55285585\",\n \"0.55256826\",\n \"0.5518122\",\n \"0.5509814\",\n \"0.550267\",\n \"0.5493837\",\n \"0.54923904\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5873769"},"document_rank":{"kind":"string","value":"39"}}},{"rowIdx":84694,"cells":{"query":{"kind":"string","value":"Returns the top prep addresses that is set every week."},"document":{"kind":"string","value":"def getTopPreps(self) -> list:\n top_prep_list= []\n for x in self._top_preps:\n top_prep_list.append(x)\n return top_prep_list"},"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 find_top_seven_routes(self):\n df = self.filter_according_to_travel_day('Sunday')\n # Group the dataset according to the frequency of the travel route\n df =df.groupby([\"travel_from\", \"travel_to\"]).size().reset_index(name=\"Frequency\")\n #Sort the dataset according to the frequency in descending order\n df =df.sort_values(\"Frequency\", ascending=False)[:7]\n return df","def _set_top_preps(self) -> None :\n prep_dict = self._system.getPReps(1, 20)\n prep_address_list = prep_dict['preps']\n for each_prep in prep_address_list:\n self._top_preps.put(each_prep['address'])","def get_top_five_countries():\n countries=country_populations.split('\\n')\n top_5=[]\n count=0\n for country in countries:\n if count<6:\n data= country.split('\\t')\n top_5.append(data[1])\n count+=1\n top_5.remove('Country')\n return top_5","def topstreet_pub(self):\n out=self.df.withColumn('street', split(col('address'), ',')[0]) \\\n .groupby('street').agg(count('name').alias('st_count')) \\\n .sort(desc(\"st_count\")).select(\"street\").limit(1) \n out.withColumnRenamed('street','street which has highest number of pubs') \\\n .write.mode(\"overwrite\").csv('{}streetname/'.format(self.target))\n\n return out.rdd.map(lambda l:l.street).collect()","def test_get_top_returns_four_apps_by_default(self):\r\n\r\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\r\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\r\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\r\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\r\n ranked_5_app = self.create_app_with_contributors(7, 0, name='five')\r\n\r\n top_apps = cached_apps.get_top()\r\n\r\n assert len(top_apps) is 4, len(top_apps)","def _reset_top_preps(self) -> None:\n if self._system.getIISSInfo()[\"nextPRepTerm\"] > self._block_height_week.get() + (7 * 43200):\n self._block_height_week.set(self._system.getIISSInfo()[\"nextPRepTerm\"])\n for i in range(len(self._top_preps)):\n self._top_preps.pop()\n self._set_top_preps()","def topCountries(top=10):\r\n #top 10 deadly countries\r\n countries = agg('country')[:top].index\r\n #grab aggregated data for these countries\r\n dataOfTop10 = agg(['year','country']).query(\"country in @countries\")### interesting...\r\n #unstack data\r\n dataOfTop10 = dataOfTop10.unstack(1)\r\n #remove multiindexes\r\n dataOfTop10 = dataOfTop10.transpose().reset_index(level=0, drop=True).transpose()\r\n #sort by year\r\n dataOfTop10.sort_index(inplace=True)\r\n return dataOfTop10","def test_get_top_returns_apps_with_most_taskruns(self):\r\n\r\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\r\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\r\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\r\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\r\n\r\n top_apps = cached_apps.get_top()\r\n\r\n assert top_apps[0]['name'] == 'one', top_apps\r\n assert top_apps[1]['name'] == 'two', top_apps\r\n assert top_apps[2]['name'] == 'three', top_apps\r\n assert top_apps[3]['name'] == 'four', top_apps","def topOccupations(years):\n\toccs = []\n\tfor year in years:\n\t\tfilename = \"SmartEnergy\" +str(year) +\".xlsx\"\n\t\tDB = pd.read_excel(filename, sheet_name= \"Report1_Data\", usecols =[\"BGTOCC\",\"Job Postings\"])\n\t\t# occs.append(DB.head(5))\n\t\toccs.append(DB)\n\t\tTopOccs =pd.concat(occs, keys = list(years), names =['year'])\n\t\n\t# Which occupations appear throughout the years, which are new and which no longer appear?\n\t\n\t\n\tv = TopOccs.BGTOCC.value_counts().sort_index()\t\n\t\n\t# create list of occupations that are posted each year\n\trecurringOccs = v[v==8].index.tolist()\n\t\n\treturn TopOccs\n\t# emergingOccs = \n\t# print(TopOccs.loc[2012,:])","def read_weekly_breakdown_statuses(self):\n from itertools import repeat\n\n self.ID7_GNIP_BREAKDOWN = kpi_from_db_config.ID7_GNIP_BREAKDOWN\n self.ID7_STREAM_BREAKDOWN = kpi_from_db_config.ID7_STREAM_BREAKDOWN\n self.ID7_SEED_BREAKDOWN = kpi_from_db_config.ID7_SEED_BREAKDOWN\n self.ID7_MENTION_BREAKDOWN = kpi_from_db_config.ID7_MENTION_BREAKDOWN\n \n list_id = [self.ID7_GNIP_BREAKDOWN, \n self.ID7_STREAM_BREAKDOWN, \n self.ID7_SEED_BREAKDOWN, \n self.ID7_MENTION_BREAKDOWN]\n\n list_result = [[] for i in repeat(None,len(list_id))]\n for i in range(len(list_id)):\n self.cursor.execute('''\n SELECT value\n FROM public.kpi_report\n WHERE id = %s\n ORDER BY created_at DESC\n LIMIT 6\n ''', [list_id[i]])\n rows_count = self.cursor.rowcount\n \n if (rows_count == 6): # 6 is LIMIT from the query\n for doc in self.cursor:\n list_result[i].append(int(doc[0]))\n elif (rows_count >= 1 and rows_count < 6): # Change rows_count > 0 and rows_count < Number of limit\n for doc in self.cursor:\n list_result[i].append(int(doc[0]))\n list_result[i] = list_result[i] + [0] * (6 - rows_count) \n else:\n list_result[i] = [0] * 6\n\n return list_result","def rideshare_pickups(self, since):\n query = \"\"\"\n SELECT\n week as date,\n SUM(n_trips) as value\n FROM rideshare\n WHERE week >= ?\n GROUP BY date\n \"\"\"\n cur = self.con.cursor()\n cur.execute(query, (since,))\n rows = rows_to_dicts(cur, cur.fetchall())\n return rows","def get_ups(self):\n return self.ups","def test_get_top_respects_limit(self):\r\n\r\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\r\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\r\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\r\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\r\n\r\n top_apps = cached_apps.get_top(n=2)\r\n\r\n assert len(top_apps) is 2, len(top_apps)","def __r7(soup):\n news = []\n ps = soup.find_all('p', class_='trends-thermometer-description')\n i = 0\n\n for p in ps:\n if i == 6: # Six trending topics\n break\n i += 1\n a = p.parent.parent.parent.a\n news.append(dict(title=a['title'], link=a['href']))\n return news","def top3_records(self):\n return sorted(set([sanitize(t) for t in self]))[0:3]","def get_top_10(df):\n\n grouped_df = df.groupby(\"country\").max()\n\n # Confirmed cases\n print(grouped_df.sort_values(\"confirmed\",\n ascending=False)[\"confirmed\"][:10])\n\n # Deaths\n print(grouped_df.sort_values(\"deaths\", ascending=False)[\"deaths\"][:10])\n\n # Recoveries\n print(grouped_df.sort_values(\"recovered\",\n ascending=False)[\"recovered\"][:10])\n\n a = grouped_df.sort_values(\"recovered\", ascending=False)[\"recovered\"][:10]\n print(a.to_markdown())","def get_top(n=4):\r\n sql = text('''SELECT app.id, app.name, app.short_name, app.description, app.info,\r\n COUNT(app_id) AS total FROM task_run, app\r\n WHERE app_id IS NOT NULL AND app.id=app_id AND app.hidden=0\r\n GROUP BY app.id ORDER BY total DESC LIMIT :limit;''')\r\n results = db.engine.execute(sql, limit=n)\r\n top_apps = []\r\n for row in results:\r\n app = dict(id=row.id, name=row.name, short_name=row.short_name,\r\n description=row.description,\r\n info=json.loads(row.info),\r\n n_volunteers=n_volunteers(row.id),\r\n n_completed_tasks=n_completed_tasks(row.id))\r\n top_apps.append(app)\r\n return top_apps","def get_commercial_next_week_trips(self):\n\n trips = self.env['sales_trip.trip']\n domain = ['&',\n ('trip_day_week_number','>=',self.get_today_week_number()),\n ('commercial_id', '=', self.commercial_id.id)]\n\n return trips.search(domain)","def get_top_featured_entries(number=5):\n return list(Entry.published.filter(featured=True)[:number])","def get_best_five(self):\n return sorted(self.speakers.iteritems(),\n key=lambda (key, val): (val, key),\n reverse=True)[:5]","def getTopUsers(self):\n\n\t\tquery = \"\"\"select M.user_id, count( distinct M.venue_id) as cnt\n\t\t\t\t\tfrom\n\t\t\t\t\t(\n\t\t\t\t\tselect J.user_id, J.venue_id, J.latitude, J.longitude, J.Homelat, J.Homelong,\n\t\t\t\t\tCASE\n\t\t\t\t\t\tWHEN J.latitude = J.Homelat and J.longitude = J.Homelong THEN 1\n\t\t\t\t\t\tELSE 0\n\t\t\t\t\t\tEND bool\n\t\t\t\t\tfrom \n\t\t\t\t\t(\n\t\t\t\t\tselect C.*, U.latitude as Homelat, U.longitude as Homelong \n\t\t\t\t\tfrom checkins C\n\t\t\t\t\tleft join users U\n\t\t\t\t\ton U.id = C.user_id\n\t\t\t\t\t) J\n\t\t\t\t\twhere bool=0\n\t\t\t\t\t) M\n\t\t\t\t\tgroup by user_id\n\t\t\t\t\torder by cnt desc, user_id\n\t\t\t\t\tlimit {}\"\"\".format(self.top)\n\n\t\tdf = pd.read_sql_query(query, self.conn)\n\n\t\tself.topusers = df[\"user_id\"].tolist()","def weekly():","def getWeeks(year):\n url = \"http://www.boxofficemojo.com/weekend/?yr=%d\" % year\n src = urllib.request.urlopen(url).read()\n soup = BeautifulSoup(src, 'html.parser')\n chart = soup.find(border=\"0\", cellspacing=\"1\", cellpadding=\"5\")\n data = parseTable(chart)\n weeks = [int(row[-1]) for row in data[1:]]\n return weeks","def get_todays_posts():\n \n return sorted(requests.get(TODAY_URL).json()['hunts'], \n key=lambda post: post['rank'])","def top_n(self, n: int = 10) -> dict:\n return self.members[:n]","def top_n(self, n: int = 10) -> dict:\n return self.members[:n]","def FindTournamentEntrants(Placement: 'df', week: int) -> None:\r\n Placement['NumTMTEntered'] = 0\r\n Placement['NumInBracket'] = 0\r\n for index, row in Placement.iterrows():\r\n nTMTEntered = 0\r\n nInBracket = 0\r\n for i in range(1, week + 1):\r\n weeklyPlacement = row[f'PWeek{i}']\r\n if weeklyPlacement > -2:\r\n nTMTEntered += 1\r\n if weeklyPlacement > -1:\r\n nInBracket += 1\r\n Placement.at[index, 'NumTMTEntered'] = nTMTEntered\r\n Placement.at[index, 'NumInBracket'] = nInBracket","def query_weekly_hits(cls,N=10):\n bwkey = 'BookWeeklyHits'\n bks = from_cache(bwkey)\n if not bks:\n dt = datetime.utcnow() - timedelta(days=7)\n daus = SuiDau.all().filter('date >=',dt).order('-visits').fetch(N)\n bids = [d.book for d in daus]\n bks = map(lambda e:str(e.key().id()),SuiBook.get_by_id(bids))\n to_cache(bwkey,bks)\n return bks","def most_infected(n: int, day: datetime.date, return_zip: bool) -> list:\n \n day = day.strftime('%m-%d-%Y')\n url = f'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_daily_reports/{day}.csv'\n\n df = pd.read_csv(StringIO(requests.get(url).text))\n df = df.loc[df['Country_Region'] == 'US'].sort_values(by='Confirmed', ascending=False) # only US and sort by Confirmed\n df = df.loc[(df['Admin2'] != 'Unassigned') & (df['Province_State'] != 'Puerto Rico')] # remove Unassigned\n\n locations = list(df.head(n)[['Admin2', 'Province_State']].values)\n\n df = pd.read_csv(r'Data Collection\\Apparatus\\Docs\\zip_code_database.csv')[['county', 'state', 'zip']]\n df['county'] = df['county'].str.replace(' County','').str.replace(' City','')\n \n\n if (return_zip):\n state_abbreviation = pd.read_csv(r'Data Collection\\Apparatus\\Docs\\states_and_counties.csv')\n state_abbreviation['State Name'].str.title()\n\n result = []\n for county, state in locations:\n if (type(county) == str):\n county = county.replace(' County', '').replace(' City', '')\n state = zip_conversion.state_to_abbreviation(state, state_abbreviation)\n result.append([str(code).zfill(5) for code in zip_conversion.county_to_zip(county, state, df)])\n\n result = [codes for codes in result if codes != []]\n return [y for x in result for y in x]\n\n else:\n result = []\n for county, state in locations:\n if (type(county) == str):\n county = county.replace(' County', '').replace(' City', '')\n result.append((county, state))\n\n return result","def generate_dict_top_five(self):\n all_months = {}\n # Loops over each avilable non-duplicate date\n available_dates = self.contacts.quer_distinct_components(\"contact_date\", \"Contacts\")\n for date in available_dates:\n top_five = self.ordered[date]\n all_months[date] = {}\n\n # Loops over top five to append their components to the final dict\n for index in range(len(top_five)):\n listing_id = top_five[index][1]\n total_contacts = top_five[index][0]\n\n all_months[date].update(\n {\n index+1: {\n 'Ranking': index+1,\n 'Listing Id': listing_id,\n 'Make': self.listing.quer_component_using_column(\"make\", \"id\", \"Listings\", listing_id)[0][0],\n 'Selling Price': self.listing.quer_component_using_column(\"price\", \"id\", \"Listings\", listing_id)[0][0],\n 'Mileage': self.listing.quer_component_using_column(\"mileage\", \"id\", \"Listings\", listing_id)[0][0],\n 'Total Amount of Contacts': total_contacts\n }\n }\n )\n\n return all_months","def get_all_from_top_ten(title,users,max = 3):\n \"\"\" ten prolific users \"\"\"\n \"\"\" max : number of user with related followers \"\"\"\n getAllUsers(users,all_users,users_set,proceeded_users,max,user_cpt,title)\n for data in users_set:\n print(data.id)","def GetListOfWeeks(self):\n delta_days = (self.GetFridayOfLastFullWeek() - self.START_DATE).days\n delta_weeks = int(math.floor(delta_days / 7))\n weeks = [self.START_DATE + dt.timedelta(days=7 * x) \n for x in range(0, delta_weeks + 1)]\n weeks = [week.strftime('%Y-%m-%d') for week in weeks]\n self.cursor.execute(\n 'SELECT DISTINCT week FROM %s' % self.BOX_OFFICE_TABLE)\n weeks_in_table = [x[0] for x in self.cursor.fetchall()]\n weeks = list(set(weeks) - set(weeks_in_table))\n weeks.sort() \n return weeks","def weekly(evictiondata):\r\n evictions_per_week = {}\r\n for index, row in evictiondata.iterrows():\r\n if row['week_date'] not in evictions_per_week.keys():\r\n evictions_per_week[row['week_date']] = row['filings_2020']\r\n else:\r\n evictions_per_week[row['week_date']] += row['filings_2020']\r\n return evictions_per_week","def getHighestAlertCountSumCPs(self):\n self.communicationPairs.sort(\n key=lambda x: x.getAlertCountSum(), reverse=True)\n returnList = []\n for i in range(len(self.communicationPairs)):\n if i == 10:\n break\n returnList.append(\n {'source_ip': self.communicationPairs[i].getSourceIp(),\n 'dest_ip': self.communicationPairs[i].getDestIp(),\n 'alert_count_sum': self.communicationPairs[i].getAlertCountSum()})\n return returnList","def sample_top_neighbors( self, max_count=200 ):\n df = self.copy()\n return df[df['neighbor'] <= max_count].coerce()","def top30_clients(self):\n clients = self.clients_sorted_by_rentals()\n return clients[:int(0.3 * len(clients))]","def load_presn_runs(offset, limit):\n now_local = datetime.now()\n timelimit = timedelta(hours=100)\n server = couchdb.Server(\"http://snoplus:\"+app.config[\"COUCHDB_PASSWORD\"]+\"@\"+app.config[\"COUCHDB_HOSTNAME\"])\n db = server[\"pre-supernova\"]\n results = []\n skip = offset\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\n total = all.total_rows\n offset = all.offset\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\n year = row.key[0]\n mon = row.key[1]\n day = row.key[2]\n hour = row.key[3]\n minute = row.key[4]\n sec = row.key[5]\n run = row.value\n run_id = row.id\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n if timediff<timelimit:\n try:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n results.sort(reverse=True)\n return results, total, offset, limit","def get_sorted():\n return sorted(country_list, key=get_pop_and_name)","def forecast_weekly():\n forecast = get_forecast()\n daily = forecast.daily()\n return daily.summary","def __top_prod_countries(df, number_of_countries):\n\t\tmlb = MultiLabelBinarizer()\n\t\ttemp = pd.DataFrame(mlb.fit_transform(df['production_countries']), columns=mlb.classes_, index=df.index)\n\t\treturn temp.sum().sort_values(ascending=False)[:number_of_countries].index.values","def build_top_browsers(self):\n browsers = heapq.nlargest(10, self.browser_dict, key=self.browser_dict.get)\n \n top_browsers = {}\n for x in range(len(browsers)):\n top_browsers[str(browsers[x])]= self.browser_dict[browsers[x]]\n \n return top_browsers","def get_apt_num(self):\n html = self.driver.page_source\n soup = BeautifulSoup(html, \"html.parser\")\n # apt_days = soup.findAll(\"div\", attrs={\"class\": \"field-fullwidth\"})\n apt_days = soup.findAll(\"div\", attrs={\"class\": \"md:flex-shrink text-gray-800\"})\n # If the webpage fails to load, relaod and find openings\n while len(apt_days) == 0:\n sleep(2)\n self.driver.get(self.search_website)\n self.driver.refresh()\n html = self.driver.page_source\n soup = BeautifulSoup(html, \"html.parser\")\n apt_days = soup.findAll(\"div\", attrs={\"class\": \"md:flex-shrink text-gray-800\"})\n print(\"Web page fault. May need to restart.\")\n # Start a new list for appointments\n self.openings = []\n for apt in apt_days:\n apt_info = apt.findAll(\"p\")\n for info in apt_info:\n # If the text available appointments is witihin then pull the number\n if \"Available Appointments\" in info.text:\n apt_op_search = re.search(\"\\d+\", info.text)\n apt_openings = int(apt_op_search.group())\n self.openings.append(apt_openings)\n break","def topBrandsandCountries(df, countries_unique):\n top_countries = {}\n for x in countries_unique:\n if df[df.geo_country==x].device_brand_name.count() > 500:\n top_countries[x] = df[df.geo_country==x].device_brand_name.count()\n\n top_3_brands = ['Apple','Samsung','Huawei']\n\n apple = []\n samsung = []\n huawei = []\n for x in top_countries.keys():\n apple.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[0]].device_brand_name.count())\n samsung.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[1]].device_brand_name.count())\n huawei.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[2]].device_brand_name.count()) \n\n return top_countries,apple,samsung,huawei","def get_top_spammers(self, n):\n sql_command = \"SELECT * FROM points ORDER BY amount DESC;\"\n cursor, connection = self.execute_command_get_connection(sql_command, [])\n all = cursor.fetchall()\n\n return all[:n]","def week_top_five(db: str) -> None:\n # Creating x and y variables for each month using the helper function\n # max_delays to get the five stations with the longest overall delays\n month_1 = [max_delays(db, 0)]\n month_2 = [max_delays(db, 1)]\n month_3 = [max_delays(db, 2)]\n month_4 = [max_delays(db, 3)]\n month_5 = [max_delays(db, 4)]\n month_6 = [max_delays(db, 5)]\n \n # using the variables to plot bar graphs of each month.\n plt.figure(figsize=(35, 20)) \n plt.xticks(fontsize=20) \n \n plt.subplot(2, 3, 1)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Sept 2017') \n plt.bar(month_1[0][0], month_1[0][1])\n \n plt.subplot(2, 3, 2)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Oct 2017') \n plt.bar(month_2[0][0], month_2[0][1]) \n \n plt.subplot(2, 3, 3)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Nov 2017') \n plt.bar(month_3[0][0], month_3[0][1]) \n \n plt.subplot(2, 3, 4)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Dec 2017') \n plt.bar(month_4[0][0], month_4[0][1]) \n \n plt.subplot(2, 3, 5)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Jan 2018') \n plt.bar(month_5[0][0], month_5[0][1])\n \n plt.subplot(2, 3, 6)\n plt.xlabel('Station')\n plt.ylabel('Total Time of Delays (minutes)') \n plt.title('Feb 2018') \n plt.bar(month_6[0][0], month_6[0][1]) \n \n plt.tight_layout()\n plt.savefig('week_top_five.png')\n plt.close()","def print_all(self, lim=100):\n for item in islice(weekdays.return_all(), 0, 100):\n print(item)","def get_top_tweets():\n Tweet.top_tweets = [(k, v) for k, v in sorted(Tweet.hashtag_counter.items(), key=lambda item: item[1], reverse=True)]\n top_10_tweets = {}\n top_10_tweets['top_tweets'] = []\n for tweet in Tweet.top_tweets[:10]:\n top_10_tweets['top_tweets'].append({'hashtag': \"#\"+tweet[0], 'count': tweet[1]})\n return top_10_tweets","def weekly_max_paid_violations(self):\n return self._weekly_max_paid_violations","def precipitation():\n year_ago = dt.date(2017,8,23) - dt.timedelta(days=365)\n one_year_ago = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= year_ago).all()\n\n all_precip = []\n for precip in one_year_ago:\n precip_dict = {}\n precip_dict[\"name\"] = precip.date\n precip_dict[\"precip\"] = precip.prcp\n\n all_precip.append(precip_dict)\n\n return jsonify(all_precip)","def get_trends_by_week(self):\n try:\n return self.profile_data[\"trendsByWeek\"]\n except Exception as e:\n error_msg = (\"Failed to retrieve weekly trends: {}\"\n \"\".format(str(e)))\n raise PlayerDataException(error_msg)","def top(self):\r\n return self.topele","def get_average_number_of_officers():\n pd_info = browser.find_element_by_class_name(\"pd_info\")\n town_info = pd_info.find_element_by_class_name(\"town_description\")\n return (\n town_info.find_element_by_class_name(\"right\")\n .find_element_by_class_name(\"town_label\")\n .get_property(\"innerHTML\")\n )","def get_popular_tickets_solution(tickets):\n popular_tickets = []\n for ticket in tickets:\n num_watchers = len(ticket['people']['watchers'])\n if num_watchers >= 8:\n popular_tickets.append(ticket)\n return popular_tickets","def _sub_ranker_top(self,numbers_frequency):\n rank=2\n\n if max(numbers_frequency.loc[numbers_frequency>0].index) == 14:\n rank=1\n\n return rank","def get_top_nationalities(result, n=5):\n nat_freq=pd.DataFrame(result['country'].value_counts())\n ratios=nat_freq[:n]/nat_freq.sum()*100\n res='The most common visitors are from'\n for i in range(0,len(ratios)):\n if i!=len(ratios)-1:\n res=res+f' {ratios.index[i]} ({np.round(ratios.country[i],2)}%),'\n else:\n res=res+f' and {ratios.index[i]} ({np.round(ratios.country[i],2)}%).'\n return res","def get_top_clickers(self, window: str, limit: str = None, page: str = None) -> dict:\n params = remove_empty_elements({\"window\": window,\n \"size\": limit,\n \"page\": page})\n return self.http_request(\"GET\", '/people/top-clickers', params=params)","def _get_current_week_entries(today, user):\n some_day = today + timedelta(days=1)\n monday_of_week = some_day - timedelta(days=(some_day.isocalendar()[2] - 1))\n sunday_of_week = monday_of_week + timedelta(days=6)\n weekevents = TimeEntry.objects.filter(\n booking_date__gte=monday_of_week, booking_date__lt=sunday_of_week, user=user\n )\n return weekevents","def getTopPopulationRegion(self):\n\t\tdata = {}\n\t\tfor iProvince in range(con.iNumRegions):\n\t\t\tdata[iProvince] = 0\n\t\tfor iLoopPlayer in range(con.iBarbarian + 1):\n\t\t\tapCityList = PyPlayer(iLoopPlayer).getCityList()\n\t\t\tfor pCity in apCityList:\n\t\t\t\tdata[pCity.GetCy().plot().getRegionID()] += pCity.getPopulation()\n\t\tkey = -1\n\t\tfor key, value in sorted(data.iteritems(), key=lambda (k,v): (v,k)):\n\t\t\tpass\n\t\treturn key","def getPastProjects(self)->list:\n returnList=[]\n for i in range(0,randint(1, 10)):\n randumProjectId = randint(0, 109)\n if randumProjectId not in returnList:\n returnList.append(randumProjectId)\n\n return returnList","def print_highest_rainfall(properly_organized_date_and_totals):\n\tprint('The highest rain fall value found was: {} on {}.'.format(properly_organized_date_and_totals[1], properly_organized_date_and_totals[0]))","def get_popular_tickets(tickets):\n popular_tickets = []\n #\n # TODO - your code here\n # \n for ticket in tickets:\n str_len=len(ticket['people']['watchers'])\n if str_len>=8:\n popular_tickets.append(ticket)\n \n return popular_tickets","def least_popular_influencers(self, influencerTopSim, count):\n infPopularity = {influencer: 0 for influencer in influencerTopSim}\n for influencer in influencerTopSim:\n infTweetPop = self.userTweetsStat[influencer]\n avgPop = []\n for tweet in influencerTopSim[influencer]:\n infTweet = infTweetPop[len(infTweetPop)-1]\n avgPop.append(self.assign_popularity_to_tweet(infTweet,tweet))\n infPopularity[influencer] = np.mean(avgPop)\n \n tmp = {key: rank for rank, key in enumerate(sorted(set(infPopularity.values()), reverse=True), 1)}\n rankInfluencer = {k: tmp[v] for k,v in infPopularity.items()}\n leastPopInfluencer = [a for a in dict(sorted(rankInfluencer.items(), key=operator.itemgetter(1), reverse=True)[:count]).keys()]\n \n return leastPopInfluencer","def top_n(self, n):\n top = {}\n for code, feat_set in self.iteritems():\n tuples = sorted(feat_set.items(), reverse=True, key=itemgetter(1))\n best = {feat for feat, _ in tuples[:n]}\n top[code] = best\n return top","def find_top_five_most_contacted_listings_per_month(self):\n available_dates = self.contacts.quer_distinct_components(\"contact_date\", \"Contacts\")\n available_listing_ids = self.contacts.quer_distinct_components(\"listing_id\", \"Contacts\")\n \n self.ordered = {}\n for date in available_dates:\n listing = []\n month = self.contacts.quer_component_using_column(\"listing_id\", \"contact_date\", \"Contacts\", date)\n new = [month[0] for month in month]\n for listing_id in available_listing_ids:\n count = new.count(listing_id)\n listing.append([count, listing_id])\n listing = sorted(listing, key=lambda x: x[0], reverse=True)\n\n self.ordered[date] = listing[:5]","def top_ten(subreddit):\n req = get(\n \"https://www.reddit.com/r/{}/hot.json\".format(subreddit),\n headers={\n \"User-Agent\": \"alx_app\"},\n params={\n \"limit\": 10},\n allow_redirects=False)\n if req.status_code != 200:\n print(None)\n else:\n posts = req.json().get(\"data\").get(\"children\")\n for post in posts:\n print(post.get(\"data\").get(\"title\"))","def get_player_stats_from_game(team, year, week):","def temperatures_by_country_till2013():\r\n\r\n # Columns: dt, AverageTemperature, AverageTemperatureUncertainty, Country\r\n temperatures = pd.read_csv(\"GlobalLandTemperatures/GlobalLandTemperaturesByCountry.csv\")\r\n\r\n # 577 462 rows\r\n print(len(temperatures))\r\n\r\n countries = temperatures['Country'].unique()\r\n print(len(countries))\r\n print(sorted(countries))","def get_personnel():\r\n if len(off) == 0:\r\n print(\"There are no office workers\")\r\n else:\r\n for i in off:\r\n print(str(i))","def get_highest_priority(self):\n for i in self.query.index.values.tolist():\n if not int(self.query.loc[i,'in_%s'%self.program]):\n pick = self.query.loc[i]\n break\n return pick","def test_top_country(self):\n tabular_format_countries_list = [['Canada', 66, '20'], ['United States', 33, '10']]\n\n result = InstallationStatistics.get_statistics_top_country(tabular_format_countries_list)\n\n self.assertEqual('Canada', result)","def earliest_available_offsets(self):\n return self.fetch_offset_limits(OffsetType.EARLIEST)","def get_reps_for_address(address):\n if not GOOGLE_API_KEY:\n raise AssertionError('Missing GOOGLE_API_KEY from env')\n\n # https://developers.google.com/civic-information/docs/v2/representatives\n params = {\n 'key': GOOGLE_API_KEY,\n 'includeOffices': True,\n 'address': address\n }\n resp = requests.get(base_url, params=params)\n if not resp.ok:\n # TODO(carolyn): differentiate btwn malformed address, rate limits, etc\n return\n\n data = resp.json()\n if 'offices' not in data or 'officials' not in data:\n logger.error('Missing required key from Google response')\n return\n\n offices = data['offices']\n officials = data['officials']\n\n # TODO(carolyn): format this like the other api endpoint?\n # for now, just add the office name to the officials\n for office in offices:\n office_name = office['name']\n for i in office['officialIndices']:\n officials[i]['office_name'] = office_name\n\n return officials","def get_game_urls(year, week):\n base_url = \"https://www.pro-football-reference.com\"\n\n # URL for the summary of all games for a given week\n # This page has the each match up for the week and\n # a link to the detailed game stats \n url = \"https://www.pro-football-reference.com/years/{}/week_{}.htm\".format(\n year, week)\n\n response = get(url)\n\n week_summary = BeautifulSoup(response.content, 'html.parser')\n\n # Get just the game summary content\n week_summary_games = week_summary.find_all(\n attrs={\"class\": \"game_summary expanded nohover\"})\n\n losing_teams = []\n winning_teams = []\n game_link = []\n\n # For each game played, extract the losing team,\n # the winning team, and the detailed game stats link\n for game in week_summary_games:\n try:\n losing_team_strings = [text for text in game.find(\n attrs={\"class\": \"loser\"}).stripped_strings]\n losing_teams.append(losing_team_strings[0])\n except AttributeError:\n pass\n\n try:\n winning_team_strings = [text for text in game.find(\n attrs={\"class\": \"winner\"}).stripped_strings]\n winning_teams.append(winning_team_strings[0])\n except AttributeError:\n pass\n\n for link in game.find_all(href=re.compile(\"boxscores\")):\n game_link.append(base_url + link.get('href'))\n\n\n game_urls = dict(zip(losing_teams, game_link))\n game_urls.update(dict(zip(winning_teams, game_link)))\n\n return game_urls","def get_newest_status():\n TrackedSite.objects.monitor_sites()","def weekly_min_paid_violations(self):\n return self._weekly_min_paid_violations","def test_week_in_range(self):\n weeks = list(range(1, 54))\n seq = 21\n for week in weeks:\n with self.subTest(week=week):\n result = star_barcode.construct_postscript(\n week=week,\n bwipp_location=self.bwipp,\n issn=self.issn,\n sequence=seq,\n header_line=''\n )\n self.assertGreater(\n result.find(f'{self.issn} {seq:02} {week:02}'),\n -1\n )","def weekNumber(self): # real signature unknown; restored from __doc__\r\n pass","def top_lovers_and_lovees(utc_week_start, dept=None, office=None, limit=20):\n sent_query = LoveCount.query(LoveCount.week_start == utc_week_start)\n if dept:\n sent_query = sent_query.filter(LoveCount.department == dept)\n\n if office:\n sent_query = sent_query.filter(LoveCount.office == office)\n\n sent = sent_query.order(-LoveCount.sent_count).fetch()\n lovers = []\n for c in sent:\n if len(lovers) == limit:\n break\n if c.sent_count == 0:\n continue\n employee_key = c.key.parent()\n\n lovers.append((employee_key, c.sent_count))\n\n received = sorted(sent, key=lambda c: c.received_count, reverse=True)\n lovees = []\n for c in received:\n if len(lovees) == limit:\n break\n if c.received_count == 0:\n continue\n employee_key = c.key.parent()\n\n lovees.append((employee_key, c.received_count))\n\n return (lovers, lovees)","def get_calendar_items(self, take=5):\n url = 'https://www.rova.nl/api/waste-calendar/upcoming'\n # request data from rova API and save response first 5 items (default)\n response = requests.get(url, params={\n 'postalcode': self.zip_code,\n 'houseNumber': self.house_number,\n 'addition': self.house_addition,\n 'take': take,\n })\n\n response.raise_for_status()\n\n rova_response = response.json()\n\n items = []\n types = []\n # add next pickup date for each garbage type\n for item in rova_response:\n date = datetime.strptime(item[\"date\"], \"%Y-%m-%dT%H:%M:%SZ\")\n date = date.strftime(\"%Y-%m-%dT%H:%M:%S\")\n garbage_type = item[\"garbageTypeCode\"].upper()\n\n items.append({\n 'GarbageTypeCode': garbage_type,\n 'Date': date\n })\n types.append(garbage_type)\n return items","def get_week_prediction(classifier, shift_ratios, needs, remove_ratios, remove_needs,\n max_scale_value):\n days_of_week = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday']\n predictions = {}\n for day in days_of_week:\n prediction = get_day_of_week_shift_prediction(\n classifier, day, shift_ratios, needs, remove_ratios, remove_needs, max_scale_value\n )\n predictions[day] = prediction\n\n return predictions","def test_get_top_doesnt_return_hidden_apps(self):\r\n\r\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\r\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\r\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\r\n hidden_app = self.create_app_with_contributors(11, 0, name='hidden')\r\n hidden_app.hidden = 1\r\n db.session.add(hidden_app)\r\n db.session.commit()\r\n\r\n top_apps = cached_apps.get_top()\r\n\r\n assert len(top_apps) is 3, len(top_apps)\r\n for app in top_apps:\r\n assert app['name'] != 'hidden', app['name']","def getMaxAddressOfUndefinedRange(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address) -> ghidra.program.model.address.Address:\n ...","def get_last_five_sales_entries():\n sales_worksheet = SHEET.worksheet('sales')\n list_of_last_fives = []\n for num in range(1, 7):\n col = sales_worksheet.col_values(num)\n last_five = col[-5:]\n list_of_last_fives.append(last_five)\n\n return list_of_last_fives","def numPostings(years):\n\tcount = []\n\tfor year in years:\n\t\tfilename = \"SmartEnergy\" +str(year) +\".xlsx\"\n\t\tDB = pd.read_excel(filename, sheet_name = 'Filters')\n\t\tcount.append(DB.iloc[10][1])\n\treturn count","def formatAddress():\n # Strings to load data\n stringFile = '/Users/Louis/Documents/Research/Code/cleanedData/'\n days = {'cleaned01-Dec-2015':2,# tuesday\n 'cleaned02-Dec-2015':3,# wednesday\n 'cleaned03-Dec-2015':4,# ...\n 'cleaned04-Dec-2015':5,\n 'cleaned07-Dec-2015':1,\n 'cleaned08-Dec-2015':2,\n 'cleaned09-Dec-2015':3,\n 'cleaned10-Dec-2015':4,\n 'cleaned11-Dec-2015':5,\n 'cleaned14-Dec-2015':1,\n 'cleaned15-Dec-2015':2,\n 'cleaned16-Dec-2015':3,\n 'cleaned17-Dec-2015':4,\n 'cleaned18-Dec-2015':5,\n 'cleaned21-Dec-2015':1}\n \n # Store results\n addresses = []\n CourierSuppliedAddresses = []\n \n for day in days.keys():\n # Configuration for CSV reading\n with open(stringFile+day+'_modified.csv') as csvfile:\n # Dictionary containing the info\n reader = csv.DictReader(csvfile,delimiter = ',')\n # print(day)\n \n for row in reader:\n addresses.append(row['Address'])\n CourierSuppliedAddresses.append(row['CourierSuppliedAddress'])\n \n addresses = list(set(addresses))\n addresses.sort()\n \n CourierSuppliedAddresses = list(set(CourierSuppliedAddresses))\n CourierSuppliedAddresses.sort()\n return addresses, CourierSuppliedAddresses","def get_top(self):\n elements = self.S.get_maximal_elements()\n data = {}\n alot = Nat().get_top()\n for e in elements:\n data[e] = alot\n return Multiset(data, self.S)","def upcoming(self):\n return self.filter(start__gte=timezone.now())","def get_top_answers(self, N):\n return sorted(\n self.answers.iteritems(), key=operator.itemgetter(1),\n reverse=True)[:N]","def get_all_top(self):\n return self.execute(TABELLE['top']['select']['all'])","def get_week():\n now = dt.now().date()\n return Week.objects.filter(date__lte=now).order_by('-date').first()","def get_top_public_momends(max_count):\n _obj = Momend.objects.filter(privacy=Momend.PRIVACY_CHOICES['Public']).order_by('create_date').reverse()\n\n return _obj if (_obj.count() < max_count) else _obj[_obj.count() - max_count:]","def weekly_viewed(df):\n df = convert_to_datetime(df)\n today = datetime.date.today()\n this_week_start = today - timedelta(days=7)\n last_week_start = today - timedelta(days=14)\n week_per_min = []\n lastweek_per_min = []\n thisweek_viewed = []\n lastweek_viewed = []\n for index, row in df.iterrows():\n if row['session_start'].date() >= this_week_start:\n per_min = get_cards_per_min(row)\n week_per_min.append(per_min)\n thisweek_viewed.append(row['total_looked_at'])\n if last_week_start <= row['session_start'].date() < this_week_start:\n per_min = get_cards_per_min(row)\n lastweek_per_min.append(per_min)\n lastweek_viewed.append(row['total_looked_at'])\n week_viewed_result = total_viewed(thisweek_viewed, lastweek_viewed)\n week_viewed_result['total_viewed_weekly'] = week_viewed_result.pop('total_viewed')\n\n return week_viewed_result","def ordered_result(self):\n cc = Counter(self._counter)\n return cc.most_common(self._qtd) #qtd is a cli arg used on --top-ips <number>","def addresses(self):\n if 'Ward Matters' in self.topics or 'City Matters' in self.topics:\n stname_pattern = \"(\\S*[a-z]\\S*\\s){1,4}?\"\n sttype_pattern = \"(ave|blvd|cres|ct|dr|hwy|ln|pkwy|pl|plz|rd|row|sq|st|ter|way)\"\n st_pattern = stname_pattern + sttype_pattern\n\n addr_pattern = \"(\\d(\\d|-)*\\s%s)\" %st_pattern\n intersec_pattern = exp = \"((?<=\\sat\\s)%s\\s?and\\s?%s)\" %(st_pattern, st_pattern)\n\n pattern = \"(%s|%s)\" %(addr_pattern, intersec_pattern)\n\n matches = re.findall(pattern, self.description, re.IGNORECASE)\n\n addresses = [m[0] for m in matches]\n return addresses\n\n return []","def top10(self) -> List[Word]:\n return self._top10","def build_population(self, fronts):\n population = []\n\n for front in fronts:\n if len(population) + len(front) > self.pop_size:\n front.sort(reverse=True)\n fill_count = self.pop_size - len(front)\n population += front[:fill_count]\n break\n\n population += front\n\n return population","def Margin(model, pool, addn):\n\n # Get probability distribution over labels and sort for each x\n pool_p = np.sort(model.predict_proba(pool), axis = 1)\n\n # Calulate difference between two highes label probabilities\n Margin = np.argsort(pool_p[:,-1] - pool_p[:,-2])\n\n # Choses the addn observations with lowest margin\n x_star = Margin[:addn]\n return x_star","def query_serp(query:str, site:str, dates:list, num_results:int, paper_name:str) -> list:\n all_sites = []\n total_sites_count = 0\n\n for d in dates:\n try:\n # Get query dict and params dict\n query_r, params = make_params(query=query, site=site, date_start=d[0], date_end=d[1],\n num_results=num_results, paper=paper_name)\n # serpAPI query\n client = GoogleSearchResults(params)\n results = client.get_dict()\n news_results = results['news_results']\n\n count = 0\n sites_date = []\n # Loop through till end of search results or error encountered\n while (news_results and len(news_results)>0) or ('error' not in results):\n sites = [news['link'] for news in news_results]\n sites_date.extend(sites)\n count+=len(sites)\n\n params['start'] = count\n client = GoogleSearchResults(params)\n results = client.get_dict()\n news_results = results['news_results']\n\n print('Date Range: {}-{}\\tTotal Sites: {}'.format(d[0],d[1],len(sites_date)))\n\n # add list of sites to query dict\n query_r['sites'] = sites_date\n all_sites.append(query_r)\n total_sites_count += len(sites_date)\n except Exception as e:\n print(e)\n print(d)\n continue\n print('Total Sites: {}'.format(total_sites_count))\n return all_sites","def get_five_latest(self):\r\n selection = []\r\n sorted(self.tweets, key=lambda tweet: tweet.date, reverse=True)\r\n amount = 5\r\n if self.get_length() < 5:\r\n amount = self.get_length()\r\n for i in range(amount):\r\n selection.append(self.tweets[i])\r\n return selection","def getTopStories(self):\n source = self.getSource(\"http://news.ycombinator.com\")\n stories = self.getStories(source)\n return stories"],"string":"[\n \"def find_top_seven_routes(self):\\n df = self.filter_according_to_travel_day('Sunday')\\n # Group the dataset according to the frequency of the travel route\\n df =df.groupby([\\\"travel_from\\\", \\\"travel_to\\\"]).size().reset_index(name=\\\"Frequency\\\")\\n #Sort the dataset according to the frequency in descending order\\n df =df.sort_values(\\\"Frequency\\\", ascending=False)[:7]\\n return df\",\n \"def _set_top_preps(self) -> None :\\n prep_dict = self._system.getPReps(1, 20)\\n prep_address_list = prep_dict['preps']\\n for each_prep in prep_address_list:\\n self._top_preps.put(each_prep['address'])\",\n \"def get_top_five_countries():\\n countries=country_populations.split('\\\\n')\\n top_5=[]\\n count=0\\n for country in countries:\\n if count<6:\\n data= country.split('\\\\t')\\n top_5.append(data[1])\\n count+=1\\n top_5.remove('Country')\\n return top_5\",\n \"def topstreet_pub(self):\\n out=self.df.withColumn('street', split(col('address'), ',')[0]) \\\\\\n .groupby('street').agg(count('name').alias('st_count')) \\\\\\n .sort(desc(\\\"st_count\\\")).select(\\\"street\\\").limit(1) \\n out.withColumnRenamed('street','street which has highest number of pubs') \\\\\\n .write.mode(\\\"overwrite\\\").csv('{}streetname/'.format(self.target))\\n\\n return out.rdd.map(lambda l:l.street).collect()\",\n \"def test_get_top_returns_four_apps_by_default(self):\\r\\n\\r\\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\\r\\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\\r\\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\\r\\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\\r\\n ranked_5_app = self.create_app_with_contributors(7, 0, name='five')\\r\\n\\r\\n top_apps = cached_apps.get_top()\\r\\n\\r\\n assert len(top_apps) is 4, len(top_apps)\",\n \"def _reset_top_preps(self) -> None:\\n if self._system.getIISSInfo()[\\\"nextPRepTerm\\\"] > self._block_height_week.get() + (7 * 43200):\\n self._block_height_week.set(self._system.getIISSInfo()[\\\"nextPRepTerm\\\"])\\n for i in range(len(self._top_preps)):\\n self._top_preps.pop()\\n self._set_top_preps()\",\n \"def topCountries(top=10):\\r\\n #top 10 deadly countries\\r\\n countries = agg('country')[:top].index\\r\\n #grab aggregated data for these countries\\r\\n dataOfTop10 = agg(['year','country']).query(\\\"country in @countries\\\")### interesting...\\r\\n #unstack data\\r\\n dataOfTop10 = dataOfTop10.unstack(1)\\r\\n #remove multiindexes\\r\\n dataOfTop10 = dataOfTop10.transpose().reset_index(level=0, drop=True).transpose()\\r\\n #sort by year\\r\\n dataOfTop10.sort_index(inplace=True)\\r\\n return dataOfTop10\",\n \"def test_get_top_returns_apps_with_most_taskruns(self):\\r\\n\\r\\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\\r\\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\\r\\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\\r\\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\\r\\n\\r\\n top_apps = cached_apps.get_top()\\r\\n\\r\\n assert top_apps[0]['name'] == 'one', top_apps\\r\\n assert top_apps[1]['name'] == 'two', top_apps\\r\\n assert top_apps[2]['name'] == 'three', top_apps\\r\\n assert top_apps[3]['name'] == 'four', top_apps\",\n \"def topOccupations(years):\\n\\toccs = []\\n\\tfor year in years:\\n\\t\\tfilename = \\\"SmartEnergy\\\" +str(year) +\\\".xlsx\\\"\\n\\t\\tDB = pd.read_excel(filename, sheet_name= \\\"Report1_Data\\\", usecols =[\\\"BGTOCC\\\",\\\"Job Postings\\\"])\\n\\t\\t# occs.append(DB.head(5))\\n\\t\\toccs.append(DB)\\n\\t\\tTopOccs =pd.concat(occs, keys = list(years), names =['year'])\\n\\t\\n\\t# Which occupations appear throughout the years, which are new and which no longer appear?\\n\\t\\n\\t\\n\\tv = TopOccs.BGTOCC.value_counts().sort_index()\\t\\n\\t\\n\\t# create list of occupations that are posted each year\\n\\trecurringOccs = v[v==8].index.tolist()\\n\\t\\n\\treturn TopOccs\\n\\t# emergingOccs = \\n\\t# print(TopOccs.loc[2012,:])\",\n \"def read_weekly_breakdown_statuses(self):\\n from itertools import repeat\\n\\n self.ID7_GNIP_BREAKDOWN = kpi_from_db_config.ID7_GNIP_BREAKDOWN\\n self.ID7_STREAM_BREAKDOWN = kpi_from_db_config.ID7_STREAM_BREAKDOWN\\n self.ID7_SEED_BREAKDOWN = kpi_from_db_config.ID7_SEED_BREAKDOWN\\n self.ID7_MENTION_BREAKDOWN = kpi_from_db_config.ID7_MENTION_BREAKDOWN\\n \\n list_id = [self.ID7_GNIP_BREAKDOWN, \\n self.ID7_STREAM_BREAKDOWN, \\n self.ID7_SEED_BREAKDOWN, \\n self.ID7_MENTION_BREAKDOWN]\\n\\n list_result = [[] for i in repeat(None,len(list_id))]\\n for i in range(len(list_id)):\\n self.cursor.execute('''\\n SELECT value\\n FROM public.kpi_report\\n WHERE id = %s\\n ORDER BY created_at DESC\\n LIMIT 6\\n ''', [list_id[i]])\\n rows_count = self.cursor.rowcount\\n \\n if (rows_count == 6): # 6 is LIMIT from the query\\n for doc in self.cursor:\\n list_result[i].append(int(doc[0]))\\n elif (rows_count >= 1 and rows_count < 6): # Change rows_count > 0 and rows_count < Number of limit\\n for doc in self.cursor:\\n list_result[i].append(int(doc[0]))\\n list_result[i] = list_result[i] + [0] * (6 - rows_count) \\n else:\\n list_result[i] = [0] * 6\\n\\n return list_result\",\n \"def rideshare_pickups(self, since):\\n query = \\\"\\\"\\\"\\n SELECT\\n week as date,\\n SUM(n_trips) as value\\n FROM rideshare\\n WHERE week >= ?\\n GROUP BY date\\n \\\"\\\"\\\"\\n cur = self.con.cursor()\\n cur.execute(query, (since,))\\n rows = rows_to_dicts(cur, cur.fetchall())\\n return rows\",\n \"def get_ups(self):\\n return self.ups\",\n \"def test_get_top_respects_limit(self):\\r\\n\\r\\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\\r\\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\\r\\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\\r\\n ranked_4_app = self.create_app_with_contributors(7, 0, name='four')\\r\\n\\r\\n top_apps = cached_apps.get_top(n=2)\\r\\n\\r\\n assert len(top_apps) is 2, len(top_apps)\",\n \"def __r7(soup):\\n news = []\\n ps = soup.find_all('p', class_='trends-thermometer-description')\\n i = 0\\n\\n for p in ps:\\n if i == 6: # Six trending topics\\n break\\n i += 1\\n a = p.parent.parent.parent.a\\n news.append(dict(title=a['title'], link=a['href']))\\n return news\",\n \"def top3_records(self):\\n return sorted(set([sanitize(t) for t in self]))[0:3]\",\n \"def get_top_10(df):\\n\\n grouped_df = df.groupby(\\\"country\\\").max()\\n\\n # Confirmed cases\\n print(grouped_df.sort_values(\\\"confirmed\\\",\\n ascending=False)[\\\"confirmed\\\"][:10])\\n\\n # Deaths\\n print(grouped_df.sort_values(\\\"deaths\\\", ascending=False)[\\\"deaths\\\"][:10])\\n\\n # Recoveries\\n print(grouped_df.sort_values(\\\"recovered\\\",\\n ascending=False)[\\\"recovered\\\"][:10])\\n\\n a = grouped_df.sort_values(\\\"recovered\\\", ascending=False)[\\\"recovered\\\"][:10]\\n print(a.to_markdown())\",\n \"def get_top(n=4):\\r\\n sql = text('''SELECT app.id, app.name, app.short_name, app.description, app.info,\\r\\n COUNT(app_id) AS total FROM task_run, app\\r\\n WHERE app_id IS NOT NULL AND app.id=app_id AND app.hidden=0\\r\\n GROUP BY app.id ORDER BY total DESC LIMIT :limit;''')\\r\\n results = db.engine.execute(sql, limit=n)\\r\\n top_apps = []\\r\\n for row in results:\\r\\n app = dict(id=row.id, name=row.name, short_name=row.short_name,\\r\\n description=row.description,\\r\\n info=json.loads(row.info),\\r\\n n_volunteers=n_volunteers(row.id),\\r\\n n_completed_tasks=n_completed_tasks(row.id))\\r\\n top_apps.append(app)\\r\\n return top_apps\",\n \"def get_commercial_next_week_trips(self):\\n\\n trips = self.env['sales_trip.trip']\\n domain = ['&',\\n ('trip_day_week_number','>=',self.get_today_week_number()),\\n ('commercial_id', '=', self.commercial_id.id)]\\n\\n return trips.search(domain)\",\n \"def get_top_featured_entries(number=5):\\n return list(Entry.published.filter(featured=True)[:number])\",\n \"def get_best_five(self):\\n return sorted(self.speakers.iteritems(),\\n key=lambda (key, val): (val, key),\\n reverse=True)[:5]\",\n \"def getTopUsers(self):\\n\\n\\t\\tquery = \\\"\\\"\\\"select M.user_id, count( distinct M.venue_id) as cnt\\n\\t\\t\\t\\t\\tfrom\\n\\t\\t\\t\\t\\t(\\n\\t\\t\\t\\t\\tselect J.user_id, J.venue_id, J.latitude, J.longitude, J.Homelat, J.Homelong,\\n\\t\\t\\t\\t\\tCASE\\n\\t\\t\\t\\t\\t\\tWHEN J.latitude = J.Homelat and J.longitude = J.Homelong THEN 1\\n\\t\\t\\t\\t\\t\\tELSE 0\\n\\t\\t\\t\\t\\t\\tEND bool\\n\\t\\t\\t\\t\\tfrom \\n\\t\\t\\t\\t\\t(\\n\\t\\t\\t\\t\\tselect C.*, U.latitude as Homelat, U.longitude as Homelong \\n\\t\\t\\t\\t\\tfrom checkins C\\n\\t\\t\\t\\t\\tleft join users U\\n\\t\\t\\t\\t\\ton U.id = C.user_id\\n\\t\\t\\t\\t\\t) J\\n\\t\\t\\t\\t\\twhere bool=0\\n\\t\\t\\t\\t\\t) M\\n\\t\\t\\t\\t\\tgroup by user_id\\n\\t\\t\\t\\t\\torder by cnt desc, user_id\\n\\t\\t\\t\\t\\tlimit {}\\\"\\\"\\\".format(self.top)\\n\\n\\t\\tdf = pd.read_sql_query(query, self.conn)\\n\\n\\t\\tself.topusers = df[\\\"user_id\\\"].tolist()\",\n \"def weekly():\",\n \"def getWeeks(year):\\n url = \\\"http://www.boxofficemojo.com/weekend/?yr=%d\\\" % year\\n src = urllib.request.urlopen(url).read()\\n soup = BeautifulSoup(src, 'html.parser')\\n chart = soup.find(border=\\\"0\\\", cellspacing=\\\"1\\\", cellpadding=\\\"5\\\")\\n data = parseTable(chart)\\n weeks = [int(row[-1]) for row in data[1:]]\\n return weeks\",\n \"def get_todays_posts():\\n \\n return sorted(requests.get(TODAY_URL).json()['hunts'], \\n key=lambda post: post['rank'])\",\n \"def top_n(self, n: int = 10) -> dict:\\n return self.members[:n]\",\n \"def top_n(self, n: int = 10) -> dict:\\n return self.members[:n]\",\n \"def FindTournamentEntrants(Placement: 'df', week: int) -> None:\\r\\n Placement['NumTMTEntered'] = 0\\r\\n Placement['NumInBracket'] = 0\\r\\n for index, row in Placement.iterrows():\\r\\n nTMTEntered = 0\\r\\n nInBracket = 0\\r\\n for i in range(1, week + 1):\\r\\n weeklyPlacement = row[f'PWeek{i}']\\r\\n if weeklyPlacement > -2:\\r\\n nTMTEntered += 1\\r\\n if weeklyPlacement > -1:\\r\\n nInBracket += 1\\r\\n Placement.at[index, 'NumTMTEntered'] = nTMTEntered\\r\\n Placement.at[index, 'NumInBracket'] = nInBracket\",\n \"def query_weekly_hits(cls,N=10):\\n bwkey = 'BookWeeklyHits'\\n bks = from_cache(bwkey)\\n if not bks:\\n dt = datetime.utcnow() - timedelta(days=7)\\n daus = SuiDau.all().filter('date >=',dt).order('-visits').fetch(N)\\n bids = [d.book for d in daus]\\n bks = map(lambda e:str(e.key().id()),SuiBook.get_by_id(bids))\\n to_cache(bwkey,bks)\\n return bks\",\n \"def most_infected(n: int, day: datetime.date, return_zip: bool) -> list:\\n \\n day = day.strftime('%m-%d-%Y')\\n url = f'https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_daily_reports/{day}.csv'\\n\\n df = pd.read_csv(StringIO(requests.get(url).text))\\n df = df.loc[df['Country_Region'] == 'US'].sort_values(by='Confirmed', ascending=False) # only US and sort by Confirmed\\n df = df.loc[(df['Admin2'] != 'Unassigned') & (df['Province_State'] != 'Puerto Rico')] # remove Unassigned\\n\\n locations = list(df.head(n)[['Admin2', 'Province_State']].values)\\n\\n df = pd.read_csv(r'Data Collection\\\\Apparatus\\\\Docs\\\\zip_code_database.csv')[['county', 'state', 'zip']]\\n df['county'] = df['county'].str.replace(' County','').str.replace(' City','')\\n \\n\\n if (return_zip):\\n state_abbreviation = pd.read_csv(r'Data Collection\\\\Apparatus\\\\Docs\\\\states_and_counties.csv')\\n state_abbreviation['State Name'].str.title()\\n\\n result = []\\n for county, state in locations:\\n if (type(county) == str):\\n county = county.replace(' County', '').replace(' City', '')\\n state = zip_conversion.state_to_abbreviation(state, state_abbreviation)\\n result.append([str(code).zfill(5) for code in zip_conversion.county_to_zip(county, state, df)])\\n\\n result = [codes for codes in result if codes != []]\\n return [y for x in result for y in x]\\n\\n else:\\n result = []\\n for county, state in locations:\\n if (type(county) == str):\\n county = county.replace(' County', '').replace(' City', '')\\n result.append((county, state))\\n\\n return result\",\n \"def generate_dict_top_five(self):\\n all_months = {}\\n # Loops over each avilable non-duplicate date\\n available_dates = self.contacts.quer_distinct_components(\\\"contact_date\\\", \\\"Contacts\\\")\\n for date in available_dates:\\n top_five = self.ordered[date]\\n all_months[date] = {}\\n\\n # Loops over top five to append their components to the final dict\\n for index in range(len(top_five)):\\n listing_id = top_five[index][1]\\n total_contacts = top_five[index][0]\\n\\n all_months[date].update(\\n {\\n index+1: {\\n 'Ranking': index+1,\\n 'Listing Id': listing_id,\\n 'Make': self.listing.quer_component_using_column(\\\"make\\\", \\\"id\\\", \\\"Listings\\\", listing_id)[0][0],\\n 'Selling Price': self.listing.quer_component_using_column(\\\"price\\\", \\\"id\\\", \\\"Listings\\\", listing_id)[0][0],\\n 'Mileage': self.listing.quer_component_using_column(\\\"mileage\\\", \\\"id\\\", \\\"Listings\\\", listing_id)[0][0],\\n 'Total Amount of Contacts': total_contacts\\n }\\n }\\n )\\n\\n return all_months\",\n \"def get_all_from_top_ten(title,users,max = 3):\\n \\\"\\\"\\\" ten prolific users \\\"\\\"\\\"\\n \\\"\\\"\\\" max : number of user with related followers \\\"\\\"\\\"\\n getAllUsers(users,all_users,users_set,proceeded_users,max,user_cpt,title)\\n for data in users_set:\\n print(data.id)\",\n \"def GetListOfWeeks(self):\\n delta_days = (self.GetFridayOfLastFullWeek() - self.START_DATE).days\\n delta_weeks = int(math.floor(delta_days / 7))\\n weeks = [self.START_DATE + dt.timedelta(days=7 * x) \\n for x in range(0, delta_weeks + 1)]\\n weeks = [week.strftime('%Y-%m-%d') for week in weeks]\\n self.cursor.execute(\\n 'SELECT DISTINCT week FROM %s' % self.BOX_OFFICE_TABLE)\\n weeks_in_table = [x[0] for x in self.cursor.fetchall()]\\n weeks = list(set(weeks) - set(weeks_in_table))\\n weeks.sort() \\n return weeks\",\n \"def weekly(evictiondata):\\r\\n evictions_per_week = {}\\r\\n for index, row in evictiondata.iterrows():\\r\\n if row['week_date'] not in evictions_per_week.keys():\\r\\n evictions_per_week[row['week_date']] = row['filings_2020']\\r\\n else:\\r\\n evictions_per_week[row['week_date']] += row['filings_2020']\\r\\n return evictions_per_week\",\n \"def getHighestAlertCountSumCPs(self):\\n self.communicationPairs.sort(\\n key=lambda x: x.getAlertCountSum(), reverse=True)\\n returnList = []\\n for i in range(len(self.communicationPairs)):\\n if i == 10:\\n break\\n returnList.append(\\n {'source_ip': self.communicationPairs[i].getSourceIp(),\\n 'dest_ip': self.communicationPairs[i].getDestIp(),\\n 'alert_count_sum': self.communicationPairs[i].getAlertCountSum()})\\n return returnList\",\n \"def sample_top_neighbors( self, max_count=200 ):\\n df = self.copy()\\n return df[df['neighbor'] <= max_count].coerce()\",\n \"def top30_clients(self):\\n clients = self.clients_sorted_by_rentals()\\n return clients[:int(0.3 * len(clients))]\",\n \"def load_presn_runs(offset, limit):\\n now_local = datetime.now()\\n timelimit = timedelta(hours=100)\\n server = couchdb.Server(\\\"http://snoplus:\\\"+app.config[\\\"COUCHDB_PASSWORD\\\"]+\\\"@\\\"+app.config[\\\"COUCHDB_HOSTNAME\\\"])\\n db = server[\\\"pre-supernova\\\"]\\n results = []\\n skip = offset\\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\\n total = all.total_rows\\n offset = all.offset\\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\\n year = row.key[0]\\n mon = row.key[1]\\n day = row.key[2]\\n hour = row.key[3]\\n minute = row.key[4]\\n sec = row.key[5]\\n run = row.value\\n run_id = row.id\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n if timediff<timelimit:\\n try:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n results.sort(reverse=True)\\n return results, total, offset, limit\",\n \"def get_sorted():\\n return sorted(country_list, key=get_pop_and_name)\",\n \"def forecast_weekly():\\n forecast = get_forecast()\\n daily = forecast.daily()\\n return daily.summary\",\n \"def __top_prod_countries(df, number_of_countries):\\n\\t\\tmlb = MultiLabelBinarizer()\\n\\t\\ttemp = pd.DataFrame(mlb.fit_transform(df['production_countries']), columns=mlb.classes_, index=df.index)\\n\\t\\treturn temp.sum().sort_values(ascending=False)[:number_of_countries].index.values\",\n \"def build_top_browsers(self):\\n browsers = heapq.nlargest(10, self.browser_dict, key=self.browser_dict.get)\\n \\n top_browsers = {}\\n for x in range(len(browsers)):\\n top_browsers[str(browsers[x])]= self.browser_dict[browsers[x]]\\n \\n return top_browsers\",\n \"def get_apt_num(self):\\n html = self.driver.page_source\\n soup = BeautifulSoup(html, \\\"html.parser\\\")\\n # apt_days = soup.findAll(\\\"div\\\", attrs={\\\"class\\\": \\\"field-fullwidth\\\"})\\n apt_days = soup.findAll(\\\"div\\\", attrs={\\\"class\\\": \\\"md:flex-shrink text-gray-800\\\"})\\n # If the webpage fails to load, relaod and find openings\\n while len(apt_days) == 0:\\n sleep(2)\\n self.driver.get(self.search_website)\\n self.driver.refresh()\\n html = self.driver.page_source\\n soup = BeautifulSoup(html, \\\"html.parser\\\")\\n apt_days = soup.findAll(\\\"div\\\", attrs={\\\"class\\\": \\\"md:flex-shrink text-gray-800\\\"})\\n print(\\\"Web page fault. May need to restart.\\\")\\n # Start a new list for appointments\\n self.openings = []\\n for apt in apt_days:\\n apt_info = apt.findAll(\\\"p\\\")\\n for info in apt_info:\\n # If the text available appointments is witihin then pull the number\\n if \\\"Available Appointments\\\" in info.text:\\n apt_op_search = re.search(\\\"\\\\d+\\\", info.text)\\n apt_openings = int(apt_op_search.group())\\n self.openings.append(apt_openings)\\n break\",\n \"def topBrandsandCountries(df, countries_unique):\\n top_countries = {}\\n for x in countries_unique:\\n if df[df.geo_country==x].device_brand_name.count() > 500:\\n top_countries[x] = df[df.geo_country==x].device_brand_name.count()\\n\\n top_3_brands = ['Apple','Samsung','Huawei']\\n\\n apple = []\\n samsung = []\\n huawei = []\\n for x in top_countries.keys():\\n apple.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[0]].device_brand_name.count())\\n samsung.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[1]].device_brand_name.count())\\n huawei.append(df[df.geo_country==x][df.device_brand_name==top_3_brands[2]].device_brand_name.count()) \\n\\n return top_countries,apple,samsung,huawei\",\n \"def get_top_spammers(self, n):\\n sql_command = \\\"SELECT * FROM points ORDER BY amount DESC;\\\"\\n cursor, connection = self.execute_command_get_connection(sql_command, [])\\n all = cursor.fetchall()\\n\\n return all[:n]\",\n \"def week_top_five(db: str) -> None:\\n # Creating x and y variables for each month using the helper function\\n # max_delays to get the five stations with the longest overall delays\\n month_1 = [max_delays(db, 0)]\\n month_2 = [max_delays(db, 1)]\\n month_3 = [max_delays(db, 2)]\\n month_4 = [max_delays(db, 3)]\\n month_5 = [max_delays(db, 4)]\\n month_6 = [max_delays(db, 5)]\\n \\n # using the variables to plot bar graphs of each month.\\n plt.figure(figsize=(35, 20)) \\n plt.xticks(fontsize=20) \\n \\n plt.subplot(2, 3, 1)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Sept 2017') \\n plt.bar(month_1[0][0], month_1[0][1])\\n \\n plt.subplot(2, 3, 2)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Oct 2017') \\n plt.bar(month_2[0][0], month_2[0][1]) \\n \\n plt.subplot(2, 3, 3)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Nov 2017') \\n plt.bar(month_3[0][0], month_3[0][1]) \\n \\n plt.subplot(2, 3, 4)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Dec 2017') \\n plt.bar(month_4[0][0], month_4[0][1]) \\n \\n plt.subplot(2, 3, 5)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Jan 2018') \\n plt.bar(month_5[0][0], month_5[0][1])\\n \\n plt.subplot(2, 3, 6)\\n plt.xlabel('Station')\\n plt.ylabel('Total Time of Delays (minutes)') \\n plt.title('Feb 2018') \\n plt.bar(month_6[0][0], month_6[0][1]) \\n \\n plt.tight_layout()\\n plt.savefig('week_top_five.png')\\n plt.close()\",\n \"def print_all(self, lim=100):\\n for item in islice(weekdays.return_all(), 0, 100):\\n print(item)\",\n \"def get_top_tweets():\\n Tweet.top_tweets = [(k, v) for k, v in sorted(Tweet.hashtag_counter.items(), key=lambda item: item[1], reverse=True)]\\n top_10_tweets = {}\\n top_10_tweets['top_tweets'] = []\\n for tweet in Tweet.top_tweets[:10]:\\n top_10_tweets['top_tweets'].append({'hashtag': \\\"#\\\"+tweet[0], 'count': tweet[1]})\\n return top_10_tweets\",\n \"def weekly_max_paid_violations(self):\\n return self._weekly_max_paid_violations\",\n \"def precipitation():\\n year_ago = dt.date(2017,8,23) - dt.timedelta(days=365)\\n one_year_ago = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= year_ago).all()\\n\\n all_precip = []\\n for precip in one_year_ago:\\n precip_dict = {}\\n precip_dict[\\\"name\\\"] = precip.date\\n precip_dict[\\\"precip\\\"] = precip.prcp\\n\\n all_precip.append(precip_dict)\\n\\n return jsonify(all_precip)\",\n \"def get_trends_by_week(self):\\n try:\\n return self.profile_data[\\\"trendsByWeek\\\"]\\n except Exception as e:\\n error_msg = (\\\"Failed to retrieve weekly trends: {}\\\"\\n \\\"\\\".format(str(e)))\\n raise PlayerDataException(error_msg)\",\n \"def top(self):\\r\\n return self.topele\",\n \"def get_average_number_of_officers():\\n pd_info = browser.find_element_by_class_name(\\\"pd_info\\\")\\n town_info = pd_info.find_element_by_class_name(\\\"town_description\\\")\\n return (\\n town_info.find_element_by_class_name(\\\"right\\\")\\n .find_element_by_class_name(\\\"town_label\\\")\\n .get_property(\\\"innerHTML\\\")\\n )\",\n \"def get_popular_tickets_solution(tickets):\\n popular_tickets = []\\n for ticket in tickets:\\n num_watchers = len(ticket['people']['watchers'])\\n if num_watchers >= 8:\\n popular_tickets.append(ticket)\\n return popular_tickets\",\n \"def _sub_ranker_top(self,numbers_frequency):\\n rank=2\\n\\n if max(numbers_frequency.loc[numbers_frequency>0].index) == 14:\\n rank=1\\n\\n return rank\",\n \"def get_top_nationalities(result, n=5):\\n nat_freq=pd.DataFrame(result['country'].value_counts())\\n ratios=nat_freq[:n]/nat_freq.sum()*100\\n res='The most common visitors are from'\\n for i in range(0,len(ratios)):\\n if i!=len(ratios)-1:\\n res=res+f' {ratios.index[i]} ({np.round(ratios.country[i],2)}%),'\\n else:\\n res=res+f' and {ratios.index[i]} ({np.round(ratios.country[i],2)}%).'\\n return res\",\n \"def get_top_clickers(self, window: str, limit: str = None, page: str = None) -> dict:\\n params = remove_empty_elements({\\\"window\\\": window,\\n \\\"size\\\": limit,\\n \\\"page\\\": page})\\n return self.http_request(\\\"GET\\\", '/people/top-clickers', params=params)\",\n \"def _get_current_week_entries(today, user):\\n some_day = today + timedelta(days=1)\\n monday_of_week = some_day - timedelta(days=(some_day.isocalendar()[2] - 1))\\n sunday_of_week = monday_of_week + timedelta(days=6)\\n weekevents = TimeEntry.objects.filter(\\n booking_date__gte=monday_of_week, booking_date__lt=sunday_of_week, user=user\\n )\\n return weekevents\",\n \"def getTopPopulationRegion(self):\\n\\t\\tdata = {}\\n\\t\\tfor iProvince in range(con.iNumRegions):\\n\\t\\t\\tdata[iProvince] = 0\\n\\t\\tfor iLoopPlayer in range(con.iBarbarian + 1):\\n\\t\\t\\tapCityList = PyPlayer(iLoopPlayer).getCityList()\\n\\t\\t\\tfor pCity in apCityList:\\n\\t\\t\\t\\tdata[pCity.GetCy().plot().getRegionID()] += pCity.getPopulation()\\n\\t\\tkey = -1\\n\\t\\tfor key, value in sorted(data.iteritems(), key=lambda (k,v): (v,k)):\\n\\t\\t\\tpass\\n\\t\\treturn key\",\n \"def getPastProjects(self)->list:\\n returnList=[]\\n for i in range(0,randint(1, 10)):\\n randumProjectId = randint(0, 109)\\n if randumProjectId not in returnList:\\n returnList.append(randumProjectId)\\n\\n return returnList\",\n \"def print_highest_rainfall(properly_organized_date_and_totals):\\n\\tprint('The highest rain fall value found was: {} on {}.'.format(properly_organized_date_and_totals[1], properly_organized_date_and_totals[0]))\",\n \"def get_popular_tickets(tickets):\\n popular_tickets = []\\n #\\n # TODO - your code here\\n # \\n for ticket in tickets:\\n str_len=len(ticket['people']['watchers'])\\n if str_len>=8:\\n popular_tickets.append(ticket)\\n \\n return popular_tickets\",\n \"def least_popular_influencers(self, influencerTopSim, count):\\n infPopularity = {influencer: 0 for influencer in influencerTopSim}\\n for influencer in influencerTopSim:\\n infTweetPop = self.userTweetsStat[influencer]\\n avgPop = []\\n for tweet in influencerTopSim[influencer]:\\n infTweet = infTweetPop[len(infTweetPop)-1]\\n avgPop.append(self.assign_popularity_to_tweet(infTweet,tweet))\\n infPopularity[influencer] = np.mean(avgPop)\\n \\n tmp = {key: rank for rank, key in enumerate(sorted(set(infPopularity.values()), reverse=True), 1)}\\n rankInfluencer = {k: tmp[v] for k,v in infPopularity.items()}\\n leastPopInfluencer = [a for a in dict(sorted(rankInfluencer.items(), key=operator.itemgetter(1), reverse=True)[:count]).keys()]\\n \\n return leastPopInfluencer\",\n \"def top_n(self, n):\\n top = {}\\n for code, feat_set in self.iteritems():\\n tuples = sorted(feat_set.items(), reverse=True, key=itemgetter(1))\\n best = {feat for feat, _ in tuples[:n]}\\n top[code] = best\\n return top\",\n \"def find_top_five_most_contacted_listings_per_month(self):\\n available_dates = self.contacts.quer_distinct_components(\\\"contact_date\\\", \\\"Contacts\\\")\\n available_listing_ids = self.contacts.quer_distinct_components(\\\"listing_id\\\", \\\"Contacts\\\")\\n \\n self.ordered = {}\\n for date in available_dates:\\n listing = []\\n month = self.contacts.quer_component_using_column(\\\"listing_id\\\", \\\"contact_date\\\", \\\"Contacts\\\", date)\\n new = [month[0] for month in month]\\n for listing_id in available_listing_ids:\\n count = new.count(listing_id)\\n listing.append([count, listing_id])\\n listing = sorted(listing, key=lambda x: x[0], reverse=True)\\n\\n self.ordered[date] = listing[:5]\",\n \"def top_ten(subreddit):\\n req = get(\\n \\\"https://www.reddit.com/r/{}/hot.json\\\".format(subreddit),\\n headers={\\n \\\"User-Agent\\\": \\\"alx_app\\\"},\\n params={\\n \\\"limit\\\": 10},\\n allow_redirects=False)\\n if req.status_code != 200:\\n print(None)\\n else:\\n posts = req.json().get(\\\"data\\\").get(\\\"children\\\")\\n for post in posts:\\n print(post.get(\\\"data\\\").get(\\\"title\\\"))\",\n \"def get_player_stats_from_game(team, year, week):\",\n \"def temperatures_by_country_till2013():\\r\\n\\r\\n # Columns: dt, AverageTemperature, AverageTemperatureUncertainty, Country\\r\\n temperatures = pd.read_csv(\\\"GlobalLandTemperatures/GlobalLandTemperaturesByCountry.csv\\\")\\r\\n\\r\\n # 577 462 rows\\r\\n print(len(temperatures))\\r\\n\\r\\n countries = temperatures['Country'].unique()\\r\\n print(len(countries))\\r\\n print(sorted(countries))\",\n \"def get_personnel():\\r\\n if len(off) == 0:\\r\\n print(\\\"There are no office workers\\\")\\r\\n else:\\r\\n for i in off:\\r\\n print(str(i))\",\n \"def get_highest_priority(self):\\n for i in self.query.index.values.tolist():\\n if not int(self.query.loc[i,'in_%s'%self.program]):\\n pick = self.query.loc[i]\\n break\\n return pick\",\n \"def test_top_country(self):\\n tabular_format_countries_list = [['Canada', 66, '20'], ['United States', 33, '10']]\\n\\n result = InstallationStatistics.get_statistics_top_country(tabular_format_countries_list)\\n\\n self.assertEqual('Canada', result)\",\n \"def earliest_available_offsets(self):\\n return self.fetch_offset_limits(OffsetType.EARLIEST)\",\n \"def get_reps_for_address(address):\\n if not GOOGLE_API_KEY:\\n raise AssertionError('Missing GOOGLE_API_KEY from env')\\n\\n # https://developers.google.com/civic-information/docs/v2/representatives\\n params = {\\n 'key': GOOGLE_API_KEY,\\n 'includeOffices': True,\\n 'address': address\\n }\\n resp = requests.get(base_url, params=params)\\n if not resp.ok:\\n # TODO(carolyn): differentiate btwn malformed address, rate limits, etc\\n return\\n\\n data = resp.json()\\n if 'offices' not in data or 'officials' not in data:\\n logger.error('Missing required key from Google response')\\n return\\n\\n offices = data['offices']\\n officials = data['officials']\\n\\n # TODO(carolyn): format this like the other api endpoint?\\n # for now, just add the office name to the officials\\n for office in offices:\\n office_name = office['name']\\n for i in office['officialIndices']:\\n officials[i]['office_name'] = office_name\\n\\n return officials\",\n \"def get_game_urls(year, week):\\n base_url = \\\"https://www.pro-football-reference.com\\\"\\n\\n # URL for the summary of all games for a given week\\n # This page has the each match up for the week and\\n # a link to the detailed game stats \\n url = \\\"https://www.pro-football-reference.com/years/{}/week_{}.htm\\\".format(\\n year, week)\\n\\n response = get(url)\\n\\n week_summary = BeautifulSoup(response.content, 'html.parser')\\n\\n # Get just the game summary content\\n week_summary_games = week_summary.find_all(\\n attrs={\\\"class\\\": \\\"game_summary expanded nohover\\\"})\\n\\n losing_teams = []\\n winning_teams = []\\n game_link = []\\n\\n # For each game played, extract the losing team,\\n # the winning team, and the detailed game stats link\\n for game in week_summary_games:\\n try:\\n losing_team_strings = [text for text in game.find(\\n attrs={\\\"class\\\": \\\"loser\\\"}).stripped_strings]\\n losing_teams.append(losing_team_strings[0])\\n except AttributeError:\\n pass\\n\\n try:\\n winning_team_strings = [text for text in game.find(\\n attrs={\\\"class\\\": \\\"winner\\\"}).stripped_strings]\\n winning_teams.append(winning_team_strings[0])\\n except AttributeError:\\n pass\\n\\n for link in game.find_all(href=re.compile(\\\"boxscores\\\")):\\n game_link.append(base_url + link.get('href'))\\n\\n\\n game_urls = dict(zip(losing_teams, game_link))\\n game_urls.update(dict(zip(winning_teams, game_link)))\\n\\n return game_urls\",\n \"def get_newest_status():\\n TrackedSite.objects.monitor_sites()\",\n \"def weekly_min_paid_violations(self):\\n return self._weekly_min_paid_violations\",\n \"def test_week_in_range(self):\\n weeks = list(range(1, 54))\\n seq = 21\\n for week in weeks:\\n with self.subTest(week=week):\\n result = star_barcode.construct_postscript(\\n week=week,\\n bwipp_location=self.bwipp,\\n issn=self.issn,\\n sequence=seq,\\n header_line=''\\n )\\n self.assertGreater(\\n result.find(f'{self.issn} {seq:02} {week:02}'),\\n -1\\n )\",\n \"def weekNumber(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def top_lovers_and_lovees(utc_week_start, dept=None, office=None, limit=20):\\n sent_query = LoveCount.query(LoveCount.week_start == utc_week_start)\\n if dept:\\n sent_query = sent_query.filter(LoveCount.department == dept)\\n\\n if office:\\n sent_query = sent_query.filter(LoveCount.office == office)\\n\\n sent = sent_query.order(-LoveCount.sent_count).fetch()\\n lovers = []\\n for c in sent:\\n if len(lovers) == limit:\\n break\\n if c.sent_count == 0:\\n continue\\n employee_key = c.key.parent()\\n\\n lovers.append((employee_key, c.sent_count))\\n\\n received = sorted(sent, key=lambda c: c.received_count, reverse=True)\\n lovees = []\\n for c in received:\\n if len(lovees) == limit:\\n break\\n if c.received_count == 0:\\n continue\\n employee_key = c.key.parent()\\n\\n lovees.append((employee_key, c.received_count))\\n\\n return (lovers, lovees)\",\n \"def get_calendar_items(self, take=5):\\n url = 'https://www.rova.nl/api/waste-calendar/upcoming'\\n # request data from rova API and save response first 5 items (default)\\n response = requests.get(url, params={\\n 'postalcode': self.zip_code,\\n 'houseNumber': self.house_number,\\n 'addition': self.house_addition,\\n 'take': take,\\n })\\n\\n response.raise_for_status()\\n\\n rova_response = response.json()\\n\\n items = []\\n types = []\\n # add next pickup date for each garbage type\\n for item in rova_response:\\n date = datetime.strptime(item[\\\"date\\\"], \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n date = date.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\")\\n garbage_type = item[\\\"garbageTypeCode\\\"].upper()\\n\\n items.append({\\n 'GarbageTypeCode': garbage_type,\\n 'Date': date\\n })\\n types.append(garbage_type)\\n return items\",\n \"def get_week_prediction(classifier, shift_ratios, needs, remove_ratios, remove_needs,\\n max_scale_value):\\n days_of_week = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday']\\n predictions = {}\\n for day in days_of_week:\\n prediction = get_day_of_week_shift_prediction(\\n classifier, day, shift_ratios, needs, remove_ratios, remove_needs, max_scale_value\\n )\\n predictions[day] = prediction\\n\\n return predictions\",\n \"def test_get_top_doesnt_return_hidden_apps(self):\\r\\n\\r\\n ranked_3_app = self.create_app_with_contributors(8, 0, name='three')\\r\\n ranked_2_app = self.create_app_with_contributors(9, 0, name='two')\\r\\n ranked_1_app = self.create_app_with_contributors(10, 0, name='one')\\r\\n hidden_app = self.create_app_with_contributors(11, 0, name='hidden')\\r\\n hidden_app.hidden = 1\\r\\n db.session.add(hidden_app)\\r\\n db.session.commit()\\r\\n\\r\\n top_apps = cached_apps.get_top()\\r\\n\\r\\n assert len(top_apps) is 3, len(top_apps)\\r\\n for app in top_apps:\\r\\n assert app['name'] != 'hidden', app['name']\",\n \"def getMaxAddressOfUndefinedRange(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address) -> ghidra.program.model.address.Address:\\n ...\",\n \"def get_last_five_sales_entries():\\n sales_worksheet = SHEET.worksheet('sales')\\n list_of_last_fives = []\\n for num in range(1, 7):\\n col = sales_worksheet.col_values(num)\\n last_five = col[-5:]\\n list_of_last_fives.append(last_five)\\n\\n return list_of_last_fives\",\n \"def numPostings(years):\\n\\tcount = []\\n\\tfor year in years:\\n\\t\\tfilename = \\\"SmartEnergy\\\" +str(year) +\\\".xlsx\\\"\\n\\t\\tDB = pd.read_excel(filename, sheet_name = 'Filters')\\n\\t\\tcount.append(DB.iloc[10][1])\\n\\treturn count\",\n \"def formatAddress():\\n # Strings to load data\\n stringFile = '/Users/Louis/Documents/Research/Code/cleanedData/'\\n days = {'cleaned01-Dec-2015':2,# tuesday\\n 'cleaned02-Dec-2015':3,# wednesday\\n 'cleaned03-Dec-2015':4,# ...\\n 'cleaned04-Dec-2015':5,\\n 'cleaned07-Dec-2015':1,\\n 'cleaned08-Dec-2015':2,\\n 'cleaned09-Dec-2015':3,\\n 'cleaned10-Dec-2015':4,\\n 'cleaned11-Dec-2015':5,\\n 'cleaned14-Dec-2015':1,\\n 'cleaned15-Dec-2015':2,\\n 'cleaned16-Dec-2015':3,\\n 'cleaned17-Dec-2015':4,\\n 'cleaned18-Dec-2015':5,\\n 'cleaned21-Dec-2015':1}\\n \\n # Store results\\n addresses = []\\n CourierSuppliedAddresses = []\\n \\n for day in days.keys():\\n # Configuration for CSV reading\\n with open(stringFile+day+'_modified.csv') as csvfile:\\n # Dictionary containing the info\\n reader = csv.DictReader(csvfile,delimiter = ',')\\n # print(day)\\n \\n for row in reader:\\n addresses.append(row['Address'])\\n CourierSuppliedAddresses.append(row['CourierSuppliedAddress'])\\n \\n addresses = list(set(addresses))\\n addresses.sort()\\n \\n CourierSuppliedAddresses = list(set(CourierSuppliedAddresses))\\n CourierSuppliedAddresses.sort()\\n return addresses, CourierSuppliedAddresses\",\n \"def get_top(self):\\n elements = self.S.get_maximal_elements()\\n data = {}\\n alot = Nat().get_top()\\n for e in elements:\\n data[e] = alot\\n return Multiset(data, self.S)\",\n \"def upcoming(self):\\n return self.filter(start__gte=timezone.now())\",\n \"def get_top_answers(self, N):\\n return sorted(\\n self.answers.iteritems(), key=operator.itemgetter(1),\\n reverse=True)[:N]\",\n \"def get_all_top(self):\\n return self.execute(TABELLE['top']['select']['all'])\",\n \"def get_week():\\n now = dt.now().date()\\n return Week.objects.filter(date__lte=now).order_by('-date').first()\",\n \"def get_top_public_momends(max_count):\\n _obj = Momend.objects.filter(privacy=Momend.PRIVACY_CHOICES['Public']).order_by('create_date').reverse()\\n\\n return _obj if (_obj.count() < max_count) else _obj[_obj.count() - max_count:]\",\n \"def weekly_viewed(df):\\n df = convert_to_datetime(df)\\n today = datetime.date.today()\\n this_week_start = today - timedelta(days=7)\\n last_week_start = today - timedelta(days=14)\\n week_per_min = []\\n lastweek_per_min = []\\n thisweek_viewed = []\\n lastweek_viewed = []\\n for index, row in df.iterrows():\\n if row['session_start'].date() >= this_week_start:\\n per_min = get_cards_per_min(row)\\n week_per_min.append(per_min)\\n thisweek_viewed.append(row['total_looked_at'])\\n if last_week_start <= row['session_start'].date() < this_week_start:\\n per_min = get_cards_per_min(row)\\n lastweek_per_min.append(per_min)\\n lastweek_viewed.append(row['total_looked_at'])\\n week_viewed_result = total_viewed(thisweek_viewed, lastweek_viewed)\\n week_viewed_result['total_viewed_weekly'] = week_viewed_result.pop('total_viewed')\\n\\n return week_viewed_result\",\n \"def ordered_result(self):\\n cc = Counter(self._counter)\\n return cc.most_common(self._qtd) #qtd is a cli arg used on --top-ips <number>\",\n \"def addresses(self):\\n if 'Ward Matters' in self.topics or 'City Matters' in self.topics:\\n stname_pattern = \\\"(\\\\S*[a-z]\\\\S*\\\\s){1,4}?\\\"\\n sttype_pattern = \\\"(ave|blvd|cres|ct|dr|hwy|ln|pkwy|pl|plz|rd|row|sq|st|ter|way)\\\"\\n st_pattern = stname_pattern + sttype_pattern\\n\\n addr_pattern = \\\"(\\\\d(\\\\d|-)*\\\\s%s)\\\" %st_pattern\\n intersec_pattern = exp = \\\"((?<=\\\\sat\\\\s)%s\\\\s?and\\\\s?%s)\\\" %(st_pattern, st_pattern)\\n\\n pattern = \\\"(%s|%s)\\\" %(addr_pattern, intersec_pattern)\\n\\n matches = re.findall(pattern, self.description, re.IGNORECASE)\\n\\n addresses = [m[0] for m in matches]\\n return addresses\\n\\n return []\",\n \"def top10(self) -> List[Word]:\\n return self._top10\",\n \"def build_population(self, fronts):\\n population = []\\n\\n for front in fronts:\\n if len(population) + len(front) > self.pop_size:\\n front.sort(reverse=True)\\n fill_count = self.pop_size - len(front)\\n population += front[:fill_count]\\n break\\n\\n population += front\\n\\n return population\",\n \"def Margin(model, pool, addn):\\n\\n # Get probability distribution over labels and sort for each x\\n pool_p = np.sort(model.predict_proba(pool), axis = 1)\\n\\n # Calulate difference between two highes label probabilities\\n Margin = np.argsort(pool_p[:,-1] - pool_p[:,-2])\\n\\n # Choses the addn observations with lowest margin\\n x_star = Margin[:addn]\\n return x_star\",\n \"def query_serp(query:str, site:str, dates:list, num_results:int, paper_name:str) -> list:\\n all_sites = []\\n total_sites_count = 0\\n\\n for d in dates:\\n try:\\n # Get query dict and params dict\\n query_r, params = make_params(query=query, site=site, date_start=d[0], date_end=d[1],\\n num_results=num_results, paper=paper_name)\\n # serpAPI query\\n client = GoogleSearchResults(params)\\n results = client.get_dict()\\n news_results = results['news_results']\\n\\n count = 0\\n sites_date = []\\n # Loop through till end of search results or error encountered\\n while (news_results and len(news_results)>0) or ('error' not in results):\\n sites = [news['link'] for news in news_results]\\n sites_date.extend(sites)\\n count+=len(sites)\\n\\n params['start'] = count\\n client = GoogleSearchResults(params)\\n results = client.get_dict()\\n news_results = results['news_results']\\n\\n print('Date Range: {}-{}\\\\tTotal Sites: {}'.format(d[0],d[1],len(sites_date)))\\n\\n # add list of sites to query dict\\n query_r['sites'] = sites_date\\n all_sites.append(query_r)\\n total_sites_count += len(sites_date)\\n except Exception as e:\\n print(e)\\n print(d)\\n continue\\n print('Total Sites: {}'.format(total_sites_count))\\n return all_sites\",\n \"def get_five_latest(self):\\r\\n selection = []\\r\\n sorted(self.tweets, key=lambda tweet: tweet.date, reverse=True)\\r\\n amount = 5\\r\\n if self.get_length() < 5:\\r\\n amount = self.get_length()\\r\\n for i in range(amount):\\r\\n selection.append(self.tweets[i])\\r\\n return selection\",\n \"def getTopStories(self):\\n source = self.getSource(\\\"http://news.ycombinator.com\\\")\\n stories = self.getStories(source)\\n return stories\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5992419","0.5827104","0.5596639","0.5556763","0.5274141","0.52575624","0.51689905","0.5167692","0.5102182","0.5079598","0.50520396","0.5037802","0.49485672","0.4947178","0.49291557","0.49205166","0.49199647","0.4886885","0.48541108","0.48188907","0.4788528","0.47664967","0.47495085","0.4745179","0.47360948","0.47360948","0.46742812","0.46626243","0.46430853","0.4639324","0.46367803","0.46363232","0.46310487","0.46298602","0.46213397","0.46021023","0.460104","0.4600159","0.4598495","0.45952132","0.45838138","0.45646352","0.45641214","0.45551056","0.45550585","0.4553165","0.4543135","0.4518296","0.45177573","0.45100522","0.44984263","0.44980773","0.44976896","0.44864282","0.44816947","0.44775653","0.4474917","0.4467901","0.44637707","0.4459267","0.44549832","0.44530484","0.44497404","0.44456938","0.44416732","0.4441585","0.4440447","0.44384432","0.4435271","0.44352219","0.44250435","0.44158968","0.44087487","0.44062003","0.4405129","0.4401051","0.44006667","0.4395885","0.43953338","0.43945256","0.43930843","0.439137","0.43894008","0.4387412","0.43800798","0.43756905","0.43754846","0.4369683","0.43611315","0.43582678","0.43558758","0.43529978","0.43492463","0.43491754","0.43470505","0.43457997","0.43437284","0.43273067","0.43258867","0.43211025"],"string":"[\n \"0.5992419\",\n \"0.5827104\",\n \"0.5596639\",\n \"0.5556763\",\n \"0.5274141\",\n \"0.52575624\",\n \"0.51689905\",\n \"0.5167692\",\n \"0.5102182\",\n \"0.5079598\",\n \"0.50520396\",\n \"0.5037802\",\n \"0.49485672\",\n \"0.4947178\",\n \"0.49291557\",\n \"0.49205166\",\n \"0.49199647\",\n \"0.4886885\",\n \"0.48541108\",\n \"0.48188907\",\n \"0.4788528\",\n \"0.47664967\",\n \"0.47495085\",\n \"0.4745179\",\n \"0.47360948\",\n \"0.47360948\",\n \"0.46742812\",\n \"0.46626243\",\n \"0.46430853\",\n \"0.4639324\",\n \"0.46367803\",\n \"0.46363232\",\n \"0.46310487\",\n \"0.46298602\",\n \"0.46213397\",\n \"0.46021023\",\n \"0.460104\",\n \"0.4600159\",\n \"0.4598495\",\n \"0.45952132\",\n \"0.45838138\",\n \"0.45646352\",\n \"0.45641214\",\n \"0.45551056\",\n \"0.45550585\",\n \"0.4553165\",\n \"0.4543135\",\n \"0.4518296\",\n \"0.45177573\",\n \"0.45100522\",\n \"0.44984263\",\n \"0.44980773\",\n \"0.44976896\",\n \"0.44864282\",\n \"0.44816947\",\n \"0.44775653\",\n \"0.4474917\",\n \"0.4467901\",\n \"0.44637707\",\n \"0.4459267\",\n \"0.44549832\",\n \"0.44530484\",\n \"0.44497404\",\n \"0.44456938\",\n \"0.44416732\",\n \"0.4441585\",\n \"0.4440447\",\n \"0.44384432\",\n \"0.4435271\",\n \"0.44352219\",\n \"0.44250435\",\n \"0.44158968\",\n \"0.44087487\",\n \"0.44062003\",\n \"0.4405129\",\n \"0.4401051\",\n \"0.44006667\",\n \"0.4395885\",\n \"0.43953338\",\n \"0.43945256\",\n \"0.43930843\",\n \"0.439137\",\n \"0.43894008\",\n \"0.4387412\",\n \"0.43800798\",\n \"0.43756905\",\n \"0.43754846\",\n \"0.4369683\",\n \"0.43611315\",\n \"0.43582678\",\n \"0.43558758\",\n \"0.43529978\",\n \"0.43492463\",\n \"0.43491754\",\n \"0.43470505\",\n \"0.43457997\",\n \"0.43437284\",\n \"0.43273067\",\n \"0.43258867\",\n \"0.43211025\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5099575"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":84695,"cells":{"query":{"kind":"string","value":"Returns a dictionary that shows wallet address as a key and the request of unstaked amount by that address as a value."},"document":{"kind":"string","value":"def getUserUnstakeInfo(self) -> list:\n unstake_info_list =[]\n for items in self._linked_list_var:\n unstake_info_list.append([items[1],items[2]])\n return unstake_info_list"},"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 address_transactions_unspent(self, address):\n res = r.get(self.url + self.address_unspent + str(address))\n return self.execute(res)","def address_transactions_unconfirmed(self, address):\n res = r.get(self.url + self.address_unconfirmed + str(address))\n return self.execute(res)","def address_details(self, address: str) -> dict:\n \n address_details_url = self.network + bf_address_url + address + bf_address_details_url\n \n response = query_blockfrost(address_details_url, self.api_key, self.proxies)\n \n return response","def split_amount(amount, shares, last_address):\n\n total_shares = sum(shares.values())\n\n # calculating amounts, int always rounds down:\n amounts = {\n address: share * amount // total_shares\n for address, share in shares.items() if address != last_address\n }\n\n # dust goes to the last_address:\n accumulated_amount = sum(amounts.values())\n amounts[last_address] = amount - accumulated_amount\n\n # removing 0-operations:\n amounts = {\n address: amount for address, amount in amounts.items()\n if amount > 0\n }\n\n return amounts","def get_Ethereum_info(wallet: str, info: dict):\r\n\tresp = requests.get('https://api.blockcypher.com/v1/eth/main/addrs/' + wallet)\r\n\tif resp.status_code == 200:\r\n\t\tresponse = json.loads(resp.text)\r\n\t\tinfo['received'] = response['total_received'] / 10**18\r\n\t\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Ethereum']\r\n\t\tinfo['updated'] = datetime.datetime.now().isoformat()\r\n\treturn info","def get_address_balance(litecoinaddress):\n total_balance = 0\n unspent = list_unspent(litecoinaddress)\n for block in unspent:\n total_balance += float(block[\"amount\"])\n\n return total_balance","def address_info(self, address: str) -> dict:\n \n address_info_url = self.network + bf_address_url + address\n \n response = query_blockfrost(address_info_url, self.api_key, self.proxies)\n \n return response","def get_balance(self, address):\n balance = 0\n for block in self.chain:\n for t in block['transactions']:\n if t['recipient'] == address:\n balance += t['amount']\n elif t['sender'] == address:\n balance -= t['amount']\n return balance","def transaction_base() -> Dict[str, Any]:\n return {\n \"first_name\": \"Donald\",\n \"last_name\": \"Duck\",\n \"company\": \"Duck Co\",\n \"email\": \"donald.duck@duckburg.inv\",\n \"telephone\": \"991234567\",\n \"mobile\": \"+358991234567\",\n \"street\": \"1313 Webfoot Walk\",\n \"postal_code\": \"00000\",\n \"city\": \"Duckburg\",\n \"country\": \"US\",\n \"information\": \"Quack, damn you!\",\n \"items\": [],\n }","def show_address_balances(self):\n\t\tret = []\n\t\tfor acct in self.wallet:\n\t\t\tutxos = get_unspent(acct[\"address\"], self.testnet)\n\t\t\tif len(utxos) != 0:\n\t\t\t\tbalance = sum(i['value'] for i in utxos)\n\t\t\t\tret.append(f\"Address {acct['address']} BTC: {str(balance/100000000.0)}\")\n\t\treturn ret","def list_unspent(litecoinaddress, min_conf=1, max_conf=99999999):\n min_conf = str(min_conf)\n max_conf = str(max_conf)\n a = [litecoinaddress]\n try:\n stdout = subprocess.check_output([\"litecoin-cli\", \"listunspent\", min_conf, max_conf, json.dumps(a)])\n unspent = json.loads(stdout.decode())\n except:\n sys.exit(1)\n \n return unspent","def as_dict(self):\n return {key: value for key,value in self.address.items()}","def derive_wallets(self, mnemonic, coin, number_keys=10):\n command = f'derive -g --mnemonic=\"{mnemonic}\" --coin={coin} --numderive={number_keys} --cols=path,address,privkey,pubkey --format=json'\n\n p = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)\n output, err = p.communicate()\n p_status = p.wait()\n\n keys = json.loads(output)\n return keys","def do_getaddress(self,args):\n ppdict(bitstamp.get_depositaddress())","def transaction():\n data = jsonpickle.decode(request.get_data())\n address = data[\"address\"]\n amount = int(data[\"amount\"])\n keyname = data[\"keyname\"]\n\n pkplus, pkminus = wallet.keys(keyname)\n\n my_balance = p2p.query(\"/balance\", address=pkplus)[\"balance\"]\n if my_balance < amount:\n abort(404, description=\"Not enough funds.\")\n\n my_utxo = p2p.query(\"/find-utxos\", address=pkplus, amount=amount)[\"utxos\"]\n rem = sum(utxo.amount for utxo in my_utxo) - amount\n address_amount = [(address, amount)]\n\n assert rem >= 0\n\n if rem > 0:\n address_amount.append((pkplus, rem))\n\n tx = build_transaction(my_utxo, address_amount, pkminus)\n try:\n p2p.broadcast(\"/transaction-pool\", transaction=tx)\n return SUCCESSFUL_PATCH\n except UnsuccessfulPatch:\n payload = jsonpickle.encode(\n {\"message\": \"Transaction wasn't accepted by the network.\"})\n return payload, 420, {\"ContentType\": \"application/json\"}","def getAddressOfgoods(account_address):\n\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\n function_selector = 'getAddressOfGoodFromWallet(address)',\n fee_limit=1000000000,\n call_value=0,\n parameters=[{'type': 'address', 'value':account_address}],\n issuer_address=account_address\n )\n addresses = addresses['constant_result']\n decodeH = decode_hex(addresses[0])\n decodeA= decode_abi(('uint256[]',),decodeH)\n print(\"----------------------------------------------------\")\n print(decodeA)\n return decodeA[0]","def address_utxo(self, address: str, pandas: bool=False) -> dict:\n \n address_utxo_url = self.network + bf_address_url + address + bf_address_utxo_url\n \n response = query_blockfrost(address_utxo_url, self.api_key, self.proxies)\n \n return pd.DataFrame.from_dict(response) if pandas else response","def rpc_getaddressinfo(self, address: str) -> dict:\n return self._call_command([\"getaddressinfo\", address])","def valid_address_dict():\n return dict(\n first_name=\"Test\",\n last_name=\"User\",\n street_address_1=\"1 Main St\",\n state_or_territory=\"US-MA\",\n city=\"Cambridge\",\n country=\"US\",\n postal_code=\"02139\",\n )","def address_transaction(self, address: str, pandas: bool=False) -> dict:\n \n address_transaction_url = self.network + bf_address_url + address + bf_address_transaction_url\n \n response = query_blockfrost(address_transaction_url, self.api_key, self.proxies)\n \n return pd.DataFrame.from_dict(response) if pandas else response","def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\n addr = address.lower()\n balances = self.addresses[addr] if addr in self.addresses else []\n balances.append({\n 'USDC': value_USDC,\n 'eXRD': value_eXRD,\n 'LP': value_LP\n })\n self.addresses[addr] = balances","def get_balances_chain(addresses):\r\n print(\"* Using chain.so to query {} addresses - one at a time\".format(len(addresses))) # NOQA\r\n\r\n CHAINS_BALANCE_ENDPOINT = \"https://chain.so/api/v2/get_address_balance/BTC/{address}\" # NOQA\r\n balances = {}\r\n i = 0\r\n for addr in addresses:\r\n i += 1\r\n response = requests.get(CHAINS_BALANCE_ENDPOINT.format(address=addr))\r\n if response.status_code != 200:\r\n print(\"** Chain sent bad server reponse: \", response.status_code)\r\n print(\"** Query number: \", i)\r\n return None\r\n\r\n data = response.json()\r\n if data[\"status\"] != \"success\":\r\n print(\"** Chain sent bad data reponse: \", data[\"status\"])\r\n return None\r\n\r\n balances[data[\"data\"][\"address\"]] = \\\r\n data[\"data\"][\"confirmed_balance\"] + \\\r\n data[\"data\"][\"unconfirmed_balance\"]\r\n\r\n # 0.2 is 5 reqs/second. Using 0.3 just in case.\r\n time.sleep(0.3)\r\n\r\n return balances","def reputation_transfer(s_key, source_btc_address, destination_btc_address, amount, outside_btc_address=None, outside_amount=None, fee=0, used_txs=None):\n\n # Get both public and private key in their hex representation\n private_key_hex = tools.get_priv_key_hex(s_key)\n\n # Check the unspent bitcoins from that address\n unspent_transactions = blockr_unspent(source_btc_address, 'testnet')\n\n # update the used transactions (but still not verified)\n # ToDo Fix this. used_tx should be stored persistently in order to look for them the next time (the program execution could be ended and no reference to it will be found).\n if used_txs is not None:\n for used_tx in used_txs:\n if used_tx in unspent_transactions:\n unspent_transactions.remove(used_tx)\n else:\n used_txs.remove(used_tx)\n\n else:\n used_txs = []\n\n necessary_amount, total_btc = tools.get_necessary_amount(unspent_transactions, amount + fee, 'small')\n\n # Build the output of the payment\n if total_btc is not 0:\n # Transfers all the balance except for the transaction fees\n if total_btc == amount + fee:\n outs = [{'value': total_btc - fee, 'address': destination_btc_address}]\n # Transfers an specific amount to the destination address, the remainder (except for the fees) is returned to the source address\n elif outside_btc_address is None or outside_amount is None:\n outs = [{'value': amount, 'address': destination_btc_address}, {'value': total_btc - amount - fee, 'address': source_btc_address}]\n # Transfers an specific amount to a destination address, and the rest (except for the fees) is sent to an outside address\n else:\n outs = [{'value': total_btc - outside_amount, 'address': destination_btc_address}, {'value': outside_amount - fee, 'address': outside_btc_address}]\n\n # Build the transaction\n tx = mktx(necessary_amount, outs)\n\n # Sign it\n for i in range(len(necessary_amount)):\n tx = sign(tx, i, private_key_hex)\n\n if fee is not 0:\n # ToDo: Change this once the problems with the blockr API has been solved\n code, reason, tx_hash = push_tx(tx, fee=True)\n # tx_hash = local_push(tx)\n else:\n code, reason, tx_hash = push_tx(tx)\n\n if code in [200, 201]:\n used_txs.extend(necessary_amount)\n else:\n tx_hash = None\n\n return tx_hash, used_txs","def addresses_with_unspent_outputs(self):\n return self._call_account_method(\n 'addressesWithUnspentOutputs'\n )","def dumpprivkey(self, address):\n return self.proxy.dumpprivkey(address)","def get_tx_info(tx):\n\n input_addresses = []\n output_addresses = []\n payments = []\n\n try:\n response = json.loads(make_request('http://tbtc.blockr.io/api/v1/tx/info/' + tx))\n except Exception as e:\n status = json.loads(e.message).get('status')\n if status in ['error', 'fail']:\n return {'from': None, 'to': None, 'amount': None, 'confirmations': 0}\n\n vins = response.get('data').get('vins')\n vouts = response.get('data').get('vouts')\n confirmations = response.get('data').get('confirmations')\n\n for i in range(len(vins)):\n if vins[i].get('address') not in input_addresses:\n input_addresses.append(vins[i].get('address'))\n for i in range(len(vouts)):\n output_addresses.append(vouts[i].get('address'))\n payments.append(vouts[i].get('amount'))\n\n return {'from': input_addresses, 'to': output_addresses, 'amount': payments, 'confirmations': confirmations}","def getRestaurantAddressDict(restaurants):\n addressdict = {}\n for rest in restaurants:\n if 'address' in rest:\n addressstring = str(rest['address']) + ' ' + str(rest['city'])\n addressdict[addressstring] = rest['name']\n\n return addressdict","def cryptocurrency_withdrawal_request(self, walletId, currency, amount, address):\n return","def balance_of_address(self, address):\n balance = 0\n for block in self.chain:\n for transaction in block.transactions:\n if transaction.walletoffrom == address:\n balance -= transaction.amount\n\n if transaction.walletofto == address:\n balance += transaction.amount\n return balance","def address_transactions(self, address):\n res = r.get(self.url + self.address_tx + str(address))\n return self.execute(res)","def address_dict(self):\n new_table = {}\n for record in self._table:\n address = self.build_address(record)\n new_table[address] = record\n return new_table","def get_Dogecoin_info(wallet: str, info: dict):\r\n\tresp = requests.get('https://dogechain.info/api/v1/address/received/' + wallet)\r\n\tif resp.status_code == 200:\r\n\t\tresponse = json.loads(resp.text)\r\n\t\tif response['success'] == 1:\r\n\t\t\tinfo['received'] = float(response['received'])\r\n\t\t\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Dogecoin']\r\n\t\t\tinfo['updated'] = datetime.datetime.now().isoformat()\r\n\treturn info","def get_addr_value(tx):\n\t# initialize lists\n\tin_addr, in_value, out_addr, out_value = [], [], [], []\n\t# for each input transaction\n\tfor input in tx[\"inputs\"]:\n\t\t# if sending address exists\n\t\t# (otherwise coin base or empty value)\n\t\tif \"prev_out\" in input.keys() and \"addr\" in input[\"prev_out\"].keys():\n\t\t\t# record address and value\n\t\t\tin_addr.append(input[\"prev_out\"][\"addr\"])\n\t\t\tin_value.append(input[\"prev_out\"][\"value\"])\n\t# for each output transaction\n\tfor output in tx[\"out\"]:\n\t\t# if receiving address exists\n\t\t# (otherwise empty value)\n\t\tif \"addr\" in output.keys():\n\t\t\t# record address and value\n\t\t\tout_addr.append(output[\"addr\"])\n\t\t\tout_value.append(output[\"value\"])\n\t# handle duplicate addresses\n\tin_addr, in_value = handle_duplicates(in_addr, in_value)\n\tout_addr, out_value = handle_duplicates(out_addr, out_value)\n\treturn in_addr, in_value, out_addr, out_value","def getBtcInWallet(address):\n btc = 'https://blockchain.info/q/addressbalance/' + address\n check = requests.get(btc)\n value = int((check.content)) / 100000000.0\n return value","def get_balances_blockonomics(addresses):\r\n print(\"* Using blockonomics.co to query {} addresses\".format(len(addresses))) # NOQA\r\n BLOCKONOMICS_BALANCE_ENDPOINT = \"https://www.blockonomics.co/api/balance\"\r\n addrs = \" \".join(addresses)\r\n response = requests.post(BLOCKONOMICS_BALANCE_ENDPOINT,\r\n json={\"addr\": addrs})\r\n if response.status_code != 200:\r\n print(\"** blockonomics sent bad server reponse: \",\r\n response.status_code)\r\n return None\r\n\r\n balances = {}\r\n data = response.json()\r\n for each in data[\"response\"]:\r\n balances[each[\"addr\"]] = each[\"confirmed\"] + each[\"unconfirmed\"]\r\n\r\n return balances","def balance():\n address = request.args.get(\"address\")\n balance = p2p.query(\"/balance\", address=address)[\"balance\"]\n payload = jsonpickle.encode({\"balance\": balance})\n return payload, 200, {\"Content-Type\": \"application/json\"}","def check_for_funding(self, address):\n\n outpoints = []\n for i in range(len(self.tx.vout)):\n addr = CIoncoinAddress.from_scriptPubKey(self.tx.vout[i].scriptPubKey)\n if str(addr) == address:\n o = {\n \"txid\": b2lx(self.tx.GetHash()),\n \"vout\": i,\n \"value\": self.tx.vout[i].nValue,\n \"scriptPubKey\": self.tx.vout[i].scriptPubKey.encode(\"hex\")\n }\n outpoints.append(o)\n return outpoints if len(outpoints) > 0 else None","def get_Bitcoin_info(wallet: str, info: dict):\r\n\tresp = requests.get('https://blockchain.info/q/getreceivedbyaddress/' + wallet)\r\n\tif resp.status_code == 200:\r\n\t\tinfo['received'] = int(resp.text) / 10**8\r\n\t\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Bitcoin']\r\n\t\tinfo['updated'] = datetime.datetime.now().isoformat()\r\n\treturn info","def deposit_address(self):\n response = self.query('deposit_address')\n return response","def total_donated():\r\n url = \"http://blockchain.info/rawaddr/1RvRE1XPTboTfujU9dRK9euC6TPnGHzKf?limit=0\" # pylint:disable=C0301\r\n try:\r\n response = json.load(urllib2.urlopen(url))\r\n except urllib2.HTTPError:\r\n return abort(500)\r\n return jsonify(total_received=response['total_received'])","def address(self):\n out = {'zip_code': '',\n 'city': '',\n 'street': '',\n 'phone': ''}\n if self.user.contract_member.exists():\n last_contract = self.user.contract_member.last()\n out['zip_code'] = last_contract.zip_code\n out['city'] = last_contract.city\n out['street'] = last_contract.street\n out['phone'] = last_contract.phone\n\n return out","def walletinfo(test_unlock):\n stm = shared_morphene_instance()\n if mph.rpc is not None:\n mph.rpc.rpcconnect() \n t = PrettyTable([\"Key\", \"Value\"])\n t.align = \"l\"\n t.add_row([\"created\", mph.wallet.created()])\n t.add_row([\"locked\", mph.wallet.locked()])\n t.add_row([\"Number of stored keys\", len(mph.wallet.getPublicKeys())])\n t.add_row([\"sql-file\", mph.wallet.keyStorage.sqlDataBaseFile])\n password_storage = mph.config[\"password_storage\"]\n t.add_row([\"password_storage\", password_storage])\n password = os.environ.get(\"UNLOCK\")\n if password is not None:\n t.add_row([\"UNLOCK env set\", \"yes\"])\n else:\n t.add_row([\"UNLOCK env set\", \"no\"])\n if KEYRING_AVAILABLE:\n t.add_row([\"keyring installed\", \"yes\"])\n else:\n t.add_row([\"keyring installed\", \"no\"])\n if test_unlock:\n if unlock_wallet(stm):\n t.add_row([\"Wallet unlock\", \"successful\"])\n else:\n t.add_row([\"Wallet unlock\", \"not working\"])\n # t.add_row([\"getPublicKeys\", str(mph.wallet.getPublicKeys())])\n print(t)","def __process_address(self, address: Tuple[int, int, int, int, int]) -> Dict[str, int]:\n return {\n 'interface': address[0],\n 'protocol': address[1],\n 'type': address[2],\n 'hardware_type': address[3],\n 'address': address[4],\n }","def compute_helper_mempool_dictionaries():\n txn_density_dict = {}\n txn_parents_dict = {}\n txn_size_dict = {}\n mempool_data = parse_mempool_csv()\n for elem in mempool_data:\n size = elem.weight/MAXIMUM_BLOCK_WEIGHT # weight mapped to (0,1)\n txn_size_dict[elem.txid] = size \n txn_density_dict[elem.txid] = elem.fee/size\n if elem.parents != '':\n txn_parents_dict[elem.txid] = elem.parents.strip().split(';')\n return txn_density_dict,txn_parents_dict,txn_size_dict","def get_wallet_info(wallet: str, info: dict):\r\n\t#return if updated recently\r\n\tif 'updated' in info:\r\n\t\tif datetime.datetime.fromisoformat(info['updated']) + datetime.timedelta(days = UPDATE_INTERVAL) > datetime.datetime.now():\r\n\t\t\treturn info\r\n\r\n\t#get the amount of money received to the wallet\r\n\t#these wallets won't have collisions in tags, so it is save to overwrite old amounts\r\n\tapi_delay(info['currency'][0])\r\n\tif 'Bitcoin' in info['currency']:\r\n\t\tget_price('Bitcoin')\r\n\t\tinfo = get_Bitcoin_info(wallet, info)\r\n\tif 'Ethereum' in info['currency']:\r\n\t\tget_price('Ethereum')\r\n\t\tinfo = get_Ethereum_info(wallet, info)\r\n\tif 'Dogecoin' in info['currency']:\r\n\t\tget_price('Dogecoin')\r\n\t\tinfo = get_Dogecoin_info(wallet, info)\r\n\tif 'ReddCoin' in info['currency']:\r\n\t\tget_price('ReddCoin')\r\n\t\tinfo = get_ReddCoin_info(wallet, info)\r\n\treturn info","def signer_address(private_key):\n return get_ethereum_address_from_private_key(private_key)","def get_balances_bitcoind(addresses, username, password,\r\n url=\"http://127.0.0.1\", port=8332):\r\n print(\"* Using bitcoind to query {} addresses\".format(len(addresses)))\r\n balances = {}\r\n balances_list = []\r\n url = url + \":\" + str(port)\r\n headers = {'content-type': 'application/json'}\r\n\r\n # Making separate requests for each address is surprisingly only a few\r\n # seconds slower (in total) than making a single request with all\r\n # addresses. # It's also easier to recover incase of a bad address from\r\n # vanitygen.\r\n def _get_balance(address):\r\n payload = {\r\n \"method\": \"getaddressbalance\",\r\n \"params\": [{\"addresses\": [address]}],\r\n \"jsonrpc\": \"2.0\",\r\n \"id\": 0,\r\n }\r\n\r\n response = requests.post(url, json=payload, headers=headers,\r\n auth=(username, password))\r\n\r\n if response.status_code != 200:\r\n return (address, 0)\r\n\r\n data = response.json()\r\n return (address, data[\"result\"][\"balance\"])\r\n\r\n pool = ThreadPool(4)\r\n balances_list = pool.map(_get_balance, addresses)\r\n pool.close()\r\n pool.join()\r\n\r\n for addr, bal in balances_list:\r\n if bal != 0:\r\n balances[addr] = bal\r\n\r\n return balances","def withdraw(self, currency, amount, address):\n return self.api_query('withdraw', {\"currency\": currency, \"amount\": amount, \"address\": address})","def get_account_balance(unspent_outputs):\n return sum(output[\"value\"] for output in unspent_outputs.values())","def test_wallets_get(self):\n pass","def get_history_from_address(address):\n \n if not exists_address_transfer_observation_from(address):\n return make_response(jsonify(build_error('No content. transactions from the address are not observed')), 204)\n \n take = request.args.get('take')\n if take is None:\n take = 0\n else:\n take = int(take)\n \n afterhash = request.args.get('afterHash')\n if afterhash is None:\n afterhash = \"\" \n \n update_index() \n items = get_transactions_from(address, take, afterhash)\n \n if 'error' in items:\n return make_response(jsonify(build_error(items['error'])), items['status'])\n\n return jsonify(items)","def get_history_to_address(address):\n \n if not exists_address_transfer_observation_to(address):\n return make_response(jsonify(build_error('No content: transactions to the address are not observed')), 204)\n \n take = request.args.get('take')\n if take is None:\n take = 0\n else:\n take = int(take)\n \n afterhash = request.args.get('afterHash'.lower())\n if afterhash is None:\n afterhash = ''\n \n update_index() \n items = get_transactions_to(address, take, afterhash)\n\n response = items if take == 0 else items[0:take]\n\n return jsonify(response)","async def mempool() -> dict:\n return {\"mempool\": chain.mempool_state()}","def withdraw_from_address(amount, network_fee, from_address, to_address):\n tx_total = amount + network_fee\n address_balance = get_address_balance(from_address)\n\n if tx_total > address_balance:\n # return not enough funds error\n print(\"Error: Not enough funds\")\n else:\n tx_hex_string = create_raw_transaction(amount, network_fee, from_address, to_address)\n signed_tx = sign_raw_transaction(tx_hex_string)\n hex_signed_tx = signed_tx[\"hex\"]\n txid = send_raw_transaction(hex_signed_tx)\n\n return txid.decode()","def withdraw(self, currency, amount, address):\n pass","def get_address_to_usb_info_dict():\n with open(os.devnull, 'w') as devnull:\n output = subprocess.check_output(MAC_COMMAND, stderr=devnull)\n output_dict = json.loads(output)\n usb_connections = output_dict[PROFILER_USB_DATA_TYPE]\n usb_info_dict = {}\n _convert_system_profiler_dict(usb_connections, usb_info_dict)\n return usb_info_dict","def unknown_address(ip_address: str) -> dict:\n address = UNKNOWN_COUNTRY.copy()\n address.update({\"remote_addr\": ip_address})\n return address","def address_balance(self, address, confirmations=0):\n address = utils.request_type(address)\n\n confs = {'confirmations': confirmations}\n if confs['confirmations'] > 0:\n res = r.get(self.url + self.balance + str(address), params=confs)\n else:\n res = r.get(self.url + self.balance + str(address))\n return self.execute(res)","def __get_account(self, address):\n\t\tfor acct in self.wallet:\n\t\t\tif acct[\"address\"] == address:\n\t\t\t\treturn acct\n\t\traise ValueError(\"The given address does not exist in the bunkr-wallet\")","def getTokens_utils(account_address, value=30000000000):\n e = {'txid':'Error!'} \n logsOfError = ''\n try:\n trigger = tron.transaction_builder.trigger_smart_contract(contract_address = TOKEN_CONTRACT,\n function_selector = 'transfer(address,uint256)', #без пробелов!\n fee_limit=1000000000,\n call_value=0,\n parameters=[{'type':'address','value':account_address},{'type': 'int256','value':value}],\n issuer_address=TOKEN_CREATOR\n )\n\n tron.private_key = TOKEN_CREATOR_PRIVATE_KEY\n transaction = trigger['transaction']\n signed1_tx = tron.trx.sign(transaction,True,False)\n e = tron.trx.broadcast(signed1_tx)\n except Exception as ex:\n logsOfError = logsOfError + str(ex)\n return {'txID':e['txid'], 'logs':logsOfError}","def __fresh_account(self):\n\t\tshuffle(self.wallet)\n\t\tfor acct in self.wallet:\n\t\t\tif len(get_spent(acct[\"address\"], self.testnet))==0 and len(get_unspent(acct[\"address\"], self.testnet))==0:\n\t\t\t\treturn acct\n\t\traise ValueError(\"No unused addresses available. Run add_accounts()\")","def dump_priv_key(litecoinaddress):\n try:\n priv_key = subprocess.check_output([\"litecoin-cli\", \"dumpprivkey\", litecoinaddress])\n except:\n sys.exit(1)\n\n return priv_key.decode().strip()","async def fetch_deposit_address(self, code: str, params={}):\n await self.load_markets()\n currency = self.currency(code)\n request = {\n 'asset': currency['id'],\n }\n response = await self.privateGetUserWithdrawalAccount(self.extend(request, params))\n data = self.safe_value(response, 'data', {})\n # Not sure about self if there could be more than one account...\n accounts = self.safe_value(data, 'accounts', [])\n firstAccount = self.safe_value(accounts, 0, {})\n address = self.safe_string(firstAccount, 'address')\n return {\n 'currency': currency,\n 'address': address,\n 'tag': None,\n 'network': None,\n 'info': response,\n }","def verbose_balance(self):\n orig_balance = self.balance\n verbose_balance = {}\n for key, val in orig_balance.items():\n acc = self.find_peer_by_pubkey(key)\n if acc is None:\n if key == self.pubkey:\n verbose_balance[self.name] = val\n else:\n verbose_balance[key] = val\n else:\n verbose_balance[acc[\"name\"]] = val\n return verbose_balance","def get_addresses_by_account(account):\n try:\n stdout = subprocess.check_output([\"litecoin-cli\", \"getaddressesbyaccount\", account])\n addresses = json.loads(stdout.decode())\n except:\n sys.exit(1)\n\n return addresses","def withdraw_crypt(self, amount, currency, address):\n response = self.query('withdraw_crypt', params=dict(amount=amount, currency=currency, address=address))\n return response","def create_raw_transaction(amount, network_fee, from_address, to_address):\n tx_total = amount + network_fee\n tx_inputs = []\n input_total = 0\n unspent = list_unspent(from_address)\n\n # Are there enough funds in one block to cover the amount\n for block in unspent:\n if float(block[\"amount\"]) >= tx_total:\n tx_input = {\"txid\": block[\"txid\"], \"vout\": int(block[\"vout\"])}\n input_total = float(block[\"amount\"])\n tx_inputs.append(tx_input)\n break\n # If tx_inputs is empty that means we have to\n # build the transaction from multiple blocks\n if not tx_inputs:\n for block in unspent:\n if input_total >= tx_total:\n break\n else:\n tx_input = {\"txid\": block[\"txid\"], \"vout\": int(block[\"vout\"])}\n input_total += float(block[\"amount\"])\n tx_inputs.append(tx_input)\n\n # Amount left over after amount to send and network fees are subtracted\n # from input_total. Change is sent back to sender\n change = round((input_total - amount) - network_fee, 8)\n \n if change < dust:\n tx_output = {to_address: amount}\n else:\n tx_output = {to_address: amount, from_address: change}\n \n try:\n tx_hex_string = subprocess.check_output([\"litecoin-cli\", \"createrawtransaction\", json.dumps(tx_inputs), json.dumps(tx_output)])\n except:\n sys.exit(1)\n\n return tx_hex_string.strip()","def get_unspent_outputs(self, crypto, address):\n raise NotImplementedError(\n \"This service does not support getting unspent outputs. \"\n \"Or rather it has no defined 'get_unspent_outputs' method.\"\n )","def get_address_revision(transaction_id, address_id) -> dict:\n address_version = version_class(Address)\n address = db.session.query(address_version) \\\n .filter(address_version.transaction_id <= transaction_id) \\\n .filter(address_version.operation_type != 2) \\\n .filter(address_version.id == address_id) \\\n .filter(or_(address_version.end_transaction_id == None, # pylint: disable=singleton-comparison # noqa: E711,E501;\n address_version.end_transaction_id > transaction_id)) \\\n .order_by(address_version.transaction_id).one_or_none()\n return address","def stake_informations(self, stake_address: str) -> dict:\n \n url_stake_info = self.network + bf_stake_url + stake_address\n \n response = query_blockfrost(url_stake_info, self.api_key, self.proxies)\n \n return response","def generate_address(self, private_key):\n words, seed = CryptoUtils.create_mnemonic_key(private_key)\n private_key_to_hex = CryptoUtils.generate_private_key(seed)\n public_key = CryptoUtils.generate_public_key(private_key_to_hex)\n public_key_compressed = CryptoUtils.compress_public_key(public_key)\n address = CryptoUtils.generate_address(public_key)\n self.addresses[address] = {\n 'owner_key': private_key,\n 'private_key': private_key_to_hex,\n 'mnemonic_words': words,\n 'public_key': public_key,\n 'public_key_compressed': public_key_compressed,\n 'balance': 0\n }","def parse_address(address: str) -> OrderedDict[str, str]:\n\n address = address.replace(\"\\n\", \", \")\n\n parsed_address, address_type = usaddress.tag(address)\n if address_type != \"Street Address\":\n logger.warning(\n f\"Couldn't parse address '{address}' of type {address_type}; best guess: {parsed_address}\"\n )\n\n # Fixup: At least one address has \"WI, USA\" in the \"StateName\" component.\n # Strip non-state components\n if parsed_address.get(\"StateName\"):\n parsed_address[\"StateName\"] = parsed_address[\"StateName\"].partition(\",\")[0]\n\n return parsed_address","def tip(sender, recipient, amount):\n\n info = {\n \"txid\" : \"None\",\n \"response\" : \"None\", #Comment reply\n \"message\" : None #Error message\n }\n\n tipper_logger.log(sender + \" is trying to send \" + recipient + \" \" + amount + \" XMR\")\n\n sender = str(sender)\n recipient = str(recipient)\n sender_rpc_n_wallet = None\n\n try:\n sender_rpc_n_wallet = SafeWallet(port=helper.ports.tip_sender_port, wallet_name=sender.lower())\n tipper_logger.log(\"Sender wallet loaded!!\")\n except Exception as e:\n sender_rpc_n_wallet.kill_rpc()\n tipper_logger.log(\"Failed to open wallets for \" + sender + \" and \" + recipient + \". Message: \")\n tipper_logger.log(e)\n info[\"response\"] = \"Could not open wallets properly! Perhaps my node is out of sync? (Try again shortly).\\n\\n^/u/OsrsNeedsF2P!!\"\n info[\"message\"] = str(e)\n return info\n\n tipper_logger.log(\"Successfully initialized wallets..\")\n\n try:\n recipient_address=helper.get_address_txt(recipient.lower())\n txs = generate_transaction(sender_wallet=sender_rpc_n_wallet.wallet, recipient_address=recipient_address, amount=amount)\n\n info[\"txid\"] = str(txs)\n info[\"response\"] = f\"Successfully tipped /u/{recipient} {amount} XMR! [^(txid)]({helper.get_xmrchain(txs)})\"\n tipper_logger.log(\"Successfully sent tip\")\n except Exception as e:\n tipper_logger.log(e)\n traceback.print_exc()\n info[\"message\"] = get_error_response(e)\n info[\"response\"] = \"Didn't tip - Check your private message to see why :)\"\n\n sender_rpc_n_wallet.kill_rpc()\n\n tipper_logger.log(\"Tip function completed without crashing\")\n\n return info","def derive_wallets2(mnemonic, coin, numderive):\n command = 'php hd-wallet-derive/hd-wallet-derive.php -g --mnemonic={mnemonic} --cols=path,address,privkey,pubkey --format=json --coin=“{coin}” --numderive= 2'\n p = subprocess.Popen(command2, stdout=subprocess.PIPE, shell=True)\n (output, err) = p.communicate()\n p_status = p.wait()\n keys = json.loads(output)\n return keys","def account_deposit_address(self, currency_symbol):\n return self.get(f'addresses/{currency_symbol}', auth=True)","def as_dict(self):\n dict_data = {\n 'first_name': self.first_name,\n 'last_name': self.last_name,\n 'email': self.email,\n 'phone': self.phone,\n 'orders_count': self.orders_count,\n 'currency': self.currency,\n }\n address_instance = Address.objects.filter(customer=self).first()\n if address_instance:\n dict_data.update({'address': address_instance.address,\n 'city': address_instance.city,\n 'country': address_instance.city,\n 'zip_code': address_instance.zip_code\n })\n return dict_data","def q_addressbalance(abe, page, chain):\n addr = wsgiref.util.shift_path_info(page['env'])\n if chain is None or addr is None:\n return 'returns amount of money at the given address\\n' \\\n '/chain/CHAIN/q/addressbalance/ADDRESS\\n'\n\n if not util.possible_address(addr):\n return 'ERROR: address invalid'\n\n version, hash = util.decode_address(addr)\n total = abe.store.get_balance(chain.id, hash)\n\n return (\"ERROR: please try again\" if total is None else\n format_satoshis(total, chain))","def to_dict(self):\n dct = self.__dict__\n dct['address'] = self.address.to_dict()\n return dct","def get_balance(address: str) -> int:\n return base.Balances(balance_of).get(address)","def get_balance(self, address):\n\n raise NotImplementedError('coming soon...')\n\n return sum(o.value for o in self.get_unspent_outputs(address)) / 100000000.0","def deposit(self, account_id: int, amount: float) -> Dict[bool, Accounts]:\n raise Exception(\"Method should be implemented\")","def test_wallets_get_transaction_list(self):\n pass","def jsonrpc_getutxos(self, addresses):\n utxos_by_addr = {}\n for address in addresses:\n pubkey = address_to_pubkey(address)\n utxo_refs = self.node.storage.utxos_for_pubkey(pubkey)\n utxos_by_addr[address] = [{\n 'txid': b2hex(ref[0]),\n 'index': ref[1],\n 'blockheight': ref[2]\n } for ref in utxo_refs]\n return utxos_by_addr","def get_balance_response(address):\n call = Address(address=address)\n response = call.get_address_info()\n if response:\n return response\n else:\n return None","def get_balances_blockchain(addresses):\r\n print(\"* blockchain.info not yet supported\")\r\n return None","async def get_locked_coins_in_spend_bundle(\n self, bundle: SpendBundle\n ) -> Dict[bytes32, WalletCoinRecord]:\n result = {}\n removals = bundle.removals()\n for coin in removals:\n coin_record = await self.wallet_state_manager.wallet_store.get_coin_record_by_coin_id(\n coin.name()\n )\n if coin_record is None:\n continue\n result[coin_record.name()] = coin_record\n return result","def test_wallets_get_list(self):\n pass","def create_tx(coin, account, recipient, amount):\n if coin ==ETH:\n gasEstimate = w3.eth.estimateGas(\n {\"from\": account.address, \"to\": recipient, \"value\": amount})\n return{\n \"to\": recipient,\n \"from\": account.address,\n \"value\": amount,\n \"gasPrice\": w3.eth.gasPrice,\n \"gas\": gasEstimate,\n \"nonce\": w3.eth.getTransactionCount(account.address)\n }\n if coin == BTCTEST:\n return PrivateKeyTestnet.prepare_transaction(account.address, [(recipient, amount, BTC)])","def _get_notary_address(from_key):\n return _hash(FAMILY_NAME.encode('utf-8'))[0:6] + \\\n _hash(from_key.encode('utf-8'))[0:64]","def removeStake(self, address: str, value_LP: int):\n addr = address.lower()\n balances = self.addresses[addr] if addr in self.addresses else []\n if len(balances) > 0:\n while len(balances) > 0 and value_LP > 0:\n balance = balances[-1]\n initial_LP = balance['LP']\n if value_LP >= initial_LP:\n del balances[-1]\n value_LP -= initial_LP\n else:\n new_LP = initial_LP - value_LP\n remaining_percent = new_LP / initial_LP if initial_LP != 0 else 1\n balance['LP'] = new_LP\n balance['USDC'] = int(balance['USDC'] * remaining_percent)\n balance['eXRD'] = int(balance['eXRD'] * remaining_percent)\n balances[-1] = balance\n value_LP = 0\n else:\n # Just log such cases - deal with them later\n balances.append({\n 'USDC': 0,\n 'eXRD': 0,\n 'LP': -value_LP\n })\n self.addresses[addr] = balances","def address_to_json(address):\n addr = {\n \"zip\": address.zip,\n \"address1\": address.address,\n \"address2\": address.unit,\n \"city\":address.city,\n \"state\": address.state\n }\n addr = {key:value for (key,value) in addr.items() if not value is None}\n return json.dumps(addr)","def calculate_debt(acc, key, value):\n if key == 'transactions':\n for amount in value:\n acc += amount \n\n return acc","def q_getreceivedbyaddress(abe, page, chain):\n addr = wsgiref.util.shift_path_info(page['env'])\n if chain is None or addr is None:\n return 'returns amount of money received by given address (not balance, sends are not subtracted)\\n' \\\n '/chain/CHAIN/q/getreceivedbyaddress/ADDRESS\\n'\n\n if not util.possible_address(addr):\n return 'ERROR: address invalid'\n\n version, hash = util.decode_address(addr)\n return format_satoshis(abe.store.get_received(chain.id, hash), chain)","def split_address(address: str, prefix=\"address_\", max_lines=5) -> dict[str, str]:\n\n # TODO ICMSLST-1692: ILB to fix addresses which are more than 5 lines\n return {\n f\"{prefix}{i}\": address_line.strip()\n for i, address_line in enumerate(address.split(\"\\n\"), start=1)\n if address_line and address_line.strip() and i <= max_lines\n }","def create_wallet(self):\n\n child = pexpect.spawn('node createKeystore', cwd='../src/')\n if commonUtil.show_logs:\n child.logfile = sys.stdout\n\n self.file_name = commonUtil.get_random_string()\n self.password = commonUtil.get_random_string()\n\n commonUtil.check_expect(\"Input file name\", child, test_name, \"'Input file name' prompt not found\")\n child.sendline(self.file_name)\n\n commonUtil.check_expect(\"Input password\", child, test_name, \"'Input password' prompt not found\")\n child.sendline(self.password)\n\n result = child.read()\n\n if result.find(\"Please check if the filename is used\") != -1:\n commonUtil.exit_test(\"file name is already present in the system\", child)\n\n if result.find(\"address\") == -1:\n commonUtil.exit_test(\"'address' title not found in wallet summary\", child)\n\n if result.find(\"waddress\") == -1:\n commonUtil.exit_test(\"waddress' title not found in wallet summary\", child)\n\n if result.find(self.file_name) == -1:\n commonUtil.exit_test(\"file name:\" + self.file_name + \" not found in wallet summary\", child)\n\n if result.find(self.password) == -1:\n commonUtil.exit_test(\"password:\" + self.password + \" not found in wallet summary\", child)\n\n address_start = result.find('0x')\n if address_start == -1:\n commonUtil.exit_test('address value starting with 0x not found in wallet summary', child)\n self.address = result[address_start:address_start + 42]\n\n waddress_start = result.find('0x', address_start + 42)\n if waddress_start == -1:\n commonUtil.exit_test('wan address value starting with 0x not found in wallet summary', child)\n self.waddress = result[waddress_start:waddress_start + 134]\n\n child.expect(pexpect.EOF)","def get_unspent_outputs(self, address):\n\n raise NotImplementedError('coming soon...')\n\n outputs = []\n for uock in self._unspent._list_unspent(address):\n\n # get the transaction for this utxo\n txck = keys.get_uock_txck(uock)\n txn = self._blocks._txns._get(txck)\n\n output_index = keys.get_uock_index(uock)\n\n # remove false positives (since the database only stores a hint)\n txio = script.Script(txn)\n if txio.output_address(output_index) == address:\n outputs.append(txn.outputs[output_index])\n\n return outputs","def prepare_raw_tx(self, mn_address, change_address, inputs, total, fee=0.00001):\n raw_tx = {mn_address: self.send_amount, change_address: total - self.send_amount - fee}\n return self.rpc.createrawtransaction(inputs, raw_tx)","def serialize(self):\n return { \n \n 'balance' : self.balance,\n 'email' : self.email,\n\n }","def payback_form_data(self):\n return {\n 'date': date.today(),\n 'who_from': 'Georgie',\n 'who_to': 'Tristan',\n 'amount': 50,\n 'currency': 'GBP',\n 'method': 'Bank_transfer'\n }","def setup_cache(self):\n if self.walletname not in cache: \n cache[self.walletname] = {\n \"raw_transactions\": {},\n \"transactions\": [],\n \"tx_count\": None,\n \"tx_changed\": True,\n \"last_block\": None,\n \"raw_tx_block_update\": {},\n \"addresses\": [],\n \"change_addresses\": [],\n \"scan_addresses\": True\n }","def dict() -> Dict[str, Pin]:"],"string":"[\n \"def address_transactions_unspent(self, address):\\n res = r.get(self.url + self.address_unspent + str(address))\\n return self.execute(res)\",\n \"def address_transactions_unconfirmed(self, address):\\n res = r.get(self.url + self.address_unconfirmed + str(address))\\n return self.execute(res)\",\n \"def address_details(self, address: str) -> dict:\\n \\n address_details_url = self.network + bf_address_url + address + bf_address_details_url\\n \\n response = query_blockfrost(address_details_url, self.api_key, self.proxies)\\n \\n return response\",\n \"def split_amount(amount, shares, last_address):\\n\\n total_shares = sum(shares.values())\\n\\n # calculating amounts, int always rounds down:\\n amounts = {\\n address: share * amount // total_shares\\n for address, share in shares.items() if address != last_address\\n }\\n\\n # dust goes to the last_address:\\n accumulated_amount = sum(amounts.values())\\n amounts[last_address] = amount - accumulated_amount\\n\\n # removing 0-operations:\\n amounts = {\\n address: amount for address, amount in amounts.items()\\n if amount > 0\\n }\\n\\n return amounts\",\n \"def get_Ethereum_info(wallet: str, info: dict):\\r\\n\\tresp = requests.get('https://api.blockcypher.com/v1/eth/main/addrs/' + wallet)\\r\\n\\tif resp.status_code == 200:\\r\\n\\t\\tresponse = json.loads(resp.text)\\r\\n\\t\\tinfo['received'] = response['total_received'] / 10**18\\r\\n\\t\\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Ethereum']\\r\\n\\t\\tinfo['updated'] = datetime.datetime.now().isoformat()\\r\\n\\treturn info\",\n \"def get_address_balance(litecoinaddress):\\n total_balance = 0\\n unspent = list_unspent(litecoinaddress)\\n for block in unspent:\\n total_balance += float(block[\\\"amount\\\"])\\n\\n return total_balance\",\n \"def address_info(self, address: str) -> dict:\\n \\n address_info_url = self.network + bf_address_url + address\\n \\n response = query_blockfrost(address_info_url, self.api_key, self.proxies)\\n \\n return response\",\n \"def get_balance(self, address):\\n balance = 0\\n for block in self.chain:\\n for t in block['transactions']:\\n if t['recipient'] == address:\\n balance += t['amount']\\n elif t['sender'] == address:\\n balance -= t['amount']\\n return balance\",\n \"def transaction_base() -> Dict[str, Any]:\\n return {\\n \\\"first_name\\\": \\\"Donald\\\",\\n \\\"last_name\\\": \\\"Duck\\\",\\n \\\"company\\\": \\\"Duck Co\\\",\\n \\\"email\\\": \\\"donald.duck@duckburg.inv\\\",\\n \\\"telephone\\\": \\\"991234567\\\",\\n \\\"mobile\\\": \\\"+358991234567\\\",\\n \\\"street\\\": \\\"1313 Webfoot Walk\\\",\\n \\\"postal_code\\\": \\\"00000\\\",\\n \\\"city\\\": \\\"Duckburg\\\",\\n \\\"country\\\": \\\"US\\\",\\n \\\"information\\\": \\\"Quack, damn you!\\\",\\n \\\"items\\\": [],\\n }\",\n \"def show_address_balances(self):\\n\\t\\tret = []\\n\\t\\tfor acct in self.wallet:\\n\\t\\t\\tutxos = get_unspent(acct[\\\"address\\\"], self.testnet)\\n\\t\\t\\tif len(utxos) != 0:\\n\\t\\t\\t\\tbalance = sum(i['value'] for i in utxos)\\n\\t\\t\\t\\tret.append(f\\\"Address {acct['address']} BTC: {str(balance/100000000.0)}\\\")\\n\\t\\treturn ret\",\n \"def list_unspent(litecoinaddress, min_conf=1, max_conf=99999999):\\n min_conf = str(min_conf)\\n max_conf = str(max_conf)\\n a = [litecoinaddress]\\n try:\\n stdout = subprocess.check_output([\\\"litecoin-cli\\\", \\\"listunspent\\\", min_conf, max_conf, json.dumps(a)])\\n unspent = json.loads(stdout.decode())\\n except:\\n sys.exit(1)\\n \\n return unspent\",\n \"def as_dict(self):\\n return {key: value for key,value in self.address.items()}\",\n \"def derive_wallets(self, mnemonic, coin, number_keys=10):\\n command = f'derive -g --mnemonic=\\\"{mnemonic}\\\" --coin={coin} --numderive={number_keys} --cols=path,address,privkey,pubkey --format=json'\\n\\n p = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)\\n output, err = p.communicate()\\n p_status = p.wait()\\n\\n keys = json.loads(output)\\n return keys\",\n \"def do_getaddress(self,args):\\n ppdict(bitstamp.get_depositaddress())\",\n \"def transaction():\\n data = jsonpickle.decode(request.get_data())\\n address = data[\\\"address\\\"]\\n amount = int(data[\\\"amount\\\"])\\n keyname = data[\\\"keyname\\\"]\\n\\n pkplus, pkminus = wallet.keys(keyname)\\n\\n my_balance = p2p.query(\\\"/balance\\\", address=pkplus)[\\\"balance\\\"]\\n if my_balance < amount:\\n abort(404, description=\\\"Not enough funds.\\\")\\n\\n my_utxo = p2p.query(\\\"/find-utxos\\\", address=pkplus, amount=amount)[\\\"utxos\\\"]\\n rem = sum(utxo.amount for utxo in my_utxo) - amount\\n address_amount = [(address, amount)]\\n\\n assert rem >= 0\\n\\n if rem > 0:\\n address_amount.append((pkplus, rem))\\n\\n tx = build_transaction(my_utxo, address_amount, pkminus)\\n try:\\n p2p.broadcast(\\\"/transaction-pool\\\", transaction=tx)\\n return SUCCESSFUL_PATCH\\n except UnsuccessfulPatch:\\n payload = jsonpickle.encode(\\n {\\\"message\\\": \\\"Transaction wasn't accepted by the network.\\\"})\\n return payload, 420, {\\\"ContentType\\\": \\\"application/json\\\"}\",\n \"def getAddressOfgoods(account_address):\\n\\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\\n function_selector = 'getAddressOfGoodFromWallet(address)',\\n fee_limit=1000000000,\\n call_value=0,\\n parameters=[{'type': 'address', 'value':account_address}],\\n issuer_address=account_address\\n )\\n addresses = addresses['constant_result']\\n decodeH = decode_hex(addresses[0])\\n decodeA= decode_abi(('uint256[]',),decodeH)\\n print(\\\"----------------------------------------------------\\\")\\n print(decodeA)\\n return decodeA[0]\",\n \"def address_utxo(self, address: str, pandas: bool=False) -> dict:\\n \\n address_utxo_url = self.network + bf_address_url + address + bf_address_utxo_url\\n \\n response = query_blockfrost(address_utxo_url, self.api_key, self.proxies)\\n \\n return pd.DataFrame.from_dict(response) if pandas else response\",\n \"def rpc_getaddressinfo(self, address: str) -> dict:\\n return self._call_command([\\\"getaddressinfo\\\", address])\",\n \"def valid_address_dict():\\n return dict(\\n first_name=\\\"Test\\\",\\n last_name=\\\"User\\\",\\n street_address_1=\\\"1 Main St\\\",\\n state_or_territory=\\\"US-MA\\\",\\n city=\\\"Cambridge\\\",\\n country=\\\"US\\\",\\n postal_code=\\\"02139\\\",\\n )\",\n \"def address_transaction(self, address: str, pandas: bool=False) -> dict:\\n \\n address_transaction_url = self.network + bf_address_url + address + bf_address_transaction_url\\n \\n response = query_blockfrost(address_transaction_url, self.api_key, self.proxies)\\n \\n return pd.DataFrame.from_dict(response) if pandas else response\",\n \"def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\\n addr = address.lower()\\n balances = self.addresses[addr] if addr in self.addresses else []\\n balances.append({\\n 'USDC': value_USDC,\\n 'eXRD': value_eXRD,\\n 'LP': value_LP\\n })\\n self.addresses[addr] = balances\",\n \"def get_balances_chain(addresses):\\r\\n print(\\\"* Using chain.so to query {} addresses - one at a time\\\".format(len(addresses))) # NOQA\\r\\n\\r\\n CHAINS_BALANCE_ENDPOINT = \\\"https://chain.so/api/v2/get_address_balance/BTC/{address}\\\" # NOQA\\r\\n balances = {}\\r\\n i = 0\\r\\n for addr in addresses:\\r\\n i += 1\\r\\n response = requests.get(CHAINS_BALANCE_ENDPOINT.format(address=addr))\\r\\n if response.status_code != 200:\\r\\n print(\\\"** Chain sent bad server reponse: \\\", response.status_code)\\r\\n print(\\\"** Query number: \\\", i)\\r\\n return None\\r\\n\\r\\n data = response.json()\\r\\n if data[\\\"status\\\"] != \\\"success\\\":\\r\\n print(\\\"** Chain sent bad data reponse: \\\", data[\\\"status\\\"])\\r\\n return None\\r\\n\\r\\n balances[data[\\\"data\\\"][\\\"address\\\"]] = \\\\\\r\\n data[\\\"data\\\"][\\\"confirmed_balance\\\"] + \\\\\\r\\n data[\\\"data\\\"][\\\"unconfirmed_balance\\\"]\\r\\n\\r\\n # 0.2 is 5 reqs/second. Using 0.3 just in case.\\r\\n time.sleep(0.3)\\r\\n\\r\\n return balances\",\n \"def reputation_transfer(s_key, source_btc_address, destination_btc_address, amount, outside_btc_address=None, outside_amount=None, fee=0, used_txs=None):\\n\\n # Get both public and private key in their hex representation\\n private_key_hex = tools.get_priv_key_hex(s_key)\\n\\n # Check the unspent bitcoins from that address\\n unspent_transactions = blockr_unspent(source_btc_address, 'testnet')\\n\\n # update the used transactions (but still not verified)\\n # ToDo Fix this. used_tx should be stored persistently in order to look for them the next time (the program execution could be ended and no reference to it will be found).\\n if used_txs is not None:\\n for used_tx in used_txs:\\n if used_tx in unspent_transactions:\\n unspent_transactions.remove(used_tx)\\n else:\\n used_txs.remove(used_tx)\\n\\n else:\\n used_txs = []\\n\\n necessary_amount, total_btc = tools.get_necessary_amount(unspent_transactions, amount + fee, 'small')\\n\\n # Build the output of the payment\\n if total_btc is not 0:\\n # Transfers all the balance except for the transaction fees\\n if total_btc == amount + fee:\\n outs = [{'value': total_btc - fee, 'address': destination_btc_address}]\\n # Transfers an specific amount to the destination address, the remainder (except for the fees) is returned to the source address\\n elif outside_btc_address is None or outside_amount is None:\\n outs = [{'value': amount, 'address': destination_btc_address}, {'value': total_btc - amount - fee, 'address': source_btc_address}]\\n # Transfers an specific amount to a destination address, and the rest (except for the fees) is sent to an outside address\\n else:\\n outs = [{'value': total_btc - outside_amount, 'address': destination_btc_address}, {'value': outside_amount - fee, 'address': outside_btc_address}]\\n\\n # Build the transaction\\n tx = mktx(necessary_amount, outs)\\n\\n # Sign it\\n for i in range(len(necessary_amount)):\\n tx = sign(tx, i, private_key_hex)\\n\\n if fee is not 0:\\n # ToDo: Change this once the problems with the blockr API has been solved\\n code, reason, tx_hash = push_tx(tx, fee=True)\\n # tx_hash = local_push(tx)\\n else:\\n code, reason, tx_hash = push_tx(tx)\\n\\n if code in [200, 201]:\\n used_txs.extend(necessary_amount)\\n else:\\n tx_hash = None\\n\\n return tx_hash, used_txs\",\n \"def addresses_with_unspent_outputs(self):\\n return self._call_account_method(\\n 'addressesWithUnspentOutputs'\\n )\",\n \"def dumpprivkey(self, address):\\n return self.proxy.dumpprivkey(address)\",\n \"def get_tx_info(tx):\\n\\n input_addresses = []\\n output_addresses = []\\n payments = []\\n\\n try:\\n response = json.loads(make_request('http://tbtc.blockr.io/api/v1/tx/info/' + tx))\\n except Exception as e:\\n status = json.loads(e.message).get('status')\\n if status in ['error', 'fail']:\\n return {'from': None, 'to': None, 'amount': None, 'confirmations': 0}\\n\\n vins = response.get('data').get('vins')\\n vouts = response.get('data').get('vouts')\\n confirmations = response.get('data').get('confirmations')\\n\\n for i in range(len(vins)):\\n if vins[i].get('address') not in input_addresses:\\n input_addresses.append(vins[i].get('address'))\\n for i in range(len(vouts)):\\n output_addresses.append(vouts[i].get('address'))\\n payments.append(vouts[i].get('amount'))\\n\\n return {'from': input_addresses, 'to': output_addresses, 'amount': payments, 'confirmations': confirmations}\",\n \"def getRestaurantAddressDict(restaurants):\\n addressdict = {}\\n for rest in restaurants:\\n if 'address' in rest:\\n addressstring = str(rest['address']) + ' ' + str(rest['city'])\\n addressdict[addressstring] = rest['name']\\n\\n return addressdict\",\n \"def cryptocurrency_withdrawal_request(self, walletId, currency, amount, address):\\n return\",\n \"def balance_of_address(self, address):\\n balance = 0\\n for block in self.chain:\\n for transaction in block.transactions:\\n if transaction.walletoffrom == address:\\n balance -= transaction.amount\\n\\n if transaction.walletofto == address:\\n balance += transaction.amount\\n return balance\",\n \"def address_transactions(self, address):\\n res = r.get(self.url + self.address_tx + str(address))\\n return self.execute(res)\",\n \"def address_dict(self):\\n new_table = {}\\n for record in self._table:\\n address = self.build_address(record)\\n new_table[address] = record\\n return new_table\",\n \"def get_Dogecoin_info(wallet: str, info: dict):\\r\\n\\tresp = requests.get('https://dogechain.info/api/v1/address/received/' + wallet)\\r\\n\\tif resp.status_code == 200:\\r\\n\\t\\tresponse = json.loads(resp.text)\\r\\n\\t\\tif response['success'] == 1:\\r\\n\\t\\t\\tinfo['received'] = float(response['received'])\\r\\n\\t\\t\\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Dogecoin']\\r\\n\\t\\t\\tinfo['updated'] = datetime.datetime.now().isoformat()\\r\\n\\treturn info\",\n \"def get_addr_value(tx):\\n\\t# initialize lists\\n\\tin_addr, in_value, out_addr, out_value = [], [], [], []\\n\\t# for each input transaction\\n\\tfor input in tx[\\\"inputs\\\"]:\\n\\t\\t# if sending address exists\\n\\t\\t# (otherwise coin base or empty value)\\n\\t\\tif \\\"prev_out\\\" in input.keys() and \\\"addr\\\" in input[\\\"prev_out\\\"].keys():\\n\\t\\t\\t# record address and value\\n\\t\\t\\tin_addr.append(input[\\\"prev_out\\\"][\\\"addr\\\"])\\n\\t\\t\\tin_value.append(input[\\\"prev_out\\\"][\\\"value\\\"])\\n\\t# for each output transaction\\n\\tfor output in tx[\\\"out\\\"]:\\n\\t\\t# if receiving address exists\\n\\t\\t# (otherwise empty value)\\n\\t\\tif \\\"addr\\\" in output.keys():\\n\\t\\t\\t# record address and value\\n\\t\\t\\tout_addr.append(output[\\\"addr\\\"])\\n\\t\\t\\tout_value.append(output[\\\"value\\\"])\\n\\t# handle duplicate addresses\\n\\tin_addr, in_value = handle_duplicates(in_addr, in_value)\\n\\tout_addr, out_value = handle_duplicates(out_addr, out_value)\\n\\treturn in_addr, in_value, out_addr, out_value\",\n \"def getBtcInWallet(address):\\n btc = 'https://blockchain.info/q/addressbalance/' + address\\n check = requests.get(btc)\\n value = int((check.content)) / 100000000.0\\n return value\",\n \"def get_balances_blockonomics(addresses):\\r\\n print(\\\"* Using blockonomics.co to query {} addresses\\\".format(len(addresses))) # NOQA\\r\\n BLOCKONOMICS_BALANCE_ENDPOINT = \\\"https://www.blockonomics.co/api/balance\\\"\\r\\n addrs = \\\" \\\".join(addresses)\\r\\n response = requests.post(BLOCKONOMICS_BALANCE_ENDPOINT,\\r\\n json={\\\"addr\\\": addrs})\\r\\n if response.status_code != 200:\\r\\n print(\\\"** blockonomics sent bad server reponse: \\\",\\r\\n response.status_code)\\r\\n return None\\r\\n\\r\\n balances = {}\\r\\n data = response.json()\\r\\n for each in data[\\\"response\\\"]:\\r\\n balances[each[\\\"addr\\\"]] = each[\\\"confirmed\\\"] + each[\\\"unconfirmed\\\"]\\r\\n\\r\\n return balances\",\n \"def balance():\\n address = request.args.get(\\\"address\\\")\\n balance = p2p.query(\\\"/balance\\\", address=address)[\\\"balance\\\"]\\n payload = jsonpickle.encode({\\\"balance\\\": balance})\\n return payload, 200, {\\\"Content-Type\\\": \\\"application/json\\\"}\",\n \"def check_for_funding(self, address):\\n\\n outpoints = []\\n for i in range(len(self.tx.vout)):\\n addr = CIoncoinAddress.from_scriptPubKey(self.tx.vout[i].scriptPubKey)\\n if str(addr) == address:\\n o = {\\n \\\"txid\\\": b2lx(self.tx.GetHash()),\\n \\\"vout\\\": i,\\n \\\"value\\\": self.tx.vout[i].nValue,\\n \\\"scriptPubKey\\\": self.tx.vout[i].scriptPubKey.encode(\\\"hex\\\")\\n }\\n outpoints.append(o)\\n return outpoints if len(outpoints) > 0 else None\",\n \"def get_Bitcoin_info(wallet: str, info: dict):\\r\\n\\tresp = requests.get('https://blockchain.info/q/getreceivedbyaddress/' + wallet)\\r\\n\\tif resp.status_code == 200:\\r\\n\\t\\tinfo['received'] = int(resp.text) / 10**8\\r\\n\\t\\tinfo['received_dollars'] = info['received'] * COIN_VALUES['Bitcoin']\\r\\n\\t\\tinfo['updated'] = datetime.datetime.now().isoformat()\\r\\n\\treturn info\",\n \"def deposit_address(self):\\n response = self.query('deposit_address')\\n return response\",\n \"def total_donated():\\r\\n url = \\\"http://blockchain.info/rawaddr/1RvRE1XPTboTfujU9dRK9euC6TPnGHzKf?limit=0\\\" # pylint:disable=C0301\\r\\n try:\\r\\n response = json.load(urllib2.urlopen(url))\\r\\n except urllib2.HTTPError:\\r\\n return abort(500)\\r\\n return jsonify(total_received=response['total_received'])\",\n \"def address(self):\\n out = {'zip_code': '',\\n 'city': '',\\n 'street': '',\\n 'phone': ''}\\n if self.user.contract_member.exists():\\n last_contract = self.user.contract_member.last()\\n out['zip_code'] = last_contract.zip_code\\n out['city'] = last_contract.city\\n out['street'] = last_contract.street\\n out['phone'] = last_contract.phone\\n\\n return out\",\n \"def walletinfo(test_unlock):\\n stm = shared_morphene_instance()\\n if mph.rpc is not None:\\n mph.rpc.rpcconnect() \\n t = PrettyTable([\\\"Key\\\", \\\"Value\\\"])\\n t.align = \\\"l\\\"\\n t.add_row([\\\"created\\\", mph.wallet.created()])\\n t.add_row([\\\"locked\\\", mph.wallet.locked()])\\n t.add_row([\\\"Number of stored keys\\\", len(mph.wallet.getPublicKeys())])\\n t.add_row([\\\"sql-file\\\", mph.wallet.keyStorage.sqlDataBaseFile])\\n password_storage = mph.config[\\\"password_storage\\\"]\\n t.add_row([\\\"password_storage\\\", password_storage])\\n password = os.environ.get(\\\"UNLOCK\\\")\\n if password is not None:\\n t.add_row([\\\"UNLOCK env set\\\", \\\"yes\\\"])\\n else:\\n t.add_row([\\\"UNLOCK env set\\\", \\\"no\\\"])\\n if KEYRING_AVAILABLE:\\n t.add_row([\\\"keyring installed\\\", \\\"yes\\\"])\\n else:\\n t.add_row([\\\"keyring installed\\\", \\\"no\\\"])\\n if test_unlock:\\n if unlock_wallet(stm):\\n t.add_row([\\\"Wallet unlock\\\", \\\"successful\\\"])\\n else:\\n t.add_row([\\\"Wallet unlock\\\", \\\"not working\\\"])\\n # t.add_row([\\\"getPublicKeys\\\", str(mph.wallet.getPublicKeys())])\\n print(t)\",\n \"def __process_address(self, address: Tuple[int, int, int, int, int]) -> Dict[str, int]:\\n return {\\n 'interface': address[0],\\n 'protocol': address[1],\\n 'type': address[2],\\n 'hardware_type': address[3],\\n 'address': address[4],\\n }\",\n \"def compute_helper_mempool_dictionaries():\\n txn_density_dict = {}\\n txn_parents_dict = {}\\n txn_size_dict = {}\\n mempool_data = parse_mempool_csv()\\n for elem in mempool_data:\\n size = elem.weight/MAXIMUM_BLOCK_WEIGHT # weight mapped to (0,1)\\n txn_size_dict[elem.txid] = size \\n txn_density_dict[elem.txid] = elem.fee/size\\n if elem.parents != '':\\n txn_parents_dict[elem.txid] = elem.parents.strip().split(';')\\n return txn_density_dict,txn_parents_dict,txn_size_dict\",\n \"def get_wallet_info(wallet: str, info: dict):\\r\\n\\t#return if updated recently\\r\\n\\tif 'updated' in info:\\r\\n\\t\\tif datetime.datetime.fromisoformat(info['updated']) + datetime.timedelta(days = UPDATE_INTERVAL) > datetime.datetime.now():\\r\\n\\t\\t\\treturn info\\r\\n\\r\\n\\t#get the amount of money received to the wallet\\r\\n\\t#these wallets won't have collisions in tags, so it is save to overwrite old amounts\\r\\n\\tapi_delay(info['currency'][0])\\r\\n\\tif 'Bitcoin' in info['currency']:\\r\\n\\t\\tget_price('Bitcoin')\\r\\n\\t\\tinfo = get_Bitcoin_info(wallet, info)\\r\\n\\tif 'Ethereum' in info['currency']:\\r\\n\\t\\tget_price('Ethereum')\\r\\n\\t\\tinfo = get_Ethereum_info(wallet, info)\\r\\n\\tif 'Dogecoin' in info['currency']:\\r\\n\\t\\tget_price('Dogecoin')\\r\\n\\t\\tinfo = get_Dogecoin_info(wallet, info)\\r\\n\\tif 'ReddCoin' in info['currency']:\\r\\n\\t\\tget_price('ReddCoin')\\r\\n\\t\\tinfo = get_ReddCoin_info(wallet, info)\\r\\n\\treturn info\",\n \"def signer_address(private_key):\\n return get_ethereum_address_from_private_key(private_key)\",\n \"def get_balances_bitcoind(addresses, username, password,\\r\\n url=\\\"http://127.0.0.1\\\", port=8332):\\r\\n print(\\\"* Using bitcoind to query {} addresses\\\".format(len(addresses)))\\r\\n balances = {}\\r\\n balances_list = []\\r\\n url = url + \\\":\\\" + str(port)\\r\\n headers = {'content-type': 'application/json'}\\r\\n\\r\\n # Making separate requests for each address is surprisingly only a few\\r\\n # seconds slower (in total) than making a single request with all\\r\\n # addresses. # It's also easier to recover incase of a bad address from\\r\\n # vanitygen.\\r\\n def _get_balance(address):\\r\\n payload = {\\r\\n \\\"method\\\": \\\"getaddressbalance\\\",\\r\\n \\\"params\\\": [{\\\"addresses\\\": [address]}],\\r\\n \\\"jsonrpc\\\": \\\"2.0\\\",\\r\\n \\\"id\\\": 0,\\r\\n }\\r\\n\\r\\n response = requests.post(url, json=payload, headers=headers,\\r\\n auth=(username, password))\\r\\n\\r\\n if response.status_code != 200:\\r\\n return (address, 0)\\r\\n\\r\\n data = response.json()\\r\\n return (address, data[\\\"result\\\"][\\\"balance\\\"])\\r\\n\\r\\n pool = ThreadPool(4)\\r\\n balances_list = pool.map(_get_balance, addresses)\\r\\n pool.close()\\r\\n pool.join()\\r\\n\\r\\n for addr, bal in balances_list:\\r\\n if bal != 0:\\r\\n balances[addr] = bal\\r\\n\\r\\n return balances\",\n \"def withdraw(self, currency, amount, address):\\n return self.api_query('withdraw', {\\\"currency\\\": currency, \\\"amount\\\": amount, \\\"address\\\": address})\",\n \"def get_account_balance(unspent_outputs):\\n return sum(output[\\\"value\\\"] for output in unspent_outputs.values())\",\n \"def test_wallets_get(self):\\n pass\",\n \"def get_history_from_address(address):\\n \\n if not exists_address_transfer_observation_from(address):\\n return make_response(jsonify(build_error('No content. transactions from the address are not observed')), 204)\\n \\n take = request.args.get('take')\\n if take is None:\\n take = 0\\n else:\\n take = int(take)\\n \\n afterhash = request.args.get('afterHash')\\n if afterhash is None:\\n afterhash = \\\"\\\" \\n \\n update_index() \\n items = get_transactions_from(address, take, afterhash)\\n \\n if 'error' in items:\\n return make_response(jsonify(build_error(items['error'])), items['status'])\\n\\n return jsonify(items)\",\n \"def get_history_to_address(address):\\n \\n if not exists_address_transfer_observation_to(address):\\n return make_response(jsonify(build_error('No content: transactions to the address are not observed')), 204)\\n \\n take = request.args.get('take')\\n if take is None:\\n take = 0\\n else:\\n take = int(take)\\n \\n afterhash = request.args.get('afterHash'.lower())\\n if afterhash is None:\\n afterhash = ''\\n \\n update_index() \\n items = get_transactions_to(address, take, afterhash)\\n\\n response = items if take == 0 else items[0:take]\\n\\n return jsonify(response)\",\n \"async def mempool() -> dict:\\n return {\\\"mempool\\\": chain.mempool_state()}\",\n \"def withdraw_from_address(amount, network_fee, from_address, to_address):\\n tx_total = amount + network_fee\\n address_balance = get_address_balance(from_address)\\n\\n if tx_total > address_balance:\\n # return not enough funds error\\n print(\\\"Error: Not enough funds\\\")\\n else:\\n tx_hex_string = create_raw_transaction(amount, network_fee, from_address, to_address)\\n signed_tx = sign_raw_transaction(tx_hex_string)\\n hex_signed_tx = signed_tx[\\\"hex\\\"]\\n txid = send_raw_transaction(hex_signed_tx)\\n\\n return txid.decode()\",\n \"def withdraw(self, currency, amount, address):\\n pass\",\n \"def get_address_to_usb_info_dict():\\n with open(os.devnull, 'w') as devnull:\\n output = subprocess.check_output(MAC_COMMAND, stderr=devnull)\\n output_dict = json.loads(output)\\n usb_connections = output_dict[PROFILER_USB_DATA_TYPE]\\n usb_info_dict = {}\\n _convert_system_profiler_dict(usb_connections, usb_info_dict)\\n return usb_info_dict\",\n \"def unknown_address(ip_address: str) -> dict:\\n address = UNKNOWN_COUNTRY.copy()\\n address.update({\\\"remote_addr\\\": ip_address})\\n return address\",\n \"def address_balance(self, address, confirmations=0):\\n address = utils.request_type(address)\\n\\n confs = {'confirmations': confirmations}\\n if confs['confirmations'] > 0:\\n res = r.get(self.url + self.balance + str(address), params=confs)\\n else:\\n res = r.get(self.url + self.balance + str(address))\\n return self.execute(res)\",\n \"def __get_account(self, address):\\n\\t\\tfor acct in self.wallet:\\n\\t\\t\\tif acct[\\\"address\\\"] == address:\\n\\t\\t\\t\\treturn acct\\n\\t\\traise ValueError(\\\"The given address does not exist in the bunkr-wallet\\\")\",\n \"def getTokens_utils(account_address, value=30000000000):\\n e = {'txid':'Error!'} \\n logsOfError = ''\\n try:\\n trigger = tron.transaction_builder.trigger_smart_contract(contract_address = TOKEN_CONTRACT,\\n function_selector = 'transfer(address,uint256)', #без пробелов!\\n fee_limit=1000000000,\\n call_value=0,\\n parameters=[{'type':'address','value':account_address},{'type': 'int256','value':value}],\\n issuer_address=TOKEN_CREATOR\\n )\\n\\n tron.private_key = TOKEN_CREATOR_PRIVATE_KEY\\n transaction = trigger['transaction']\\n signed1_tx = tron.trx.sign(transaction,True,False)\\n e = tron.trx.broadcast(signed1_tx)\\n except Exception as ex:\\n logsOfError = logsOfError + str(ex)\\n return {'txID':e['txid'], 'logs':logsOfError}\",\n \"def __fresh_account(self):\\n\\t\\tshuffle(self.wallet)\\n\\t\\tfor acct in self.wallet:\\n\\t\\t\\tif len(get_spent(acct[\\\"address\\\"], self.testnet))==0 and len(get_unspent(acct[\\\"address\\\"], self.testnet))==0:\\n\\t\\t\\t\\treturn acct\\n\\t\\traise ValueError(\\\"No unused addresses available. Run add_accounts()\\\")\",\n \"def dump_priv_key(litecoinaddress):\\n try:\\n priv_key = subprocess.check_output([\\\"litecoin-cli\\\", \\\"dumpprivkey\\\", litecoinaddress])\\n except:\\n sys.exit(1)\\n\\n return priv_key.decode().strip()\",\n \"async def fetch_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n currency = self.currency(code)\\n request = {\\n 'asset': currency['id'],\\n }\\n response = await self.privateGetUserWithdrawalAccount(self.extend(request, params))\\n data = self.safe_value(response, 'data', {})\\n # Not sure about self if there could be more than one account...\\n accounts = self.safe_value(data, 'accounts', [])\\n firstAccount = self.safe_value(accounts, 0, {})\\n address = self.safe_string(firstAccount, 'address')\\n return {\\n 'currency': currency,\\n 'address': address,\\n 'tag': None,\\n 'network': None,\\n 'info': response,\\n }\",\n \"def verbose_balance(self):\\n orig_balance = self.balance\\n verbose_balance = {}\\n for key, val in orig_balance.items():\\n acc = self.find_peer_by_pubkey(key)\\n if acc is None:\\n if key == self.pubkey:\\n verbose_balance[self.name] = val\\n else:\\n verbose_balance[key] = val\\n else:\\n verbose_balance[acc[\\\"name\\\"]] = val\\n return verbose_balance\",\n \"def get_addresses_by_account(account):\\n try:\\n stdout = subprocess.check_output([\\\"litecoin-cli\\\", \\\"getaddressesbyaccount\\\", account])\\n addresses = json.loads(stdout.decode())\\n except:\\n sys.exit(1)\\n\\n return addresses\",\n \"def withdraw_crypt(self, amount, currency, address):\\n response = self.query('withdraw_crypt', params=dict(amount=amount, currency=currency, address=address))\\n return response\",\n \"def create_raw_transaction(amount, network_fee, from_address, to_address):\\n tx_total = amount + network_fee\\n tx_inputs = []\\n input_total = 0\\n unspent = list_unspent(from_address)\\n\\n # Are there enough funds in one block to cover the amount\\n for block in unspent:\\n if float(block[\\\"amount\\\"]) >= tx_total:\\n tx_input = {\\\"txid\\\": block[\\\"txid\\\"], \\\"vout\\\": int(block[\\\"vout\\\"])}\\n input_total = float(block[\\\"amount\\\"])\\n tx_inputs.append(tx_input)\\n break\\n # If tx_inputs is empty that means we have to\\n # build the transaction from multiple blocks\\n if not tx_inputs:\\n for block in unspent:\\n if input_total >= tx_total:\\n break\\n else:\\n tx_input = {\\\"txid\\\": block[\\\"txid\\\"], \\\"vout\\\": int(block[\\\"vout\\\"])}\\n input_total += float(block[\\\"amount\\\"])\\n tx_inputs.append(tx_input)\\n\\n # Amount left over after amount to send and network fees are subtracted\\n # from input_total. Change is sent back to sender\\n change = round((input_total - amount) - network_fee, 8)\\n \\n if change < dust:\\n tx_output = {to_address: amount}\\n else:\\n tx_output = {to_address: amount, from_address: change}\\n \\n try:\\n tx_hex_string = subprocess.check_output([\\\"litecoin-cli\\\", \\\"createrawtransaction\\\", json.dumps(tx_inputs), json.dumps(tx_output)])\\n except:\\n sys.exit(1)\\n\\n return tx_hex_string.strip()\",\n \"def get_unspent_outputs(self, crypto, address):\\n raise NotImplementedError(\\n \\\"This service does not support getting unspent outputs. \\\"\\n \\\"Or rather it has no defined 'get_unspent_outputs' method.\\\"\\n )\",\n \"def get_address_revision(transaction_id, address_id) -> dict:\\n address_version = version_class(Address)\\n address = db.session.query(address_version) \\\\\\n .filter(address_version.transaction_id <= transaction_id) \\\\\\n .filter(address_version.operation_type != 2) \\\\\\n .filter(address_version.id == address_id) \\\\\\n .filter(or_(address_version.end_transaction_id == None, # pylint: disable=singleton-comparison # noqa: E711,E501;\\n address_version.end_transaction_id > transaction_id)) \\\\\\n .order_by(address_version.transaction_id).one_or_none()\\n return address\",\n \"def stake_informations(self, stake_address: str) -> dict:\\n \\n url_stake_info = self.network + bf_stake_url + stake_address\\n \\n response = query_blockfrost(url_stake_info, self.api_key, self.proxies)\\n \\n return response\",\n \"def generate_address(self, private_key):\\n words, seed = CryptoUtils.create_mnemonic_key(private_key)\\n private_key_to_hex = CryptoUtils.generate_private_key(seed)\\n public_key = CryptoUtils.generate_public_key(private_key_to_hex)\\n public_key_compressed = CryptoUtils.compress_public_key(public_key)\\n address = CryptoUtils.generate_address(public_key)\\n self.addresses[address] = {\\n 'owner_key': private_key,\\n 'private_key': private_key_to_hex,\\n 'mnemonic_words': words,\\n 'public_key': public_key,\\n 'public_key_compressed': public_key_compressed,\\n 'balance': 0\\n }\",\n \"def parse_address(address: str) -> OrderedDict[str, str]:\\n\\n address = address.replace(\\\"\\\\n\\\", \\\", \\\")\\n\\n parsed_address, address_type = usaddress.tag(address)\\n if address_type != \\\"Street Address\\\":\\n logger.warning(\\n f\\\"Couldn't parse address '{address}' of type {address_type}; best guess: {parsed_address}\\\"\\n )\\n\\n # Fixup: At least one address has \\\"WI, USA\\\" in the \\\"StateName\\\" component.\\n # Strip non-state components\\n if parsed_address.get(\\\"StateName\\\"):\\n parsed_address[\\\"StateName\\\"] = parsed_address[\\\"StateName\\\"].partition(\\\",\\\")[0]\\n\\n return parsed_address\",\n \"def tip(sender, recipient, amount):\\n\\n info = {\\n \\\"txid\\\" : \\\"None\\\",\\n \\\"response\\\" : \\\"None\\\", #Comment reply\\n \\\"message\\\" : None #Error message\\n }\\n\\n tipper_logger.log(sender + \\\" is trying to send \\\" + recipient + \\\" \\\" + amount + \\\" XMR\\\")\\n\\n sender = str(sender)\\n recipient = str(recipient)\\n sender_rpc_n_wallet = None\\n\\n try:\\n sender_rpc_n_wallet = SafeWallet(port=helper.ports.tip_sender_port, wallet_name=sender.lower())\\n tipper_logger.log(\\\"Sender wallet loaded!!\\\")\\n except Exception as e:\\n sender_rpc_n_wallet.kill_rpc()\\n tipper_logger.log(\\\"Failed to open wallets for \\\" + sender + \\\" and \\\" + recipient + \\\". Message: \\\")\\n tipper_logger.log(e)\\n info[\\\"response\\\"] = \\\"Could not open wallets properly! Perhaps my node is out of sync? (Try again shortly).\\\\n\\\\n^/u/OsrsNeedsF2P!!\\\"\\n info[\\\"message\\\"] = str(e)\\n return info\\n\\n tipper_logger.log(\\\"Successfully initialized wallets..\\\")\\n\\n try:\\n recipient_address=helper.get_address_txt(recipient.lower())\\n txs = generate_transaction(sender_wallet=sender_rpc_n_wallet.wallet, recipient_address=recipient_address, amount=amount)\\n\\n info[\\\"txid\\\"] = str(txs)\\n info[\\\"response\\\"] = f\\\"Successfully tipped /u/{recipient} {amount} XMR! [^(txid)]({helper.get_xmrchain(txs)})\\\"\\n tipper_logger.log(\\\"Successfully sent tip\\\")\\n except Exception as e:\\n tipper_logger.log(e)\\n traceback.print_exc()\\n info[\\\"message\\\"] = get_error_response(e)\\n info[\\\"response\\\"] = \\\"Didn't tip - Check your private message to see why :)\\\"\\n\\n sender_rpc_n_wallet.kill_rpc()\\n\\n tipper_logger.log(\\\"Tip function completed without crashing\\\")\\n\\n return info\",\n \"def derive_wallets2(mnemonic, coin, numderive):\\n command = 'php hd-wallet-derive/hd-wallet-derive.php -g --mnemonic={mnemonic} --cols=path,address,privkey,pubkey --format=json --coin=“{coin}” --numderive= 2'\\n p = subprocess.Popen(command2, stdout=subprocess.PIPE, shell=True)\\n (output, err) = p.communicate()\\n p_status = p.wait()\\n keys = json.loads(output)\\n return keys\",\n \"def account_deposit_address(self, currency_symbol):\\n return self.get(f'addresses/{currency_symbol}', auth=True)\",\n \"def as_dict(self):\\n dict_data = {\\n 'first_name': self.first_name,\\n 'last_name': self.last_name,\\n 'email': self.email,\\n 'phone': self.phone,\\n 'orders_count': self.orders_count,\\n 'currency': self.currency,\\n }\\n address_instance = Address.objects.filter(customer=self).first()\\n if address_instance:\\n dict_data.update({'address': address_instance.address,\\n 'city': address_instance.city,\\n 'country': address_instance.city,\\n 'zip_code': address_instance.zip_code\\n })\\n return dict_data\",\n \"def q_addressbalance(abe, page, chain):\\n addr = wsgiref.util.shift_path_info(page['env'])\\n if chain is None or addr is None:\\n return 'returns amount of money at the given address\\\\n' \\\\\\n '/chain/CHAIN/q/addressbalance/ADDRESS\\\\n'\\n\\n if not util.possible_address(addr):\\n return 'ERROR: address invalid'\\n\\n version, hash = util.decode_address(addr)\\n total = abe.store.get_balance(chain.id, hash)\\n\\n return (\\\"ERROR: please try again\\\" if total is None else\\n format_satoshis(total, chain))\",\n \"def to_dict(self):\\n dct = self.__dict__\\n dct['address'] = self.address.to_dict()\\n return dct\",\n \"def get_balance(address: str) -> int:\\n return base.Balances(balance_of).get(address)\",\n \"def get_balance(self, address):\\n\\n raise NotImplementedError('coming soon...')\\n\\n return sum(o.value for o in self.get_unspent_outputs(address)) / 100000000.0\",\n \"def deposit(self, account_id: int, amount: float) -> Dict[bool, Accounts]:\\n raise Exception(\\\"Method should be implemented\\\")\",\n \"def test_wallets_get_transaction_list(self):\\n pass\",\n \"def jsonrpc_getutxos(self, addresses):\\n utxos_by_addr = {}\\n for address in addresses:\\n pubkey = address_to_pubkey(address)\\n utxo_refs = self.node.storage.utxos_for_pubkey(pubkey)\\n utxos_by_addr[address] = [{\\n 'txid': b2hex(ref[0]),\\n 'index': ref[1],\\n 'blockheight': ref[2]\\n } for ref in utxo_refs]\\n return utxos_by_addr\",\n \"def get_balance_response(address):\\n call = Address(address=address)\\n response = call.get_address_info()\\n if response:\\n return response\\n else:\\n return None\",\n \"def get_balances_blockchain(addresses):\\r\\n print(\\\"* blockchain.info not yet supported\\\")\\r\\n return None\",\n \"async def get_locked_coins_in_spend_bundle(\\n self, bundle: SpendBundle\\n ) -> Dict[bytes32, WalletCoinRecord]:\\n result = {}\\n removals = bundle.removals()\\n for coin in removals:\\n coin_record = await self.wallet_state_manager.wallet_store.get_coin_record_by_coin_id(\\n coin.name()\\n )\\n if coin_record is None:\\n continue\\n result[coin_record.name()] = coin_record\\n return result\",\n \"def test_wallets_get_list(self):\\n pass\",\n \"def create_tx(coin, account, recipient, amount):\\n if coin ==ETH:\\n gasEstimate = w3.eth.estimateGas(\\n {\\\"from\\\": account.address, \\\"to\\\": recipient, \\\"value\\\": amount})\\n return{\\n \\\"to\\\": recipient,\\n \\\"from\\\": account.address,\\n \\\"value\\\": amount,\\n \\\"gasPrice\\\": w3.eth.gasPrice,\\n \\\"gas\\\": gasEstimate,\\n \\\"nonce\\\": w3.eth.getTransactionCount(account.address)\\n }\\n if coin == BTCTEST:\\n return PrivateKeyTestnet.prepare_transaction(account.address, [(recipient, amount, BTC)])\",\n \"def _get_notary_address(from_key):\\n return _hash(FAMILY_NAME.encode('utf-8'))[0:6] + \\\\\\n _hash(from_key.encode('utf-8'))[0:64]\",\n \"def removeStake(self, address: str, value_LP: int):\\n addr = address.lower()\\n balances = self.addresses[addr] if addr in self.addresses else []\\n if len(balances) > 0:\\n while len(balances) > 0 and value_LP > 0:\\n balance = balances[-1]\\n initial_LP = balance['LP']\\n if value_LP >= initial_LP:\\n del balances[-1]\\n value_LP -= initial_LP\\n else:\\n new_LP = initial_LP - value_LP\\n remaining_percent = new_LP / initial_LP if initial_LP != 0 else 1\\n balance['LP'] = new_LP\\n balance['USDC'] = int(balance['USDC'] * remaining_percent)\\n balance['eXRD'] = int(balance['eXRD'] * remaining_percent)\\n balances[-1] = balance\\n value_LP = 0\\n else:\\n # Just log such cases - deal with them later\\n balances.append({\\n 'USDC': 0,\\n 'eXRD': 0,\\n 'LP': -value_LP\\n })\\n self.addresses[addr] = balances\",\n \"def address_to_json(address):\\n addr = {\\n \\\"zip\\\": address.zip,\\n \\\"address1\\\": address.address,\\n \\\"address2\\\": address.unit,\\n \\\"city\\\":address.city,\\n \\\"state\\\": address.state\\n }\\n addr = {key:value for (key,value) in addr.items() if not value is None}\\n return json.dumps(addr)\",\n \"def calculate_debt(acc, key, value):\\n if key == 'transactions':\\n for amount in value:\\n acc += amount \\n\\n return acc\",\n \"def q_getreceivedbyaddress(abe, page, chain):\\n addr = wsgiref.util.shift_path_info(page['env'])\\n if chain is None or addr is None:\\n return 'returns amount of money received by given address (not balance, sends are not subtracted)\\\\n' \\\\\\n '/chain/CHAIN/q/getreceivedbyaddress/ADDRESS\\\\n'\\n\\n if not util.possible_address(addr):\\n return 'ERROR: address invalid'\\n\\n version, hash = util.decode_address(addr)\\n return format_satoshis(abe.store.get_received(chain.id, hash), chain)\",\n \"def split_address(address: str, prefix=\\\"address_\\\", max_lines=5) -> dict[str, str]:\\n\\n # TODO ICMSLST-1692: ILB to fix addresses which are more than 5 lines\\n return {\\n f\\\"{prefix}{i}\\\": address_line.strip()\\n for i, address_line in enumerate(address.split(\\\"\\\\n\\\"), start=1)\\n if address_line and address_line.strip() and i <= max_lines\\n }\",\n \"def create_wallet(self):\\n\\n child = pexpect.spawn('node createKeystore', cwd='../src/')\\n if commonUtil.show_logs:\\n child.logfile = sys.stdout\\n\\n self.file_name = commonUtil.get_random_string()\\n self.password = commonUtil.get_random_string()\\n\\n commonUtil.check_expect(\\\"Input file name\\\", child, test_name, \\\"'Input file name' prompt not found\\\")\\n child.sendline(self.file_name)\\n\\n commonUtil.check_expect(\\\"Input password\\\", child, test_name, \\\"'Input password' prompt not found\\\")\\n child.sendline(self.password)\\n\\n result = child.read()\\n\\n if result.find(\\\"Please check if the filename is used\\\") != -1:\\n commonUtil.exit_test(\\\"file name is already present in the system\\\", child)\\n\\n if result.find(\\\"address\\\") == -1:\\n commonUtil.exit_test(\\\"'address' title not found in wallet summary\\\", child)\\n\\n if result.find(\\\"waddress\\\") == -1:\\n commonUtil.exit_test(\\\"waddress' title not found in wallet summary\\\", child)\\n\\n if result.find(self.file_name) == -1:\\n commonUtil.exit_test(\\\"file name:\\\" + self.file_name + \\\" not found in wallet summary\\\", child)\\n\\n if result.find(self.password) == -1:\\n commonUtil.exit_test(\\\"password:\\\" + self.password + \\\" not found in wallet summary\\\", child)\\n\\n address_start = result.find('0x')\\n if address_start == -1:\\n commonUtil.exit_test('address value starting with 0x not found in wallet summary', child)\\n self.address = result[address_start:address_start + 42]\\n\\n waddress_start = result.find('0x', address_start + 42)\\n if waddress_start == -1:\\n commonUtil.exit_test('wan address value starting with 0x not found in wallet summary', child)\\n self.waddress = result[waddress_start:waddress_start + 134]\\n\\n child.expect(pexpect.EOF)\",\n \"def get_unspent_outputs(self, address):\\n\\n raise NotImplementedError('coming soon...')\\n\\n outputs = []\\n for uock in self._unspent._list_unspent(address):\\n\\n # get the transaction for this utxo\\n txck = keys.get_uock_txck(uock)\\n txn = self._blocks._txns._get(txck)\\n\\n output_index = keys.get_uock_index(uock)\\n\\n # remove false positives (since the database only stores a hint)\\n txio = script.Script(txn)\\n if txio.output_address(output_index) == address:\\n outputs.append(txn.outputs[output_index])\\n\\n return outputs\",\n \"def prepare_raw_tx(self, mn_address, change_address, inputs, total, fee=0.00001):\\n raw_tx = {mn_address: self.send_amount, change_address: total - self.send_amount - fee}\\n return self.rpc.createrawtransaction(inputs, raw_tx)\",\n \"def serialize(self):\\n return { \\n \\n 'balance' : self.balance,\\n 'email' : self.email,\\n\\n }\",\n \"def payback_form_data(self):\\n return {\\n 'date': date.today(),\\n 'who_from': 'Georgie',\\n 'who_to': 'Tristan',\\n 'amount': 50,\\n 'currency': 'GBP',\\n 'method': 'Bank_transfer'\\n }\",\n \"def setup_cache(self):\\n if self.walletname not in cache: \\n cache[self.walletname] = {\\n \\\"raw_transactions\\\": {},\\n \\\"transactions\\\": [],\\n \\\"tx_count\\\": None,\\n \\\"tx_changed\\\": True,\\n \\\"last_block\\\": None,\\n \\\"raw_tx_block_update\\\": {},\\n \\\"addresses\\\": [],\\n \\\"change_addresses\\\": [],\\n \\\"scan_addresses\\\": True\\n }\",\n \"def dict() -> Dict[str, Pin]:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6371236","0.5843207","0.5801892","0.5744291","0.5730674","0.5722021","0.57213354","0.5651544","0.5647592","0.5630476","0.5613511","0.5587668","0.553333","0.55286324","0.5524606","0.54863155","0.54595","0.5434609","0.54137826","0.5393165","0.5364194","0.5350382","0.53486043","0.53478116","0.5347365","0.5332011","0.53113383","0.5286262","0.52857304","0.5276326","0.52726305","0.5272427","0.5268349","0.52642167","0.52183723","0.52032685","0.5181992","0.51809114","0.5167548","0.51537126","0.5075591","0.5062355","0.50623214","0.5057735","0.50486743","0.504246","0.5025963","0.5025876","0.5013936","0.5009949","0.49884412","0.49546382","0.49541467","0.49514934","0.4936646","0.4936599","0.4932581","0.49320516","0.49253005","0.492427","0.4907074","0.48773584","0.4867814","0.485142","0.48501107","0.48472658","0.4839781","0.48352575","0.48230267","0.48019236","0.47982383","0.47795585","0.47737667","0.47720847","0.47681406","0.47676975","0.47653505","0.4765317","0.47577438","0.47517577","0.4748897","0.47466773","0.47454193","0.47307712","0.47279745","0.47274214","0.47242007","0.47239453","0.471865","0.4710284","0.47070715","0.47056305","0.47036988","0.4702302","0.4699388","0.4698143","0.46947515","0.46868095","0.46814445","0.46717045","0.4643194"],"string":"[\n \"0.6371236\",\n \"0.5843207\",\n \"0.5801892\",\n \"0.5744291\",\n \"0.5730674\",\n \"0.5722021\",\n \"0.57213354\",\n \"0.5651544\",\n \"0.5647592\",\n \"0.5630476\",\n \"0.5613511\",\n \"0.5587668\",\n \"0.553333\",\n \"0.55286324\",\n \"0.5524606\",\n \"0.54863155\",\n \"0.54595\",\n \"0.5434609\",\n \"0.54137826\",\n \"0.5393165\",\n \"0.5364194\",\n \"0.5350382\",\n \"0.53486043\",\n \"0.53478116\",\n \"0.5347365\",\n \"0.5332011\",\n \"0.53113383\",\n \"0.5286262\",\n \"0.52857304\",\n \"0.5276326\",\n \"0.52726305\",\n \"0.5272427\",\n \"0.5268349\",\n \"0.52642167\",\n \"0.52183723\",\n \"0.52032685\",\n \"0.5181992\",\n \"0.51809114\",\n \"0.5167548\",\n \"0.51537126\",\n \"0.5075591\",\n \"0.5062355\",\n \"0.50623214\",\n \"0.5057735\",\n \"0.50486743\",\n \"0.504246\",\n \"0.5025963\",\n \"0.5025876\",\n \"0.5013936\",\n \"0.5009949\",\n \"0.49884412\",\n \"0.49546382\",\n \"0.49541467\",\n \"0.49514934\",\n \"0.4936646\",\n \"0.4936599\",\n \"0.4932581\",\n \"0.49320516\",\n \"0.49253005\",\n \"0.492427\",\n \"0.4907074\",\n \"0.48773584\",\n \"0.4867814\",\n \"0.485142\",\n \"0.48501107\",\n \"0.48472658\",\n \"0.4839781\",\n \"0.48352575\",\n \"0.48230267\",\n \"0.48019236\",\n \"0.47982383\",\n \"0.47795585\",\n \"0.47737667\",\n \"0.47720847\",\n \"0.47681406\",\n \"0.47676975\",\n \"0.47653505\",\n \"0.4765317\",\n \"0.47577438\",\n \"0.47517577\",\n \"0.4748897\",\n \"0.47466773\",\n \"0.47454193\",\n \"0.47307712\",\n \"0.47279745\",\n \"0.47274214\",\n \"0.47242007\",\n \"0.47239453\",\n \"0.471865\",\n \"0.4710284\",\n \"0.47070715\",\n \"0.47056305\",\n \"0.47036988\",\n \"0.4702302\",\n \"0.4699388\",\n \"0.4698143\",\n \"0.46947515\",\n \"0.46868095\",\n \"0.46814445\",\n \"0.46717045\",\n \"0.4643194\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84696,"cells":{"query":{"kind":"string","value":"Sets the sICX address from staking contract."},"document":{"kind":"string","value":"def setSicxAddress(self, _address: Address) -> None:\n self._sICX_address.set(_address)"},"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 set_contract_addr(self, addr):\n\t\tself.contract_addr = addr\n\t\tself._bank_inst = self._w3.eth.contract(\n\t\t\taddress=self.contract_addr,\n\t\t\tabi=self._iface[\"abi\"],\n\t\t)","def set_address(self, address):\n pass","def getSicxAddress(self) -> Address:\n return self._sICX_address.get()","def set_Street(self, value):\n super(AddressValidationInputSet, self)._set_input('Street', value)","def address(self, address: str):\n\n self._address = address","def address(self, address: object):\n\n self._address = address","def set_address(self, address):\n if address == \"\":\n self.address = Address(\"\", \"\", \"\")\n else:\n self.address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def address(self, address):\n\n self._address = address","def setEthaddr(self):\n\t\tself.ethaddr = self.settings.getKeyValue('ethaddr')\n\t\tself.socket.send('setenv ethaddr ' + self.ethaddr+'\\r', 1)\n\t\treturn None","def setAddress(self, ip_address):\n # type: (str)->None\n\n self._validator.validate_one(\n 'address', VALID_OPTS['address'], ip_address)\n self._ifAttributes['address'] = ip_address","def set_address(self, address, defer=False):\n\n # The MAXUSB chip handles this for us, so we don't need to do anything.\n pass","def set_address(self,address): \n new_address = self._format_address(address)\n self.rs485.write_command('#00?8 {}'.format(new_address))\n self.rs485.clear_buffers()\n time.sleep(0.2)","def set_address(self, address):\n self._java_ref.setAddress(address)","def test_set_address(self):\n s1 = System()\n s1.set_address(\"101 St James Rd\")\n self.assertEqual(s1.get_address(), \"101 St James Rd\")","def address(self, address):\n if address is None:\n raise ValueError(\"Invalid value for `address`, must not be `None`\")\n\n self._address = address","def address(self, address):\n if self.local_vars_configuration.client_side_validation and address is None: # noqa: E501\n raise ValueError(\"Invalid value for `address`, must not be `None`\") # noqa: E501\n\n self._address = address","def set_sICX_supply(self) -> None:\n sICX_score = self.create_interface_score(self._sICX_address.get(),\n sICXTokenInterface)\n self._sICX_supply.set(sICX_score.totalSupply())","def setBaseAddress(self, address):\n DPxSetDinBuffBaseAddr(address)","def setIpaddr(self):\n\t\tself.ipaddr = self.settings.getKeyValue('ipaddr')\n\t\tself.socket.send('setenv ipaddr ' + self.ipaddr+'\\r', 1)\t\t\n\t\treturn None","def szx(self, addr):\n\n if self.reg.zerox_flag:\n self.reg.ip_inc()\n self.reg.ip_inc()","def setSicxSupply(self) -> None:\n self._sICX_supply.set(self.sICX_score.totalSupply())","def stellar_address(self) -> str:\n return kin_utils.encode_check('account', bytes(self._verify_key)).decode()","def set_start_address(address):\n try:\n command(address + \"P\")\n except EppException as e:\n print 'No EPROM type is selected, or value is higher than end address.', e.value","def _set_address(self, v, load=False):\n try:\n t = YANGDynClass(v,base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\"address\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True)\n except (TypeError, ValueError):\n raise ValueError(\"\"\"address must be of a type compatible with base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\"address\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True\"\"\")\n self.__address = t\n if hasattr(self, '_set'):\n self._set()","def setWriteAddress(self, address):\n DPxSetDinBuffWriteAddr(address)","def setData(self,address):\n self.data = _pack_address(address)","def escrow_address(self, escrow_address):\n\n self._escrow_address = escrow_address","def address(self, address: str):\n if address is None:\n raise ValueError(\"Invalid value for `address`, must not be `None`\") # noqa: E501\n\n self._address = address","def change_ip(self, address: int) -> None:\n self.regs[\"ip\"].write(address)","def set_GOST_address(address=None):\n if not address:\n address = get_address_from_file()\n else:\n f = open(address_file_path, 'w')\n f.writelines([])\n f.close()\n f = os.open(address_file_path, os.O_RDWR)\n os.write(f, bytes(address, 'utf-8'))\n os.fsync(f)\n os.close(f)\n if test_connection(address, verbose=False):\n return address\n else:\n return False","def address(self, address):\n if address is None:\n raise ValueError(\"Invalid value for `address`, must not be `None`\") # noqa: E501\n\n self._address = address","def set_permitted_ip(address=None, deploy=False):\n\n if not address:\n raise CommandExecutionError(\"Address option must not be empty.\")\n\n ret = {}\n\n query = {\n \"type\": \"config\",\n \"action\": \"set\",\n \"xpath\": \"/config/devices/entry[@name='localhost.localdomain']/deviceconfig/system/permitted-ip\",\n \"element\": \"<entry name='{}'></entry>\".format(address),\n }\n\n ret.update(__proxy__[\"panos.call\"](query))\n\n if deploy is True:\n ret.update(commit())\n\n return ret","def setup(token_addr: str, box_addr: str) -> None:\n print(f\"\\nSetting up Contracts....\")\n tokenContract = pytezos.contract(token_addr)\n print(f\"-- Performing Initial Mint to Admin : {pub_key_hash}\")\n tokenContract.initialMint(None).inject(_async=False)\n print(\"-- Funding Fishcake Box Contract\")\n tokenContract.transfer([{\"from_\": pub_key_hash, \"txs\": [\n {\"to_\": box_addr, \"token_id\": 0, \"amount\": default_fsck_box_fund}]}]).inject(_async=False)","def contract(self, contract):\n\n self._contract = contract","def set_addr(self, addr):\n Server.t_addresses[threading.get_ident()] = addr","def set_device_address(self, value):\n # Check format\n if value > 0xFF:\n raise StationException(\"Device addresses must be 1-byte length\")\n # Switch to command mode if necessary\n if self._sermode == SerialModem.Mode.DATA:\n self.enter_command_mode()\n # Run AT command\n response = self.run_at_command(\"ATDA=\" + \"{0:02X}\".format(value) + \"\\r\")\n if response is None:\n return False\n if response[0:2] == \"OK\":\n self.devaddress = value\n return True\n else:\n return False","def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\n addr = address.lower()\n balances = self.addresses[addr] if addr in self.addresses else []\n balances.append({\n 'USDC': value_USDC,\n 'eXRD': value_eXRD,\n 'LP': value_LP\n })\n self.addresses[addr] = balances","def stx(self, addr):\n\n self.mem.write(addr, self.reg.idx)","def _set_address(self, address):\n for retry in range(0, self.__RETRY_MAX_NUM):\n sequence = bytearray(address.to_bytes(4, 'big'))\n sequence.append(self._checksum(sequence))\n\n bytes_sent = self._port_handle.write(sequence)\n if bytes_sent != len(sequence):\n raise DfuException(\n 'Serial port write error: tried to'\n 'send {} bytes, but {} was sent.'.format(\n len(sequence), bytes_sent))\n if self._is_acknowledged():\n break\n else:\n raise DfuException('Setting address failed after {} '\n 'retries.'.format(retry + 1))","def set_amf_addr(self, addr: str) -> None:\n self.config[\"amfConfigs\"][0][\"address\"] = addr","def set_offset_address(address):\n command(address + \"O\")","def street(self, street):\n\n self._street = street","def setAddressSource(self, address_source):\n # type: (str)->None\n\n self._validator.validate_one(\n 'source', VALID_OPTS['source'], address_source)\n self._ifAttributes['source'] = address_source","def set_adressing(self, addr, set=True):\n assert addr in [self.ADDRESSING_HORIZ, self.ADDRESSING_VERT], \"Addressing must be ADDRESSING_HORIZ or ADDRESSING_VERT.\"\n self.addressing = addr\n if set:\n self._set_function()","def setInt(self, address: ghidra.program.model.address.Address, value: int) -> None:\n ...","def address_id(self, address_id):\n\n self._address_id = address_id","def address_id(self, address_id):\n\n self._address_id = address_id","def set_address(self, new_address, ):\n self.address.append(new_address)\n self.save()","def set_State(self, value):\n super(AddressValidationInputSet, self)._set_input('State', value)","def ship_to_pickup_address(self, address):\n self._set('shipping', 'pickup_address_id', address.id)","def __init__(self, address):\n self._address = address","def set_remit_to_address(self, remit_to_address):\n self.remit_to_address = remit_to_address","def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int], sIndex: int, size: int) -> None:\n ...","def set(self, addr, value):\n\n if len(addr) == 4:\n ipset.ipmap_ipv4_set(self.map, addr, value)\n return\n\n elif len(addr) == 16:\n ipset.ipmap_ipv6_set(self.map, addr, value)\n return\n\n else:\n raise ValueError(\"Invalid address\")","def generateNewAddress(self, currency):\n pass","def set_value(self, address, value):\n\n self.data[address] = value\n\n return True","def set_TX_address(self,address):\n if type(address) is not str: address=chr(address)+'\\x21\\xc8'\n self.usb.write('\\x01'+address)\n self.usb.flush()\n n=ord(self.usb.read(1))\n if n&0x80: raise RuntimeError(self.usb.read(n&0x3f))\n return self.usb.read(n) if n else None","def contract_number(self, contract_number):\n\n self._contract_number = contract_number","def set_AccountNumber(self, value):\n super(AddressValidationInputSet, self)._set_input('AccountNumber', value)","def sc_subnet(self, sc_subnet):\n \n self._sc_subnet = sc_subnet","def set_server_address_game_frame(self, address):\n\n self.frames[\"game\"].set_server_address(address)","def address_1(self, address_1):\n\n self._address_1 = address_1","def address1(self, address1):\n\n self._address1 = address1","def set_ipaddress(modulo):\n\n print ('Configuring IP address...')\n\n modulo.write('AT+NETOPEN\\r\\n'.encode())\n\n if _valid_net(modulo): \n try:\n modulo.write('AT+IPADDR\\r\\n'.encode())\n time.sleep(0.1)\n except serial.SerialException:\n print ('... Whitout IP address, try again')\n if _valid_ip(modulo):\n print ('IP address configurated')\n else:\n print ('IP not configurated')\n else:\n print ('Net Already configurated')\n \n data = _read_line(modulo)\n return data","def address_txs(self, address_txs):\n if address_txs is None:\n raise ValueError(\"Invalid value for `address_txs`, must not be `None`\")\n\n self._address_txs = address_txs","def test_set():\n contract = ContractHandler.get(\"DataTokenTemplate\")\n address = contract.address\n\n ContractHandler.set(\"second_name\", contract)\n\n # result format is a tuple of (contract, contract_concise)\n # did it store in (name) key?\n result = ContractHandler._contracts[\"second_name\"]\n assert len(result) == 2\n assert result[0].address == address\n assert isinstance(result[1], ConciseContract)\n\n # did it store in (name, address) key?\n result2 = ContractHandler._contracts[(\"second_name\", address)]\n assert result2 == result","def ssid(self, ssid):\n\n self._ssid = ssid","def ip_address(self, ip_address):\n\n self._ip_address = ip_address","def ip_address(self, ip_address):\n\n self._ip_address = ip_address","def ip_address(self, ip_address):\n\n self._ip_address = ip_address","def set_stig_x(self, target_stig_x):\n raise NotImplementedError","def setAddress(self, addresses):\n self.addr = addresses\n for i in xrange(len(self.addr)):\n if not ':' in self.addr[i]: \n self.addr[i] += ':' + self.port \n self.addr[i] += '/' + self.service","def _stake(self, _stake_value: int) -> None:\n self._system.setStake(_stake_value)","def set_relay_address(self, relay_addr):\n self.relay_addr = self._Address(*relay_addr)","def set_critical_option_source_addresses(self, address):\n if address:\n self.critical_option_source_address = address\n else:\n raise ValueError(\"Provide a non-null string\")","def ChangeAddress(self, newaddress=None):\n if newaddress == None:\n newaddress = self.DefaultAddress\n if self.Address != newaddress: \n self.Bus.Write_uInt8(self.Address,0xF1,0x55)\n self.Bus.Write_UInt8(self.Address,0xF2,0xAA)\n self.Bus.Write_uInt8(self.Address,0xF0,nwewaddress)\n self.Bus.Devices[newaddress]=self.Bus.Devices[self.Address]\n del self.Bus.Devices[self.Address]\n self.Address = newaddress","def set_ip(self, party_ip) -> None:\n\n self._ip = party_ip","def address(self, new_address):\n house_num, street_name, apt_num = new_address\n self._address.house_num = house_num\n self._address.street_name = street_name\n self._address.apt_num = apt_num","def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int]) -> None:\n ...","def set_host_ipaddress(self, sHostIPAddress):\n\t\tcall_sdk_function('PrlVirtNet_SetHostIPAddress', self.handle, sHostIPAddress)","def test_set_default_address(self):\n # Checking current screen\n self.assertExists(\"//ScreenManager[@current=\\\"myaddress\\\"]\", timeout=5)\n # This is for opening side navbar\n self.open_side_navbar()\n # Click to open Address Dropdown\n self.assertExists('//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]', timeout=5)\n self.assertExists(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"]', timeout=5\n )\n self.assertExists(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"][@is_open=false]', timeout=5\n )\n self.cli.wait(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"][@state=\\\"normal\\\"]', timeout=5\n )\n # Click to open Address Dropdown\n self.cli.wait_click(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"]', timeout=5\n )\n self.cli.wait(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"][@state=\\\"normal\\\"]', timeout=5\n )\n # Check the state of dropdown.\n self.assertExists(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"][@is_open=true]', timeout=5\n )\n # List of addresses\n addresses_in_dropdown = self.cli.getattr(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]/IdentitySpinner[@values]', 'values'\n )\n # Checking the dropdown options are exists\n self.assertGreaterEqual(len(self.cli.getattr(\n '//MySpinnerOption[@text]', 'text')), len(addresses_in_dropdown)\n )\n # Selection of an address to set as a default address.\n self.cli.wait_click('//MySpinnerOption[0]', timeout=5)\n\n self.assertExists(\n '//NavigationItem[0][@text=\\\"dropdown_nav_item\\\"]'\n '/IdentitySpinner[@name=\\\"identity_dropdown\\\"][@is_open=false]', timeout=5\n )\n self.cli.sleep(0.5)","def set_I_to_address(self):\n self.I = self.opcode & 0xFFF\n logger.info(\"Set I to {}\".format(hex(self.I)))","def intranet_address(self) -> str:\n return pulumi.get(self, \"intranet_address\")","def setaccount(self, vergeaddress, account):\n return self.proxy.setaccount(vergeaddress, account)","def src_subnet(self, src_subnet):\n\n self._src_subnet = src_subnet","def payToSStx(addr):\n # Only pay to pubkey hash and pay to script hash are\n # supported.\n scriptType = PubKeyHashTy\n if isinstance(addr, addrlib.AddressPubKeyHash):\n if addr.sigType != crypto.STEcdsaSecp256k1:\n raise NotImplementedError(\n \"unable to generate payment script for \"\n \"unsupported digital signature algorithm\"\n )\n elif isinstance(addr, addrlib.AddressScriptHash):\n scriptType = ScriptHashTy\n else:\n raise NotImplementedError(\n \"unable to generate payment script for \"\n \"unsupported address type %s\" % type(addr)\n )\n\n if scriptType == PubKeyHashTy:\n return payToStakePKHScript(addr.scriptAddress(), opcode.OP_SSTX)\n return payToStakeSHScript(addr.scriptAddress(), opcode.OP_SSTX)","def setInt(self, addr: ghidra.program.model.address.Address, value: int) -> None:\n ...","def set_unicast_address(self,serial,address):\n self.set_TX_address(0xff)\n if type(serial) is not str: serial=struct.pack('<BBBHBB',*serial)\n if type(address) is not str: address=chr(address)\n self.send_multicast('\\xb2'+serial+address)","def set_nci(self, nci: int) -> None:\n self.config[\"nci\"] = \"0x{}0\".format(str(nci).zfill(8))","def zaberStoreLocation(self, stage, address):\n\t\tself.zaberSend(stage, self.cmd[\"storeCurrentPosition\"], address)","def set_host_addr(self, addr: str) -> None:\n self.config[\"host_addr\"] = addr","def _get_address(self):\n return self.__address","def pci_address(self, pci_address):\n\n self._pci_address = pci_address"],"string":"[\n \"def set_contract_addr(self, addr):\\n\\t\\tself.contract_addr = addr\\n\\t\\tself._bank_inst = self._w3.eth.contract(\\n\\t\\t\\taddress=self.contract_addr,\\n\\t\\t\\tabi=self._iface[\\\"abi\\\"],\\n\\t\\t)\",\n \"def set_address(self, address):\\n pass\",\n \"def getSicxAddress(self) -> Address:\\n return self._sICX_address.get()\",\n \"def set_Street(self, value):\\n super(AddressValidationInputSet, self)._set_input('Street', value)\",\n \"def address(self, address: str):\\n\\n self._address = address\",\n \"def address(self, address: object):\\n\\n self._address = address\",\n \"def set_address(self, address):\\n if address == \\\"\\\":\\n self.address = Address(\\\"\\\", \\\"\\\", \\\"\\\")\\n else:\\n self.address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def address(self, address):\\n\\n self._address = address\",\n \"def setEthaddr(self):\\n\\t\\tself.ethaddr = self.settings.getKeyValue('ethaddr')\\n\\t\\tself.socket.send('setenv ethaddr ' + self.ethaddr+'\\\\r', 1)\\n\\t\\treturn None\",\n \"def setAddress(self, ip_address):\\n # type: (str)->None\\n\\n self._validator.validate_one(\\n 'address', VALID_OPTS['address'], ip_address)\\n self._ifAttributes['address'] = ip_address\",\n \"def set_address(self, address, defer=False):\\n\\n # The MAXUSB chip handles this for us, so we don't need to do anything.\\n pass\",\n \"def set_address(self,address): \\n new_address = self._format_address(address)\\n self.rs485.write_command('#00?8 {}'.format(new_address))\\n self.rs485.clear_buffers()\\n time.sleep(0.2)\",\n \"def set_address(self, address):\\n self._java_ref.setAddress(address)\",\n \"def test_set_address(self):\\n s1 = System()\\n s1.set_address(\\\"101 St James Rd\\\")\\n self.assertEqual(s1.get_address(), \\\"101 St James Rd\\\")\",\n \"def address(self, address):\\n if address is None:\\n raise ValueError(\\\"Invalid value for `address`, must not be `None`\\\")\\n\\n self._address = address\",\n \"def address(self, address):\\n if self.local_vars_configuration.client_side_validation and address is None: # noqa: E501\\n raise ValueError(\\\"Invalid value for `address`, must not be `None`\\\") # noqa: E501\\n\\n self._address = address\",\n \"def set_sICX_supply(self) -> None:\\n sICX_score = self.create_interface_score(self._sICX_address.get(),\\n sICXTokenInterface)\\n self._sICX_supply.set(sICX_score.totalSupply())\",\n \"def setBaseAddress(self, address):\\n DPxSetDinBuffBaseAddr(address)\",\n \"def setIpaddr(self):\\n\\t\\tself.ipaddr = self.settings.getKeyValue('ipaddr')\\n\\t\\tself.socket.send('setenv ipaddr ' + self.ipaddr+'\\\\r', 1)\\t\\t\\n\\t\\treturn None\",\n \"def szx(self, addr):\\n\\n if self.reg.zerox_flag:\\n self.reg.ip_inc()\\n self.reg.ip_inc()\",\n \"def setSicxSupply(self) -> None:\\n self._sICX_supply.set(self.sICX_score.totalSupply())\",\n \"def stellar_address(self) -> str:\\n return kin_utils.encode_check('account', bytes(self._verify_key)).decode()\",\n \"def set_start_address(address):\\n try:\\n command(address + \\\"P\\\")\\n except EppException as e:\\n print 'No EPROM type is selected, or value is higher than end address.', e.value\",\n \"def _set_address(self, v, load=False):\\n try:\\n t = YANGDynClass(v,base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\\\"address\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"\\\"\\\"address must be of a type compatible with base=[unicode,unicode,unicode,unicode,unicode,], is_leaf=True, yang_name=\\\"address\\\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True\\\"\\\"\\\")\\n self.__address = t\\n if hasattr(self, '_set'):\\n self._set()\",\n \"def setWriteAddress(self, address):\\n DPxSetDinBuffWriteAddr(address)\",\n \"def setData(self,address):\\n self.data = _pack_address(address)\",\n \"def escrow_address(self, escrow_address):\\n\\n self._escrow_address = escrow_address\",\n \"def address(self, address: str):\\n if address is None:\\n raise ValueError(\\\"Invalid value for `address`, must not be `None`\\\") # noqa: E501\\n\\n self._address = address\",\n \"def change_ip(self, address: int) -> None:\\n self.regs[\\\"ip\\\"].write(address)\",\n \"def set_GOST_address(address=None):\\n if not address:\\n address = get_address_from_file()\\n else:\\n f = open(address_file_path, 'w')\\n f.writelines([])\\n f.close()\\n f = os.open(address_file_path, os.O_RDWR)\\n os.write(f, bytes(address, 'utf-8'))\\n os.fsync(f)\\n os.close(f)\\n if test_connection(address, verbose=False):\\n return address\\n else:\\n return False\",\n \"def address(self, address):\\n if address is None:\\n raise ValueError(\\\"Invalid value for `address`, must not be `None`\\\") # noqa: E501\\n\\n self._address = address\",\n \"def set_permitted_ip(address=None, deploy=False):\\n\\n if not address:\\n raise CommandExecutionError(\\\"Address option must not be empty.\\\")\\n\\n ret = {}\\n\\n query = {\\n \\\"type\\\": \\\"config\\\",\\n \\\"action\\\": \\\"set\\\",\\n \\\"xpath\\\": \\\"/config/devices/entry[@name='localhost.localdomain']/deviceconfig/system/permitted-ip\\\",\\n \\\"element\\\": \\\"<entry name='{}'></entry>\\\".format(address),\\n }\\n\\n ret.update(__proxy__[\\\"panos.call\\\"](query))\\n\\n if deploy is True:\\n ret.update(commit())\\n\\n return ret\",\n \"def setup(token_addr: str, box_addr: str) -> None:\\n print(f\\\"\\\\nSetting up Contracts....\\\")\\n tokenContract = pytezos.contract(token_addr)\\n print(f\\\"-- Performing Initial Mint to Admin : {pub_key_hash}\\\")\\n tokenContract.initialMint(None).inject(_async=False)\\n print(\\\"-- Funding Fishcake Box Contract\\\")\\n tokenContract.transfer([{\\\"from_\\\": pub_key_hash, \\\"txs\\\": [\\n {\\\"to_\\\": box_addr, \\\"token_id\\\": 0, \\\"amount\\\": default_fsck_box_fund}]}]).inject(_async=False)\",\n \"def contract(self, contract):\\n\\n self._contract = contract\",\n \"def set_addr(self, addr):\\n Server.t_addresses[threading.get_ident()] = addr\",\n \"def set_device_address(self, value):\\n # Check format\\n if value > 0xFF:\\n raise StationException(\\\"Device addresses must be 1-byte length\\\")\\n # Switch to command mode if necessary\\n if self._sermode == SerialModem.Mode.DATA:\\n self.enter_command_mode()\\n # Run AT command\\n response = self.run_at_command(\\\"ATDA=\\\" + \\\"{0:02X}\\\".format(value) + \\\"\\\\r\\\")\\n if response is None:\\n return False\\n if response[0:2] == \\\"OK\\\":\\n self.devaddress = value\\n return True\\n else:\\n return False\",\n \"def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\\n addr = address.lower()\\n balances = self.addresses[addr] if addr in self.addresses else []\\n balances.append({\\n 'USDC': value_USDC,\\n 'eXRD': value_eXRD,\\n 'LP': value_LP\\n })\\n self.addresses[addr] = balances\",\n \"def stx(self, addr):\\n\\n self.mem.write(addr, self.reg.idx)\",\n \"def _set_address(self, address):\\n for retry in range(0, self.__RETRY_MAX_NUM):\\n sequence = bytearray(address.to_bytes(4, 'big'))\\n sequence.append(self._checksum(sequence))\\n\\n bytes_sent = self._port_handle.write(sequence)\\n if bytes_sent != len(sequence):\\n raise DfuException(\\n 'Serial port write error: tried to'\\n 'send {} bytes, but {} was sent.'.format(\\n len(sequence), bytes_sent))\\n if self._is_acknowledged():\\n break\\n else:\\n raise DfuException('Setting address failed after {} '\\n 'retries.'.format(retry + 1))\",\n \"def set_amf_addr(self, addr: str) -> None:\\n self.config[\\\"amfConfigs\\\"][0][\\\"address\\\"] = addr\",\n \"def set_offset_address(address):\\n command(address + \\\"O\\\")\",\n \"def street(self, street):\\n\\n self._street = street\",\n \"def setAddressSource(self, address_source):\\n # type: (str)->None\\n\\n self._validator.validate_one(\\n 'source', VALID_OPTS['source'], address_source)\\n self._ifAttributes['source'] = address_source\",\n \"def set_adressing(self, addr, set=True):\\n assert addr in [self.ADDRESSING_HORIZ, self.ADDRESSING_VERT], \\\"Addressing must be ADDRESSING_HORIZ or ADDRESSING_VERT.\\\"\\n self.addressing = addr\\n if set:\\n self._set_function()\",\n \"def setInt(self, address: ghidra.program.model.address.Address, value: int) -> None:\\n ...\",\n \"def address_id(self, address_id):\\n\\n self._address_id = address_id\",\n \"def address_id(self, address_id):\\n\\n self._address_id = address_id\",\n \"def set_address(self, new_address, ):\\n self.address.append(new_address)\\n self.save()\",\n \"def set_State(self, value):\\n super(AddressValidationInputSet, self)._set_input('State', value)\",\n \"def ship_to_pickup_address(self, address):\\n self._set('shipping', 'pickup_address_id', address.id)\",\n \"def __init__(self, address):\\n self._address = address\",\n \"def set_remit_to_address(self, remit_to_address):\\n self.remit_to_address = remit_to_address\",\n \"def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int], sIndex: int, size: int) -> None:\\n ...\",\n \"def set(self, addr, value):\\n\\n if len(addr) == 4:\\n ipset.ipmap_ipv4_set(self.map, addr, value)\\n return\\n\\n elif len(addr) == 16:\\n ipset.ipmap_ipv6_set(self.map, addr, value)\\n return\\n\\n else:\\n raise ValueError(\\\"Invalid address\\\")\",\n \"def generateNewAddress(self, currency):\\n pass\",\n \"def set_value(self, address, value):\\n\\n self.data[address] = value\\n\\n return True\",\n \"def set_TX_address(self,address):\\n if type(address) is not str: address=chr(address)+'\\\\x21\\\\xc8'\\n self.usb.write('\\\\x01'+address)\\n self.usb.flush()\\n n=ord(self.usb.read(1))\\n if n&0x80: raise RuntimeError(self.usb.read(n&0x3f))\\n return self.usb.read(n) if n else None\",\n \"def contract_number(self, contract_number):\\n\\n self._contract_number = contract_number\",\n \"def set_AccountNumber(self, value):\\n super(AddressValidationInputSet, self)._set_input('AccountNumber', value)\",\n \"def sc_subnet(self, sc_subnet):\\n \\n self._sc_subnet = sc_subnet\",\n \"def set_server_address_game_frame(self, address):\\n\\n self.frames[\\\"game\\\"].set_server_address(address)\",\n \"def address_1(self, address_1):\\n\\n self._address_1 = address_1\",\n \"def address1(self, address1):\\n\\n self._address1 = address1\",\n \"def set_ipaddress(modulo):\\n\\n print ('Configuring IP address...')\\n\\n modulo.write('AT+NETOPEN\\\\r\\\\n'.encode())\\n\\n if _valid_net(modulo): \\n try:\\n modulo.write('AT+IPADDR\\\\r\\\\n'.encode())\\n time.sleep(0.1)\\n except serial.SerialException:\\n print ('... Whitout IP address, try again')\\n if _valid_ip(modulo):\\n print ('IP address configurated')\\n else:\\n print ('IP not configurated')\\n else:\\n print ('Net Already configurated')\\n \\n data = _read_line(modulo)\\n return data\",\n \"def address_txs(self, address_txs):\\n if address_txs is None:\\n raise ValueError(\\\"Invalid value for `address_txs`, must not be `None`\\\")\\n\\n self._address_txs = address_txs\",\n \"def test_set():\\n contract = ContractHandler.get(\\\"DataTokenTemplate\\\")\\n address = contract.address\\n\\n ContractHandler.set(\\\"second_name\\\", contract)\\n\\n # result format is a tuple of (contract, contract_concise)\\n # did it store in (name) key?\\n result = ContractHandler._contracts[\\\"second_name\\\"]\\n assert len(result) == 2\\n assert result[0].address == address\\n assert isinstance(result[1], ConciseContract)\\n\\n # did it store in (name, address) key?\\n result2 = ContractHandler._contracts[(\\\"second_name\\\", address)]\\n assert result2 == result\",\n \"def ssid(self, ssid):\\n\\n self._ssid = ssid\",\n \"def ip_address(self, ip_address):\\n\\n self._ip_address = ip_address\",\n \"def ip_address(self, ip_address):\\n\\n self._ip_address = ip_address\",\n \"def ip_address(self, ip_address):\\n\\n self._ip_address = ip_address\",\n \"def set_stig_x(self, target_stig_x):\\n raise NotImplementedError\",\n \"def setAddress(self, addresses):\\n self.addr = addresses\\n for i in xrange(len(self.addr)):\\n if not ':' in self.addr[i]: \\n self.addr[i] += ':' + self.port \\n self.addr[i] += '/' + self.service\",\n \"def _stake(self, _stake_value: int) -> None:\\n self._system.setStake(_stake_value)\",\n \"def set_relay_address(self, relay_addr):\\n self.relay_addr = self._Address(*relay_addr)\",\n \"def set_critical_option_source_addresses(self, address):\\n if address:\\n self.critical_option_source_address = address\\n else:\\n raise ValueError(\\\"Provide a non-null string\\\")\",\n \"def ChangeAddress(self, newaddress=None):\\n if newaddress == None:\\n newaddress = self.DefaultAddress\\n if self.Address != newaddress: \\n self.Bus.Write_uInt8(self.Address,0xF1,0x55)\\n self.Bus.Write_UInt8(self.Address,0xF2,0xAA)\\n self.Bus.Write_uInt8(self.Address,0xF0,nwewaddress)\\n self.Bus.Devices[newaddress]=self.Bus.Devices[self.Address]\\n del self.Bus.Devices[self.Address]\\n self.Address = newaddress\",\n \"def set_ip(self, party_ip) -> None:\\n\\n self._ip = party_ip\",\n \"def address(self, new_address):\\n house_num, street_name, apt_num = new_address\\n self._address.house_num = house_num\\n self._address.street_name = street_name\\n self._address.apt_num = apt_num\",\n \"def setBytes(self, addr: ghidra.program.model.address.Address, source: List[int]) -> None:\\n ...\",\n \"def set_host_ipaddress(self, sHostIPAddress):\\n\\t\\tcall_sdk_function('PrlVirtNet_SetHostIPAddress', self.handle, sHostIPAddress)\",\n \"def test_set_default_address(self):\\n # Checking current screen\\n self.assertExists(\\\"//ScreenManager[@current=\\\\\\\"myaddress\\\\\\\"]\\\", timeout=5)\\n # This is for opening side navbar\\n self.open_side_navbar()\\n # Click to open Address Dropdown\\n self.assertExists('//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]', timeout=5)\\n self.assertExists(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"]', timeout=5\\n )\\n self.assertExists(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"][@is_open=false]', timeout=5\\n )\\n self.cli.wait(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"][@state=\\\\\\\"normal\\\\\\\"]', timeout=5\\n )\\n # Click to open Address Dropdown\\n self.cli.wait_click(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"]', timeout=5\\n )\\n self.cli.wait(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"][@state=\\\\\\\"normal\\\\\\\"]', timeout=5\\n )\\n # Check the state of dropdown.\\n self.assertExists(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"][@is_open=true]', timeout=5\\n )\\n # List of addresses\\n addresses_in_dropdown = self.cli.getattr(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]/IdentitySpinner[@values]', 'values'\\n )\\n # Checking the dropdown options are exists\\n self.assertGreaterEqual(len(self.cli.getattr(\\n '//MySpinnerOption[@text]', 'text')), len(addresses_in_dropdown)\\n )\\n # Selection of an address to set as a default address.\\n self.cli.wait_click('//MySpinnerOption[0]', timeout=5)\\n\\n self.assertExists(\\n '//NavigationItem[0][@text=\\\\\\\"dropdown_nav_item\\\\\\\"]'\\n '/IdentitySpinner[@name=\\\\\\\"identity_dropdown\\\\\\\"][@is_open=false]', timeout=5\\n )\\n self.cli.sleep(0.5)\",\n \"def set_I_to_address(self):\\n self.I = self.opcode & 0xFFF\\n logger.info(\\\"Set I to {}\\\".format(hex(self.I)))\",\n \"def intranet_address(self) -> str:\\n return pulumi.get(self, \\\"intranet_address\\\")\",\n \"def setaccount(self, vergeaddress, account):\\n return self.proxy.setaccount(vergeaddress, account)\",\n \"def src_subnet(self, src_subnet):\\n\\n self._src_subnet = src_subnet\",\n \"def payToSStx(addr):\\n # Only pay to pubkey hash and pay to script hash are\\n # supported.\\n scriptType = PubKeyHashTy\\n if isinstance(addr, addrlib.AddressPubKeyHash):\\n if addr.sigType != crypto.STEcdsaSecp256k1:\\n raise NotImplementedError(\\n \\\"unable to generate payment script for \\\"\\n \\\"unsupported digital signature algorithm\\\"\\n )\\n elif isinstance(addr, addrlib.AddressScriptHash):\\n scriptType = ScriptHashTy\\n else:\\n raise NotImplementedError(\\n \\\"unable to generate payment script for \\\"\\n \\\"unsupported address type %s\\\" % type(addr)\\n )\\n\\n if scriptType == PubKeyHashTy:\\n return payToStakePKHScript(addr.scriptAddress(), opcode.OP_SSTX)\\n return payToStakeSHScript(addr.scriptAddress(), opcode.OP_SSTX)\",\n \"def setInt(self, addr: ghidra.program.model.address.Address, value: int) -> None:\\n ...\",\n \"def set_unicast_address(self,serial,address):\\n self.set_TX_address(0xff)\\n if type(serial) is not str: serial=struct.pack('<BBBHBB',*serial)\\n if type(address) is not str: address=chr(address)\\n self.send_multicast('\\\\xb2'+serial+address)\",\n \"def set_nci(self, nci: int) -> None:\\n self.config[\\\"nci\\\"] = \\\"0x{}0\\\".format(str(nci).zfill(8))\",\n \"def zaberStoreLocation(self, stage, address):\\n\\t\\tself.zaberSend(stage, self.cmd[\\\"storeCurrentPosition\\\"], address)\",\n \"def set_host_addr(self, addr: str) -> None:\\n self.config[\\\"host_addr\\\"] = addr\",\n \"def _get_address(self):\\n return self.__address\",\n \"def pci_address(self, pci_address):\\n\\n self._pci_address = pci_address\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7022209","0.668352","0.6504335","0.60547084","0.5994743","0.5949447","0.59453374","0.5931548","0.5931548","0.5931548","0.5931548","0.5931548","0.5931548","0.5931548","0.5931548","0.5877724","0.58283544","0.56609696","0.5632742","0.5621456","0.5613599","0.557624","0.5574531","0.55671555","0.5408116","0.53823256","0.5380349","0.5363514","0.5347638","0.52978736","0.52344966","0.5205238","0.52050716","0.5203898","0.51974815","0.51929826","0.5162689","0.51621777","0.5145271","0.5145155","0.51390725","0.5129224","0.5129192","0.51281244","0.512564","0.51240104","0.51228786","0.5119996","0.5116699","0.511211","0.5076398","0.50593334","0.49995318","0.49995318","0.49924198","0.49784306","0.49766654","0.49620497","0.49565545","0.49521607","0.49420214","0.49329844","0.49260095","0.49209508","0.48831043","0.48829323","0.4870045","0.4862261","0.48622492","0.48541373","0.48462975","0.48434684","0.4841741","0.483794","0.4831504","0.4831504","0.4831504","0.48295793","0.48152214","0.48121315","0.48095328","0.4806783","0.48007002","0.48003966","0.47990003","0.47945186","0.47923595","0.47919023","0.4790061","0.47837514","0.47753704","0.4757365","0.47454128","0.4742884","0.4735615","0.47325954","0.47287744","0.4728632","0.46961826","0.4692"],"string":"[\n \"0.7022209\",\n \"0.668352\",\n \"0.6504335\",\n \"0.60547084\",\n \"0.5994743\",\n \"0.5949447\",\n \"0.59453374\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5931548\",\n \"0.5877724\",\n \"0.58283544\",\n \"0.56609696\",\n \"0.5632742\",\n \"0.5621456\",\n \"0.5613599\",\n \"0.557624\",\n \"0.5574531\",\n \"0.55671555\",\n \"0.5408116\",\n \"0.53823256\",\n \"0.5380349\",\n \"0.5363514\",\n \"0.5347638\",\n \"0.52978736\",\n \"0.52344966\",\n \"0.5205238\",\n \"0.52050716\",\n \"0.5203898\",\n \"0.51974815\",\n \"0.51929826\",\n \"0.5162689\",\n \"0.51621777\",\n \"0.5145271\",\n \"0.5145155\",\n \"0.51390725\",\n \"0.5129224\",\n \"0.5129192\",\n \"0.51281244\",\n \"0.512564\",\n \"0.51240104\",\n \"0.51228786\",\n \"0.5119996\",\n \"0.5116699\",\n \"0.511211\",\n \"0.5076398\",\n \"0.50593334\",\n \"0.49995318\",\n \"0.49995318\",\n \"0.49924198\",\n \"0.49784306\",\n \"0.49766654\",\n \"0.49620497\",\n \"0.49565545\",\n \"0.49521607\",\n \"0.49420214\",\n \"0.49329844\",\n \"0.49260095\",\n \"0.49209508\",\n \"0.48831043\",\n \"0.48829323\",\n \"0.4870045\",\n \"0.4862261\",\n \"0.48622492\",\n \"0.48541373\",\n \"0.48462975\",\n \"0.48434684\",\n \"0.4841741\",\n \"0.483794\",\n \"0.4831504\",\n \"0.4831504\",\n \"0.4831504\",\n \"0.48295793\",\n \"0.48152214\",\n \"0.48121315\",\n \"0.48095328\",\n \"0.4806783\",\n \"0.48007002\",\n \"0.48003966\",\n \"0.47990003\",\n \"0.47945186\",\n \"0.47923595\",\n \"0.47919023\",\n \"0.4790061\",\n \"0.47837514\",\n \"0.47753704\",\n \"0.4757365\",\n \"0.47454128\",\n \"0.4742884\",\n \"0.4735615\",\n \"0.47325954\",\n \"0.47287744\",\n \"0.4728632\",\n \"0.46961826\",\n \"0.4692\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76929194"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84697,"cells":{"query":{"kind":"string","value":"Weekly this function is called to set the top 100 prep address in an arraydb"},"document":{"kind":"string","value":"def _set_top_preps(self) -> None :\n prep_dict = self._system.getPReps(1, 20)\n prep_address_list = prep_dict['preps']\n for each_prep in prep_address_list:\n self._top_preps.put(each_prep['address'])"},"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 partition_geocode(con: sqlite3.Connection, cur: sqlite3.Cursor, quarter: str, county_cht: str):\n cur.execute('''SELECT 土地區段位置或建物區門牌 FROM \"{0}/TRX\"\n WHERE 縣市 = ?\n GROUP BY 土地區段位置或建物區門牌;'''.format(quarter), (county_cht,))\n for address, in cur.fetchall():\n cur.execute('''SELECT GEO.編號\n FROM \"{0}/TRX\" AS TRX, \"{0}/GEO\" AS GEO\n WHERE TRX.編號 = GEO.編號\n AND TRX.土地區段位置或建物區門牌 = ?\n AND GEO.LAT_Avg ISNULL;'''.format(quarter), (address,))\n identities = cur.fetchall()\n if not identities:\n continue\n print(\"[%d] \"%(len(identities)) + address)\n try:\n results = selective_geocode(address)\n except geo.AddressError:\n continue\n if len(results[\"lat\"]) != 5 or len(results[\"lon\"]) != 5:\n continue\n results[\"lat\"].append(sum(results[\"lat\"]) / len(results[\"lat\"]))\n results[\"lon\"].append(sum(results[\"lon\"]) / len(results[\"lon\"]))\n combined = [num for zipped in zip(results[\"lat\"], results[\"lon\"]) for num in zipped]\n values = [(tuple(combined) + identity) for identity in identities]\n cur.executemany('''UPDATE \"{0}/GEO\" SET\n LAT_1 = ?, LON_1 = ?,\n LAT_2 = ?, LON_2 = ?,\n LAT_3 = ?, LON_3 = ?,\n LAT_4 = ?, LON_4 = ?,\n LAT_5 = ?, LON_5 = ?,\n LAT_Avg = ?, LON_Avg = ?\n WHERE 編號 = ?;'''.format(quarter), values)\n con.commit()","def load_presn_search(search, start, end, offset, limit):\n now_local = datetime.now()\n timelimit = timedelta(hours=100)\n server = couchdb.Server(\"http://snoplus:\"+app.config[\"COUCHDB_PASSWORD\"]+\"@\"+app.config[\"COUCHDB_HOSTNAME\"])\n db = server[\"pre-supernova\"]\n \n results = []\n skip = offset\n\n if search == \"run\":\n startkey = [int(start)]\n endkey = [int(end)]\n view = '_design/presn/_view/presn_by_run_date'\n\n elif search == \"date\":\n start_year = start[0:4]\n start_month = start[5:7]\n start_day = start[8:10]\n end_year = end[0:4]\n end_month = end[5:7]\n end_day = end[8:10]\n if start_month[0] == \"0\":\n start_month = start_month[1]\n if end_month[0] == \"0\":\n end_month = end_month[1]\n if start_day[0] == \"0\":\n start_day = start_day[1]\n if end_day[0] == \"0\":\n end_day = end_day[1]\n startkey = [int(start_year), int(start_month), int(start_day)]\n endkey = [int(end_year), int(end_month), int(end_day)]\n view = '_design/presn/_view/presn_by_date_run'\n \n if search == \"run\":\n try:\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\n total = len(all.rows)\n print \"OK, run gives us\", total\n print all\n except:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB.\")\n\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\n try:\n year = row.value[0]\n mon = row.value[1]\n day = row.value[2]\n hour = row.value[3]\n minute = row.value[4]\n sec = row.value[5]\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n run = row.key\n run_id = row.id\n if timediff<timelimit:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n\n elif search == \"date\":\n try:\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\n total = len(all.rows)\n except:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB.\")\n\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\n try:\n year = row.key[0]\n mon = row.key[1]\n day = row.key[2]\n hour = row.key[3]\n minute = row.key[4]\n sec = row.key[5]\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n run = row.value\n run_id = row.id\n if timediff<timelimit:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n return results, total, offset, limit","def update_take_x_ip_requests(limit):\n global ip_report\n\n for remote_host, record in ip_report.items():\n ip_report[remote_host]['requests'] = {k: ip_report[remote_host]['requests'][k] for k in list(ip_report[remote_host]['requests'])[:limit]}","def Process_address(self):\n\n self.data = np.load(self.cache_path, allow_pickle=True)[()]\n\n ID = self.data.keys()\n\n cnt = 0\n for id in tqdm(ID):\n if not 'address' in self.data[id] and 'post' in self.data[id]:\n self.data[id]['address'] = ''\n self.data[id]['location'] = ''\n Q = self.Query_baidu(self.data[id]['post'])\n self.data[id]['address'] = Q['address']\n self.data[id]['location'] = Q['location']\n cnt += 1\n\n print(\"Query %d info\" % cnt)\n\n np.save(self.cache_path, self.data)","def populate_db(dbase):\n # In this order: Iron, Blood, Shadow, Fel, Storm\n wowhead_ids = []\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-8))\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-9))\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-10))\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-11))\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-17))\n item_ids = set(wowhead_ids)\n print(item_ids)\n\n pos = 0\n for item_id in item_ids:\n if pos % 10 == 0:\n print(\"Relic %d of %d\" % (pos, len(item_ids)))\n pos += 1\n import_relic(dbase, item_id)","def load_presn_runs(offset, limit):\n now_local = datetime.now()\n timelimit = timedelta(hours=100)\n server = couchdb.Server(\"http://snoplus:\"+app.config[\"COUCHDB_PASSWORD\"]+\"@\"+app.config[\"COUCHDB_HOSTNAME\"])\n db = server[\"pre-supernova\"]\n results = []\n skip = offset\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\n total = all.total_rows\n offset = all.offset\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\n year = row.key[0]\n mon = row.key[1]\n day = row.key[2]\n hour = row.key[3]\n minute = row.key[4]\n sec = row.key[5]\n run = row.value\n run_id = row.id\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n if timediff<timelimit:\n try:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n results.sort(reverse=True)\n return results, total, offset, limit","def reset_trending_db():\n db.execute(\"SELECT * FROM stocksera_trending ORDER BY count DESC LIMIT 10\")\n top_10 = db.fetchall()\n\n db.execute(\"DELETE FROM stocksera_trending\")\n\n count = 20\n for row in top_10:\n row = list(row)\n row[2] = count\n print(row)\n db.execute(\"INSERT OR IGNORE INTO stocksera_trending VALUES (?, ?, ?, ?)\", tuple(row))\n conn.commit()\n count -= 1","def populate_index(db):\n\tfor url in URL:\n\t\tprint url\n\t\trequest = urllib2.Request(url)\n\t\ttry :\n\t\t\tresponse = urllib2.urlopen(request)\n\t\texcept urllib2.URLError:\n\t\t\tprint \"Network Unreachable \"\n\t\t\tsys.exit()\t\n\t\ttext = html2text(response.read())\n\t\tdb.generate_index(text,url)","def getNextNonUndefinedDataAfter(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address, maxAddr: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","def crawl(db):\n cur = db.cursor()\n\n dailyMax = 3000\n batchNum = 20\n sleeptimeforPubmed = 5\n backstep = 20\n\n cur.execute('select pmid from articles order by pmid desc')\n startingPMID = cur.fetchall()[backstep][0]\n\n\t################\n\t# for testing\n # startingPMID=28315500\n\n cur.execute('truncate table articles')\n for i in range (startingPMID, startingPMID+dailyMax, batchNum):\n PMIDs = \"\"\n\n for j in range (batchNum):\n PMIDs = PMIDs + str(i + j ) +\",\"\n\n url = \"https://www.ncbi.nlm.nih.gov/pubmed/\"+ PMIDs +\"?report=medline&format=text\"\n\n time.sleep(sleeptimeforPubmed)\n http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n r = http.request('GET', url)\n soup = BeautifulSoup(r.data, \"lxml\")\n\n allInfo = unicode(soup.pre.string)\n\n if allInfo.find('PMID- ')<0:\n print url\n print 'extraction complete'\n break\n\n while (allInfo.find('AB -')>0 and allInfo.find('TI -')>0):\n IdIndexStart = allInfo.index('PMID- ')+6\n IdIndexEnd = allInfo.index('\\n', IdIndexStart)\n PMID = allInfo[IdIndexStart:IdIndexEnd]\n\n try:\n tiIndexStart = allInfo.index('TI -')+6\n\n if allInfo.find( 'PG -', tiIndexStart)>0:\n tiIndexEnd = allInfo.index('PG -', tiIndexStart)-1\n elif allInfo.find('LID -', tiIndexStart)>0:\n tiIndexEnd = allInfo.index('LID -', tiIndexStart)-1\n else:\n tiIndexEnd = allInfo.index('AB -', tiIndexStart)-1\n ti = allInfo[tiIndexStart:tiIndexEnd]\n\n except:\n ti =\"\"\n\n abIndexStart = allInfo.index('AB -')+6\n try:\n abIndexEnd = allInfo.index('FAU -', abIndexStart)-1\n except:\n abIndexEnd = abIndexStart + 1000\n ab = ti+\" Abstract:\"+allInfo[abIndexStart:abIndexEnd]\n\n query = \"insert into articles (pmid, abstract) values (\"+ PMID +\", '\"+ ab + \"')\"\n endingPMID = int(PMID)\n\n\n if (endingPMID%10==0):\n print endingPMID\n\n try:\n cur.execute(query)\n db.commit()\n\n except:\n db.rollback()\n\n allInfo = allInfo[abIndexEnd:]\n\n now = datetime.datetime.now()\n query = 'insert into last_pmid (record_date, pmid) values (\"%s\", %d)'%(now, endingPMID)\n cur.execute(query)\n db.commit()","def _reset_top_preps(self) -> None:\n if self._system.getIISSInfo()[\"nextPRepTerm\"] > self._block_height_week.get() + (7 * 43200):\n self._block_height_week.set(self._system.getIISSInfo()[\"nextPRepTerm\"])\n for i in range(len(self._top_preps)):\n self._top_preps.pop()\n self._set_top_preps()","def collector_numbers(db):\n\n # create indicies to make the important queries much faster.\n db.dbase.execute('CREATE INDEX IF NOT EXISTS cnames ON cards (cardname);')\n db.dbase.execute('CREATE INDEX IF NOT EXISTS pubexp ON published (expansion);')\n db.dbase.execute('CREATE INDEX IF NOT EXISTS pubnames ON published (name);')\n\n # get a cursor of the list of sets in the db\n setlist = db.dbase.execute('SELECT abbreviation FROM sets ORDER BY released')\n\n # HACK -- planar chaos split cards\n for scard in ['Boom // Bust', 'Dead // Gone', 'Rough // Tumble']:\n db.dbase.execute('UPDATE cards SET cn_position = 54 WHERE cards.cardname = ?', (scard,))\n\n for expansion in setlist:\n # special case for time spiral\n if expansion[0] == 'TSP':\n cardlist = db.dbase.execute('SELECT DISTINCT published.name,published.rarity FROM published JOIN cards ON cards.cardname = published.name WHERE published.expansion = ? AND cards.virtual = ? ORDER BY CASE published.rarity WHEN ? THEN 2 ELSE 1 END,cards.cn_position, published.name', (expansion[0], 'No', 'S'))\n\n # other sets\n else:\n cardlist = db.dbase.execute('SELECT DISTINCT published.name FROM published JOIN cards ON cards.cardname = published.name WHERE published.expansion = ? AND cards.virtual = ? ORDER BY cards.cn_position, published.name', (expansion[0], 'No'))\n\n cardnumber = 1\n for card in cardlist:\n db.dbase.execute('UPDATE published SET cnum = ? WHERE published.name = ? AND published.expansion = ?', (cardnumber, card[0], expansion[0]) )\n cardnumber += 1","def load_disasters():\n\n print \"Disasters\"\n\n #deletes any data within the table before seeding\n Disaster.query.delete()\n\n\n result_count = 1000\n iteration = 0\n records_returned = 1000\n\n # makes payload requests from FEMA API\n while records_returned == 1000:\n payload = {'$top': result_count,\n '$skip': result_count * iteration,\n '$inlinecount': 'allpages',\n '$filter': 'declarationDate ge \\'1990-01-01T04:00:00.000z\\'',\n '$select': 'disasterNumber,declarationDate,state,incidentType,title,incidentBeginDate,incidentEndDate,placeCode,declaredCountyArea'}\n r = requests.get(\n \"http://www.fema.gov/api/open/v1/DisasterDeclarationsSummaries\",\n params=payload)\n\n # iteration counter, starts at zero, for every iteration add 1\n iteration += 1\n\n disaster_info = r.json()\n metadata = disaster_info['metadata']\n record_count = metadata['count']\n records_returned = len(disaster_info['DisasterDeclarationsSummaries'])\n\n # parsing through the information returned from API\n for incident_dict in disaster_info['DisasterDeclarationsSummaries']:\n disasterNumber = incident_dict.get('disasterNumber')\n declarationDate = incident_dict.get('declarationDate')\n state = incident_dict.get('state')\n incidentType = incident_dict.get('incidentType')\n title = incident_dict.get('title')\n incidentBeginDate = incident_dict.get('incidentBeginDate')\n incidentEndDate = incident_dict.get('incidentEndDate')\n placeCode = incident_dict.get('placeCode')\n declaredCountyArea = incident_dict.get('declaredCountyArea')\n\n \"\"\"Try/Except does two things: the try is doing a check to see if the county is already in the counties tables and if it is, then setting the Disaster.countyArea_id in the disasters table. The except is occuring only when the NoResultFound occurs and is creating the county and adding it to the counties table.\"\"\"\n try:\n #variable county set to \"answer\" of query\n county_check = County.query.filter(County.county_name==declaredCountyArea, County.state_code==state).one()\n\n countyArea_id = county_check.county_id\n\n # creating a county when NoResultFound error occurs\n except NoResultFound:\n\n county = County(state_code=state,\n county_name=declaredCountyArea)\n\n db.session.add(county)\n #!!!!!!!!! ask bonnie about this again !!!!!!!!!!#\n db.session.flush()\n\n countyArea_id = county.county_id\n\n county = County.query.filter(County.county_name==declaredCountyArea, County.state_code==state).one()\n countyArea_id = county.county_id\n\n disaster = Disaster(disasterNumber=disasterNumber,\n state=state,\n declarationDate=declarationDate,\n incidentType=incidentType,\n title=title,\n incidentBeginDate=incidentBeginDate,\n incidentEndDate=incidentEndDate,\n placeCode=placeCode,\n declaredCountyArea=declaredCountyArea,\n countyArea_id=countyArea_id)\n\n db.session.add(disaster)\n\n db.session.commit()\n print \"Disasters and Counties seeded\"","def create_address_data():\r\n print(\"Reading address data file\")\r\n addresses = pd.read_csv(raw_loc + 'san_francisco_addresses.csv')\r\n addresses.columns = map(str.lower, addresses.columns)\r\n\r\n keepcolumns = ['lon', 'lat', 'number', 'street']\r\n addresses = addresses[keepcolumns]\r\n addresses['number'] = addresses['number'].apply(lambda x: re.findall( '\\d+', x)[0]).astype(int)\r\n addresses['address'] = addresses.apply(lambda x: str(x['number']) + \" \" + str(x['street']), axis = 1)\r\n addresses['streetname'] = addresses['street'].apply(return_street)\r\n addresses.drop_duplicates(subset = 'address', inplace = True)\r\n addresses['type'] = 'known'\r\n addresses.to_sql('raw_address_data', if_exists = 'replace', con = conn)\r\n\r\n\r\n print(\"Finding similar addresses\")\r\n df = pd.read_sql_query('Select distinct tickstreetno , tickstreetname , count(*) total_tickets from raw_ticket_data t1'\r\n ' left join raw_address_data t2 on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname '\r\n \" where t2.address is null group by tickstreetno, tickstreetname \", conn)\r\n\r\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\r\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\r\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\r\n df['blocknum'] = df['TickStreetNo'].apply(lambda x: math.ceil(x/100))\r\n df.drop_duplicates(inplace = True)\r\n\r\n df2 = addresses\r\n df2['blocknum'] = df2['number'].apply(lambda x: math.ceil(x/100))\r\n newdf = df.merge(df2, how = 'left', left_on = ['TickStreetName', 'blocknum'], \\\r\n right_on = ['streetname', 'blocknum'])\r\n\r\n\r\n unfound = newdf[pd.isnull(newdf.number)]\r\n unfound['type'] == \"unknown\"\r\n newdf = newdf[pd.isnull(newdf.number) == False]\r\n newdf['delta'] = np.abs(newdf['number'] - newdf['TickStreetNo'])\r\n newdf.sort_values(by = 'delta', inplace = True)\r\n newdf.drop_duplicates(subset = ['TickStreetName', 'TickStreetNo'], keep = 'first', inplace = True)\r\n\r\n newdf = newdf[[ 'lon', 'lat', 'TickStreetNo', 'street', 'address','streetname' ]]\r\n newdf.columns = ['lon', 'lat', 'number', 'street', 'address','streetname' ]\r\n newdf['address'] = newdf['number'].map(str) + ' ' + newdf['street']\r\n newdf.drop_duplicates(inplace = True)\r\n newdf['type'] = 'similar'\r\n newdf.to_sql('raw_address_data', conn, if_exists = 'append')\r\n unfound = unfound[unfound.TickStreetNo < 10000]\r\n\r\n\r\n print(\"Searching for Intersection Addresses\")\r\n #unfound = unfound[(unfound.TickStreetNo < 10000) & (unfound.TickStreetNo > 0)]\r\n isection = unfound[['TickStreetNo','TickStreetName', 'total_tickets']]\r\n isection['address'] = isection['TickStreetName'].apply(return_intersections)\r\n unfound = isection[pd.isnull(isection.address) == True]\r\n isection = isection[pd.isnull(isection.address) == False]\r\n isection = isection.merge(addresses, left_on = 'address', right_on = 'address')\r\n isection = isection[['number', 'streetname', 'street', 'address', 'lat', 'lon']]\r\n isection.to_sql('raw_address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n\r\n print(\"Searching for Unknown Addresses\")\r\n unfound.drop_duplicates(inplace = True)\r\n tqdm.pandas()\r\n unfound['street'] = unfound.apply(lambda x: return_streetname_unknown(x['TickStreetNo'], x['TickStreetName']), axis = 1)\r\n unfound['address'] = unfound.apply(lambda x: str(x['TickStreetNo']) + \" \" + str(x['street']), axis = 1)\r\n numlookup = 5000\r\n print(\"There are \" + str(unfound.shape[0]) + \" addresses we couldn't find, we're goin to lookup \" + str(numlookup))\r\n lookup = unfound.sort_values(by = 'total_tickets', ascending = False)[:numlookup] #CHANGE TO 5000\r\n lookup['coordinates'] = lookup['address'].progress_apply(lambda x: create_locs(x + ' SAN FRANCISCO CA'))\r\n lookup.dropna(subset = ['coordinates'], inplace = True)\r\n lookup['lat'] = lookup['coordinates'].apply(lambda x: x[0])\r\n lookup['lon'] = lookup['coordinates'].apply(lambda x: x[1])\r\n lookup.rename(columns = {'TickStreetNo':'number', 'TickStreetName':'streetname'}, inplace = True)\r\n lookup = lookup[['lat', 'lon', 'street', 'number', 'streetname', 'address']]\r\n unfound = unfound[unfound['address'].isin(lookup['address']) == False]\r\n unfound['type'] = 'unfound'\r\n lookup['type'] = 'searched'\r\n lookup.to_sql('raw_address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n print(\"associating neighborhoods\")\r\n addresses = pd.read_sql_query('Select * from raw_address_data', conn)\r\n addresses['geometry'] = addresses.apply(lambda x: Point(x['lon'], x['lat']), axis = 1)\r\n point = gpd.GeoDataFrame(addresses['geometry'])\r\n point.crs = {'init': 'epsg:4326'}\r\n poly = gpd.GeoDataFrame.from_file(raw_loc+ 'AnalysisNeighborhoods.geojson')\r\n pointInPolys = gpd.tools.sjoin(point, poly, how='left')\r\n addresses['geometry'] = addresses['geometry'].astype(str)\r\n pointInPolys['geometry'] = pointInPolys['geometry'].astype(str)\r\n addresses = addresses.merge(pointInPolys, left_on = 'geometry', right_on = 'geometry')\r\n addresses.drop(columns = ['geometry', 'index', 'index_right'], inplace = True)\r\n addresses.drop_duplicates(subset = 'address', inplace = True)\r\n addresses['number'] = addresses['number'].astype(int)\r\n addresses.to_sql('address_data', conn, if_exists = 'replace')\r\n\r\n\r\n unfound.rename(columns = {'TickStreetNo':'number', 'TickStreetName': 'streetname'}, inplace = True)\r\n unfound.drop(columns = 'total_tickets', inplace = True)\r\n unfound['number'] = unfound['number'].astype(int)\r\n unfound.to_sql('address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n\r\n \"\"\"Function is to separate addresses into those that may have have more than one address associated with a ticket and street name combo. \"\"\"\r\n grouped = addresses.groupby(by = ['number', 'streetname'], as_index = False)['address'].agg('count')\r\n grouped.sort_values(by = 'address', ascending = False)\r\n grouped.columns = ['number', 'streetname', 'count_ad']\r\n single_address = grouped[grouped.count_ad ==1]\r\n single_address = single_address.merge(addresses, left_on = ['number', 'streetname'], right_on = ['number', 'streetname'])\r\n double_address = addresses[addresses.address.isin(single_address['address']) == False]\r\n single_address.to_sql('single_address', conn, if_exists = 'replace')\r\n\r\n return single_address, double_address, addresses","def populate_homes(self, breakdown):\n #check!#\n\n ###your code here###\n tot=self.nx*self.ny\n for n in range(len(breakdown)):\n breakdown[n]=int(round(tot*breakdown[n]))\n for i in range(breakdown[n]):\n new_home=self.empty_homes.pop(random.randrange(len(self.empty_homes)))\n home_address=(new_home.x,new_home.y)\n x=Person(group=n,home=self.homes[home_address])\n self.homes[home_address].occupant=x\n self.people.append(x)","def top10(self, top10: List[Word]):\n\n self._top10 = top10","def complete_databank(port=\"localhost:27017\",coconut_database=\"COCONUT2020-10\",sweetcoconut_database=\"sweetcoconut\"):\n client = MongoClient(port)\n db_complete = client[coconut_database]\n collection = db_complete.uniqueNaturalProduct\n db_complete_only_ring_sugars = pd.DataFrame(list(collection.find({\"contains_ring_sugars\": True})))\n df_complete_tax = pd.DataFrame({\"taxonomy\": db_complete_only_ring_sugars[\"textTaxa\"],\n \"smiles\": db_complete_only_ring_sugars[\"smiles\"],\n \"coconut_id\": db_complete_only_ring_sugars[\"coconut_id\"],\n \"no_sugar_smiles\": db_complete_only_ring_sugars[\"sugar_free_smiles\"]\n })\n complete_names = []\n indexes = []\n for i in range(len(df_complete_tax.taxonomy)):\n # some entries are empty lists\n # doubles\n if df_complete_tax.taxonomy[i] != [] and (\"plants\" in df_complete_tax.taxonomy[i] or \"bacteria\" in df_complete_tax.taxonomy[i] or \"marine\" in df_complete_tax.taxonomy[i] or \"animals\" in df_complete_tax.taxonomy[i] or \"fungi\" in df_complete_tax.taxonomy[i]):\n indexes.append(i)\n complete_names.append(df_complete_tax.taxonomy[i])\n df_five_tax = df_complete_tax.loc[indexes[:]]\n df_tax_id = pd.DataFrame({\"taxonomy\": df_five_tax.taxonomy,\n \"coconut_id\": df_five_tax.coconut_id})\n df_tax_id = df_tax_id.reset_index()\n taxonomies = [\"plants\",\"bacteria\",\"fungi\",\"marine\",\"animals\"]\n biology_names = []\n for row in df_tax_id.taxonomy:\n for name in row:\n if name not in taxonomies:\n biology_names.append(name)\n for biology_name in biology_names:\n for row in df_tax_id.taxonomy:\n if biology_name in row:\n row.remove(biology_name)\n # **------------for tax prediction---------------**\n df_tax_id.to_pickle(\"output_data/for_predict_doubletriple.pkl\")\n # **----------end tax prediction--------------**\n for ind, tax_list in enumerate(df_tax_id.taxonomy):\n if \"marine\" in tax_list:\n #print(ind, tax_list)\n if len(tax_list) > 1:\n df_tax_id.taxonomy[ind].remove(\"marine\")\n else:\n df_tax_id.taxonomy[ind].append(\"no\")\n df_tax_id.taxonomy[ind].remove(\"marine\")\n #df_tax_id.taxonomy[ind] = [\"no\"]\n taxonomy_Double = []\n taxonomy_Triple = []\n taxonomy_single_entry = []\n for ind, tax_list in enumerate(df_tax_id.taxonomy):\n #print(ind, tax_list)\n if len(tax_list) == 1:\n taxonomy_single_entry.append(tax_list[0])\n elif len(tax_list) == 2: \n taxonomy_single_entry.append('double')\n # save original annotation\n taxonomyDouble1 = []\n for tax in tax_list:\n taxonomyDouble1.append(tax)\n taxonomy_Double.append(taxonomyDouble1)\n elif len(tax_list) == 3:\n taxonomy_single_entry.append('triple')\n # save original annotation\n taxonomyTriple1 = []\n for tax in tax_list:\n taxonomyTriple1.append(tax)\n taxonomy_Triple.append(taxonomyTriple1)\n else:\n print('Error: Too many taxonomies for one aglycon','\\n','create a new elif statement in line 102 in tanimoto_index.py')\n df_tax_id_fromCompleteDatabank = pd.DataFrame({\"taxonomy\": taxonomy_single_entry,\n \"coconut_id\": df_five_tax.coconut_id})\n sweetcoconut_databank(df_tax_id_fromCompleteDatabank,taxonomy_Double,sweetcoconut_database,port)","def addresses_per_kvk_to_sql(self):\n\n self.logger.info(\"Start writing the addressees to the sql Addresses table\")\n if self.address_df.index.size == 0:\n self.logger.debug(\"Empty address data frame. Nothing to write\")\n return\n\n # create selection of data columns\n self.address_df[COMPANY_KEY] = None\n columns = [KVK_KEY, NAME_KEY, ADDRESS_KEY, POSTAL_CODE_KEY, CITY_KEY, COMPANY_KEY]\n df = self.address_df[columns].copy()\n df.sort_values([KVK_KEY], inplace=True)\n # count the number of urls per kvk\n\n n_postcode_per_kvk = df.groupby(KVK_KEY)[KVK_KEY].count()\n self.logger.info(f\"Found: {self.n_company} companies\")\n wdg = PB_WIDGETS\n if self.progressbar:\n wdg[-1] = progress_bar_message(0, self.n_company)\n progress = pb.ProgressBar(widgets=wdg, maxval=self.n_company, fd=sys.stdout).start()\n else:\n progress = None\n\n company_list = list()\n for counter, company in enumerate(self.company_vs_kvk):\n kvk_nr = int(company.kvk_nummer)\n # we need to check if this kvk is in de address list still\n\n try:\n n_postcode = n_postcode_per_kvk.loc[kvk_nr]\n except KeyError:\n continue\n\n # add the company number of url time to the list\n company_list.extend([company] * n_postcode)\n\n if progress:\n wdg[-1] = progress_bar_message(counter, self.n_company, kvk_nr, company.naam)\n progress.update(counter)\n if counter % MAX_SQL_CHUNK == 0:\n self.logger.info(\" Added {} / {}\".format(counter, self.n_company))\n if progress:\n progress.finish()\n\n df[COMPANY_KEY] = company_list\n\n self.logger.info(\"Converting addresses to dict. This make take some time...\")\n address_list = list(df.to_dict(orient=\"index\").values())\n\n # turn the list of dictionaries into a sql table\n self.logger.info(\"Start writing table addresses\")\n n_batch = int(len(address_list) / MAX_SQL_CHUNK) + 1\n if self.progressbar:\n wdg = PB_WIDGETS\n wdg[-1] = progress_bar_message(0, self.n_company)\n progress = pb.ProgressBar(widgets=wdg, maxval=n_batch, fd=sys.stdout).start()\n else:\n progress = None\n with self.database.atomic():\n for cnt, batch in enumerate(pw.chunked(address_list, MAX_SQL_CHUNK)):\n self.logger.info(\"Address chunk nr {}/{}\".format(cnt + 1, n_batch))\n self.AddressTbl.insert_many(batch).execute()\n if progress:\n wdg[-1] = progress_bar_message(cnt, n_batch)\n progress.update(cnt)\n if progress:\n progress.finish()","def pagerank(self, limit=20):\r\n\t\tfor urlid in self.url_ids:\r\n\t\t\tself.all_scores[urlid] = 1.0\r\n\r\n\t\tfor i in range(limit):\r\n\t\t\tfor urlid in self.url_ids:\r\n\t\t\t\tscore = self.all_scores[urlid]\r\n\t\t\t\tfor fromid in self.from_ids[urlid]:\r\n\t\t\t\t\tscore += self.all_scores[fromid] / \\\r\n\t\t\t\t\t\t\t (len(self.from_ids[fromid])+len(self.to_ids[fromid]))\r\n\t\t\t\tscore *= 0.85\r\n\t\t\t\tscore += 0.15\r\n\t\t\t\tself.all_scores[urlid] = score\r\n\t\tself.save_pr()","def topstreet_pub(self):\n out=self.df.withColumn('street', split(col('address'), ',')[0]) \\\n .groupby('street').agg(count('name').alias('st_count')) \\\n .sort(desc(\"st_count\")).select(\"street\").limit(1) \n out.withColumnRenamed('street','street which has highest number of pubs') \\\n .write.mode(\"overwrite\").csv('{}streetname/'.format(self.target))\n\n return out.rdd.map(lambda l:l.street).collect()","def update_db(bus_id=def_id):\n # Instantiate the SQL class for the business data we will be pulling\n sql = Sql(bus_id)\n\n # Check if we have previously analyzed the requested business\n # If not, pull the raw data and processing the data\n if sql.check() is not False:\n print \"Already in database!\"\n return\n\n # Get business data (name, country, etc) from Yelp API\n # Limited to 25,000 Yelp API calls per day\n # There are over 4 million reviews and over 140,000 businesses in database\n while True:\n try:\n bus_info = Yelp(bus_id)\n break\n except ValueError:\n pass\n except YelpAPI.YelpAPIError:\n return\n\n # Grab review text from SQL database\n sql.pull_reviews()\n\n # Use our trained XGBoost Classifier and TFIDF vectorizer\n # to determine whether each review is \"Favorable\" or \"Unfavorable\"\n model.predict(sql.reviews)\n\n # Conduct sentiment analysis and evaluate word counts in order to\n # \"penalize\" the weighting of reviews that don't fit the threshold\n nlp = Nlp(sql.reviews, sql.stars, model.preds,\n bus_info.name, bus_info.country, bus_info.city)\n\n # Assign variables from all the objects attributes we created\n # and then input them into a tuple.\n # The tuple is used to populate the SQL database for faster lookup of\n # our analysis at a later time\n # The tuple is also used to populate our dictionary which will be\n # used for variables that will be rendered on our website\n name = nlp.name\n city = nlp.city\n country = nlp.country\n old_rating = int(100 * nlp.stars_avg / 5)\n new_rating = int(nlp.new_rating * 100)\n rev_count = len(sql.reviews)\n count_5 = sql.stars.count(5)\n count_4 = sql.stars.count(4)\n count_3 = sql.stars.count(3)\n count_2 = sql.stars.count(2)\n count_1 = sql.stars.count(1)\n fav_count = (model.preds == 1).sum()\n unfav_count = (model.preds == 0).sum()\n avg_wts = int(100*sum(nlp.avg_wts) / len(nlp.avg_wts))\n bus_tup = (bus_id, name, city, country, old_rating, new_rating,\n rev_count, count_5, count_4, count_3, count_2, count_1,\n fav_count, unfav_count, avg_wts)\n sql.insert(bus_tup)\n print bus_tup","def query_all():\n all_nutrients = {}\n offset_counter = 0\n\n while offset_counter <= 7500:\n query_string = 'https://api.nal.usda.gov/ndb/nutrients/?format=json&api_key={}&nutrients=205&nutrients=204&nutrients=208&nutrients=269&offset={}'.format(api_key, offset_counter)\n results = requests.get(query_string)\n all_nutrients[offset_counter] = results.json()\n offset_counter += 150\n\n print all_nutrients","def address_to_update(id,con,cur):\n\n psql=f\"\"\"select line1,line2,city,state,postal_code,country from address where extern_client_id='{id}'\"\"\"\n cur.execute(psql)\n record=cur.fetchall()\n \n address={'line1':record[0][0],\n 'line2':record[0][1],\n 'city':record[0][2],\n 'state':record[0][3],\n 'postal_code':record[0][4],\n 'country':record[0][5]}\n return address","def _process_pub_dbxref(self, limit):\n\n if self.testMode:\n g = self.testgraph\n else:\n g = self.graph\n model = Model(g)\n raw = '/'.join((self.rawdir, 'pub_dbxref'))\n logger.info(\"processing pub_dbxref\")\n\n line_counter = 0\n\n with open(raw, 'r') as f:\n filereader = csv.reader(f, delimiter='\\t', quotechar='\\\"')\n f.readline() # read the header row; skip\n for line in filereader:\n (pub_dbxref_id, pub_id, dbxref_id, is_current) = line\n # 49648\t43222\t395730\tt\n\n pub_key = pub_id\n pub_id = self.idhash['publication'][pub_key]\n\n if self.testMode and int(pub_key) not in self.test_keys['pub']:\n continue\n\n # get any dbxrefs for pubs, including pmids and dois\n dbxref_key = dbxref_id\n if str(dbxref_key) in self.dbxrefs:\n dbxrefs = self.dbxrefs[str(dbxref_key)]\n # pub_dbs = [75, 51, 76, 95, 126]\n pmid_ids = [50, 77, 275, 286, 347]\n # flybase_ids = [4] # TODO unused\n isbn = [75, 51]\n for d in dbxrefs:\n dbxref_id = None\n if int(d) in pmid_ids:\n if re.match(r'^PMID', dbxrefs[d]):\n dbxref_id = dbxrefs[d].strip()\n else:\n dbxref_id = 'PMID:'+dbxrefs[d].strip()\n model.makeLeader(dbxref_id)\n elif int(d) in isbn:\n dbxref_id = 'ISBN:'+dbxrefs[d].strip()\n elif int(d) == 161:\n dbxref_id = 'DOI:'+dbxrefs[d].strip()\n # elif int(d) == 4:\n # dbxref_id = 'FlyBase:'+dbxrefs[d].strip()\n\n if dbxref_id is not None:\n reference = Reference(\n g, dbxref_id,\n Reference.ref_types['publication'])\n reference.addRefToGraph()\n model.addSameIndividual(pub_id, dbxref_id)\n line_counter += 1\n\n if not self.testMode \\\n and limit is not None and line_counter > limit:\n break\n\n return","def get_all_from_top_ten(title,users,max = 3):\n \"\"\" ten prolific users \"\"\"\n \"\"\" max : number of user with related followers \"\"\"\n getAllUsers(users,all_users,users_set,proceeded_users,max,user_cpt,title)\n for data in users_set:\n print(data.id)","def setpmidInfo():\n DB = PT.DB\n for p in PT.proteins:\n f = DB[p]['PMID_link']\n #print f\n try:\n auth, tit = t.fetchPMIDSummary(f['text'])\n #print 'got info', tit\n except:\n print 'no pmid'\n try:\n f['authors'] = auth\n f['title'] = tit\n print auth, tit\n #print DB[p]['PMID_link']\n except:\n print 'no dict'\n \n return","def placesBuides():\n con=lite.connect('parking.db')\n cursor=con.cursor()\n cursor.execute(\"SELECT (10-count(*)) FROM parking where placa NOT NULL\")\n row=cursor.fetchone()\n if row:\n print \"El nombre de places disponibles es:\",row[0]\n con.close()","def _BuildAddressBook(self, zone, counter, address):\n if zone not in self.addressbook:\n self.addressbook[zone] = collections.defaultdict(list)\n if str(counter) in self.addressbook[zone]:\n return counter\n self.addressbook[zone][str(counter)].append(address)\n return counter + 1","def get_sorted_cities(db):\n city_rec = {'Vancouver' : 0,\n 'Calgary' : 0,\n 'Edmonton' : 0,\n 'Saskatoon' : 0,\n 'Winnipeg' : 0,\n 'Toronto' : 0} #to simplify the exam I am providing this, but in practice you would build this structure on the fly\n\n #YOUR CODE GOES HERE\n \n\n sales = city_rec.sales\n sorted_sales = sales.sort(reverse = True)\n\n \n for index in range(1, len(sorted_sales)):\n currentValue = sorted_sales[index]\n currentPosition = index\n\n while currentPosition > 0 and compare_function(sorted_sales[currentPosition - 1], currentValue):\n sorted_sales[currentPosition] = array[currentPosition - 1]\n currentPosition = currentPosition - 1\n\n array[currentPosition] = currentValue\n\n return get_sorted_cities(city_rec, sorted_sales)","def populate(self):\n\n NUM_COUNTRIES = 2 # random.randint(1, 4)\n\n # find a suitable hex\n with Timer(\"Creating initial data\", debug=self.debug):\n\n for i in range(NUM_COUNTRIES):\n country, provinces, pops = create_country(self, self.map)\n country.determine_tax_policy()\n self.countries.append(country)","def addQueryArp(self, num=1):\n self.query_arp += num","def build_addresses(self):\n \n from ambry.geo.geocoders import DstkGeocoder\n\n facilities = self.partitions.find(table='facilities')\n\n def address_gen():\n for row in facilities.query(\"SELECT * FROM facilities\"):\n address = \"{}, {}, {} {}\".format(row['dba_address1'], row['dba_city'], 'CA', row['dba_zip_code'])\n yield (address, row)\n\n dstk_service = self.config.service('dstk')\n \n dstk_gc = DstkGeocoder(dstk_service, address_gen())\n \n p = self.partitions.find_or_new(table='facilities_addresses')\n p.clean()\n \n lr = self.init_log_rate(500)\n \n with p.inserter() as ins:\n for i, (k, r, inp_row) in enumerate(dstk_gc.geocode()):\n lr(\"Addresses \"+str(i))\n r['facilities_id'] = inp_row['id']\n ins.insert(r)","def placement_fix():\r\n def func(place):\r\n if place in ['3', '4']:\r\n return '3-4'\r\n elif place in ['5', '6', '7', '8']:\r\n return '5-8'\r\n else:\r\n return place\r\n \r\n for place in decks_coll.find({}):\r\n record_id = place['_id']\r\n decks_coll.update_one({'_id': record_id}, {'$set': {'placement': func(place['placement'])}})","def firstPass(self, priorityBondList=[]):\r\n self.lastRefreshTime = datetime.datetime.now()\r\n if priorityBondList == []:\r\n emptyLines = list(self.df.index)\r\n isins = self.embondsisins + BBGHand + ' Corp'\r\n else:\r\n emptyLines = priorityBondList\r\n isins = self.df.loc[priorityBondList, 'ISIN'] + BBGHand + ' Corp'\r\n isins = list(isins.astype(str))\r\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceLongQuery)\r\n blptsStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\r\n blpts.register(blptsStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n isins = self.rfbondsisins + ' @CBBT Corp'\r\n isins = list(isins.astype(str))\r\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceRFQuery)\r\n blptsStream = StreamWatcher(self, BloombergQuery.FIRSTPASS)\r\n blpts.register(blptsStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n specialBondList = list(set(emptyLines) & set(SPECIALBONDS))\r\n specialIsins = map(lambda x:self.df.at[x,'ISIN'] + BBGHand + ' Corp',specialBondList)\r\n blpts = blpapiwrapper.BLPTS(specialIsins, self.bbgPriceLongSpecialQuery)\r\n specialbondStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\r\n blpts.register(specialbondStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n for bond in emptyLines:\r\n self.updateStaticAnalytics(bond) # This will update benchmarks and fill grid. Has to be done here so all data for benchmarks is ready.\r","async def fetch(self, hostname, **params):\n\n self.source_records.extend(\n await self.source.client.paginate(\n url=_IPAM_ADDR_URL, filters=dict(device=hostname, **params)\n )\n )","def readdata(self, prefix, date, county):\n print('F30A: prefix and date', prefix, date)\n\n filetoread = open(prefix + 'EL30A')\n\n lines = []\n for line in filetoread:\n lines.append(line)\n\n linelimit = len(lines)\n# print('LINELIMIT', linelimit)\n linesub = 0\n while linesub < linelimit:\n line = lines[linesub]\n\n if len(line) < 4:\n linesub += 1\n continue\n if len(line.split()) < 2:\n linesub += 1\n continue\n possiblepctnumber = line[0:4]\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\n self._pctnumber = possiblepctnumber\n self._pctname = line[4:].strip()\n if self._pctnumber not in globalpcts:\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\n else:\n onepct = globalpcts[self._pctnumber]\n\n # here's the new 12 June 2018 kluge to get the numbers\n if 'BALLOTS CAST - TOTAL' in line:\n line = line.replace('.', ' ')\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\n line = line.replace(',', '') # commas in numbers\n\n# linesplit = line.split()\n self._ballots = []\n for item in line.split():\n self._ballots.append(int(item))\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\n onepct.updatefrom30a(self._registered, self._ballots, county)\n globalpcts[self._pctnumber] = onepct\n linesub += 1","def bulk_lookup_rdap(addresses=None, inc_raw=False, retry_count=3, depth=0,\n excluded_entities=None, rate_limit_timeout=60,\n socket_timeout=10, asn_timeout=240, proxy_openers=None):\n\n if not isinstance(addresses, list):\n\n raise ValueError('addresses must be a list of IP address strings')\n\n # Initialize the dicts/lists\n results = {}\n failed_lookups_dict = {}\n rated_lookups = []\n stats = {\n 'ip_input_total': len(addresses),\n 'ip_unique_total': 0,\n 'ip_lookup_total': 0,\n 'lacnic': {'failed': [], 'rate_limited': [], 'total': 0},\n 'ripencc': {'failed': [], 'rate_limited': [], 'total': 0},\n 'apnic': {'failed': [], 'rate_limited': [], 'total': 0},\n 'afrinic': {'failed': [], 'rate_limited': [], 'total': 0},\n 'arin': {'failed': [], 'rate_limited': [], 'total': 0},\n 'unallocated_addresses': []\n }\n asn_parsed_results = {}\n\n if proxy_openers is None:\n\n proxy_openers = [None]\n\n proxy_openers_copy = iter(proxy_openers)\n\n # Make sure addresses is unique\n unique_ip_list = list(unique_everseen(addresses))\n\n # Get the unique count to return\n stats['ip_unique_total'] = len(unique_ip_list)\n\n # This is needed for iteration order\n rir_keys_ordered = ['lacnic', 'ripencc', 'apnic', 'afrinic', 'arin']\n\n # First query the ASN data for all IPs, can raise ASNLookupError, no catch\n bulk_asn = get_bulk_asn_whois(unique_ip_list, timeout=asn_timeout)\n\n # ASN results are returned as string, parse lines to list and remove first\n asn_result_list = bulk_asn.split('\\n')\n del asn_result_list[0]\n\n # We need to instantiate IPASN, which currently needs a Net object,\n # IP doesn't matter here\n net = Net('1.2.3.4')\n ipasn = IPASN(net)\n\n # Iterate each IP ASN result, and add valid RIR results to\n # asn_parsed_results for RDAP lookups\n for asn_result in asn_result_list:\n\n temp = asn_result.split('|')\n\n # Not a valid entry, move on to next\n if len(temp) == 1:\n\n continue\n\n ip = temp[1].strip()\n\n # We need this since ASN bulk lookup is returning duplicates\n # This is an issue on the Cymru end\n if ip in asn_parsed_results.keys(): # pragma: no cover\n\n continue\n\n try:\n\n results = ipasn.parse_fields_whois(asn_result)\n\n except ASNRegistryError: # pragma: no cover\n\n continue\n\n # Add valid IP ASN result to asn_parsed_results for RDAP lookup\n asn_parsed_results[ip] = results\n stats[results['asn_registry']]['total'] += 1\n\n # Set the list of IPs that are not allocated/failed ASN lookup\n stats['unallocated_addresses'] = list(k for k in addresses if k not in\n asn_parsed_results)\n\n # Set the total lookup count after unique IP and ASN result filtering\n stats['ip_lookup_total'] = len(asn_parsed_results)\n\n # Track the total number of LACNIC queries left. This is tracked in order\n # to ensure the 9 priority LACNIC queries/min don't go into infinite loop\n lacnic_total_left = stats['lacnic']['total']\n\n # Set the start time, this value is updated when the rate limit is reset\n old_time = time.time()\n\n # Rate limit tracking dict for all RIRs\n rate_tracker = {\n 'lacnic': {'time': old_time, 'count': 0},\n 'ripencc': {'time': old_time, 'count': 0},\n 'apnic': {'time': old_time, 'count': 0},\n 'afrinic': {'time': old_time, 'count': 0},\n 'arin': {'time': old_time, 'count': 0}\n }\n\n # Iterate all of the IPs to perform RDAP lookups until none are left\n while len(asn_parsed_results) > 0:\n\n # Sequentially run through each RIR to minimize lookups in a row to\n # the same RIR.\n for rir in rir_keys_ordered:\n\n # If there are still LACNIC IPs left to lookup and the rate limit\n # hasn't been reached, skip to find a LACNIC IP to lookup\n if (\n rir != 'lacnic' and lacnic_total_left > 0 and\n (rate_tracker['lacnic']['count'] != 9 or\n (time.time() - rate_tracker['lacnic']['time']\n ) >= rate_limit_timeout\n )\n ): # pragma: no cover\n\n continue\n\n # If the RIR rate limit has been reached and hasn't expired,\n # move on to the next RIR\n if (\n rate_tracker[rir]['count'] == 9 and (\n (time.time() - rate_tracker[rir]['time']\n ) < rate_limit_timeout)\n ): # pragma: no cover\n\n continue\n\n # If the RIR rate limit has expired, reset the count/timer\n # and perform the lookup\n elif ((time.time() - rate_tracker[rir]['time']\n ) >= rate_limit_timeout): # pragma: no cover\n\n rate_tracker[rir]['count'] = 0\n rate_tracker[rir]['time'] = time.time()\n\n # Create a copy of the lookup IP dict so we can modify on\n # successful/failed queries. Loop each IP until it matches the\n # correct RIR in the parent loop, and attempt lookup\n tmp_dict = asn_parsed_results.copy()\n\n for ip, asn_data in tmp_dict.items():\n\n # Check to see if IP matches parent loop RIR for lookup\n if asn_data['asn_registry'] == rir:\n\n log.debug('Starting lookup for IP: {0} '\n 'RIR: {1}'.format(ip, rir))\n\n # Add to count for rate-limit tracking only for LACNIC,\n # since we have not seen aggressive rate-limiting from the\n # other RIRs yet\n if rir == 'lacnic':\n\n rate_tracker[rir]['count'] += 1\n\n # Get the next proxy opener to use, or None\n try:\n\n opener = next(proxy_openers_copy)\n\n # Start at the beginning if all have been used\n except StopIteration:\n\n proxy_openers_copy = iter(proxy_openers)\n opener = next(proxy_openers_copy)\n\n # Instantiate the objects needed for the RDAP lookup\n net = Net(ip, timeout=socket_timeout, proxy_opener=opener)\n rdap = RDAP(net)\n\n try:\n\n # Perform the RDAP lookup. retry_count is set to 0\n # here since we handle that in this function\n results = rdap.lookup(\n inc_raw=inc_raw, retry_count=0, asn_data=asn_data,\n depth=depth, excluded_entities=excluded_entities\n )\n\n log.debug('Successful lookup for IP: {0} '\n 'RIR: {1}'.format(ip, rir))\n\n # Lookup was successful, add to result. Set the nir\n # key to None as this is not supported\n # (yet - requires more queries)\n results[ip] = results\n results[ip]['nir'] = None\n\n # Remove the IP from the lookup queue\n del asn_parsed_results[ip]\n\n # If this was LACNIC IP, reduce the total left count\n if rir == 'lacnic':\n\n lacnic_total_left -= 1\n\n log.debug(\n '{0} total lookups left, {1} LACNIC lookups left'\n ''.format(str(len(asn_parsed_results)),\n str(lacnic_total_left))\n )\n\n # If this IP failed previously, remove it from the\n # failed return dict\n if (\n ip in failed_lookups_dict.keys()\n ): # pragma: no cover\n\n del failed_lookups_dict[ip]\n\n # Break out of the IP list loop, we need to change to\n # the next RIR\n break\n\n except HTTPLookupError: # pragma: no cover\n\n log.debug('Failed lookup for IP: {0} '\n 'RIR: {1}'.format(ip, rir))\n\n # Add the IP to the failed lookups dict if not there\n if ip not in failed_lookups_dict.keys():\n\n failed_lookups_dict[ip] = 1\n\n # This IP has already failed at least once, increment\n # the failure count until retry_count reached, then\n # stop trying\n else:\n\n failed_lookups_dict[ip] += 1\n\n if failed_lookups_dict[ip] == retry_count:\n\n del asn_parsed_results[ip]\n stats[rir]['failed'].append(ip)\n\n if rir == 'lacnic':\n\n lacnic_total_left -= 1\n\n # Since this IP failed, we don't break to move to next\n # RIR, we check the next IP for this RIR\n continue\n\n except HTTPRateLimitError: # pragma: no cover\n\n # Add the IP to the rate-limited lookups dict if not\n # there\n if ip not in rated_lookups:\n\n rated_lookups.append(ip)\n stats[rir]['rate_limited'].append(ip)\n\n log.debug('Rate limiting triggered for IP: {0} '\n 'RIR: {1}'.format(ip, rir))\n\n # Since rate-limit was reached, reset the timer and\n # max out the count\n rate_tracker[rir]['time'] = time.time()\n rate_tracker[rir]['count'] = 9\n\n # Break out of the IP list loop, we need to change to\n # the next RIR\n break\n\n return_tuple = namedtuple('return_tuple', ['results', 'stats'])\n return return_tuple(results, stats)","def update_weekly_total(areacode=AREACODE,areaname=AREA):\n start,stop=model_calcs.RANGE_WEEK\n log.debug(f'Processing {areaname}')\n for week in range(start,stop+1):\n end_day=ons_week.week(week)\n \n week_total=weekly_total(end_day,areacode=areacode,areaname=areaname)\n #print(f'{areaname}: Weektotal for week number {week} ending {end_day}: {week_total}')\n \n if week_total is not None:\n try:\n stored,created=CovidWeek.objects.get_or_create(areacode=areacode,week=week)\n #print(stored.weeklycases)\n if stored.weeklycases != week_total:\n log.debug(f'{areaname}: updating week {week} from {stored.weeklycases} to {week_total}')\n stored.weeklycases=week_total\n stored.areaname=areaname\n stored.save()\n if created:\n stored.nation=ons_week.nation[areacode]\n stored.areaname=areaname\n log.debug(f'Created new entry for week {week} for {areaname}')\n stored.week=week\n stored.save()\n except Exception as e:\n log.error(e)\n log.error(f'No data stored for {areaname} week {week}')\n else:\n log.error(f'Bypassing {areaname} - no data')","def sequence_ingest(self,sequence):\n\t\tdata=self.data\n\t\t\n\t\tcounter=0\n\n\t\tfor item in data[sequence]:\n\t\t\tdatestring=item['specimenDate']\n\t\t\tdate=fetchdate(datestring)\n\t\t\trow,created=DailyCases.objects.get_or_create(specimenDate=date,areacode=item['areaCode'])\n\t\t\trow.areaname=item['areaName']\n\t\t\trow.dailyLabConfirmedCases=item['dailyLabConfirmedCases']\n\t\t\trow.totalLabConfirmedCases=item['totalLabConfirmedCases']\n\t\t\trow.changeInDailyCases=item['changeInDailyCases']\n\t\t\trow.dailyTotalLabConfirmedCasesRate=item['dailyTotalLabConfirmedCasesRate']\n\t\t\trow.previouslyReportedDailyCases=item['previouslyReportedDailyCases']\n\t\t\trow.previouslyReportedTotalCases=item['previouslyReportedTotalCases']\n\t\t\trow.changeInTotalCases=item['changeInTotalCases']\n\t\t\trow.save()\n\t\t\tcounter+=1\n\t\tlog.info(f'Processed: {counter} rows')","def fullAssociative(addresses,block_size,mode,extended=True,pretty_print=True):\n container = LRU(block_size)\n for i in range(block_size):\n container[i] = \" \"\n table = [\" \"]* block_size\n full_table = []\n iterator = 0\n for address in addresses:\n parseResult = parseAddressFA(address)\n tag, address_result = parseResult[\"tag\"], parseResult[\"address_result\"]\n if mode==\"RANDOM\":\n if address_result in table:\n result = Fore.GREEN + \"HIT\" + Style.RESET_ALL\n elif \" \" in table:\n for i in range(0,block_size):\n if \" \" == table[i]:\n table[i] = address_result\n break\n result = Fore.RED + \"MISSED\" + Style.RESET_ALL\n else:\n position = randint(0,block_size - 1)\n result = Fore.YELLOW + \"COLLISION\" + Style.RESET_ALL\n table[position] = address_result\n elif mode==\"LRU\":\n if address_result in MRU2list(container.items()):\n for element in container.items():\n if element[1] == address_result:\n container[element[0]] = address_result\n result = Fore.GREEN + \"HIT\" + Style.RESET_ALL\n elif \" \" in MRU2list(container.items()):\n for element in container.items():\n if element[1] == \" \":\n container[element[0]] = address_result\n break\n result = Fore.RED + \"MISSED\" + Style.RESET_ALL\n for index in range(len(table)):\n if table[index] == \" \":\n table[index] = address_result\n break\n else:\n element2replace = MRU2list(container.items())[block_size-1]\n index = container.peek_last_item()\n container[index] = address_result\n result = Fore.YELLOW + \"COLLISION\" + Style.RESET_ALL\n for index in range(len(table)):\n if table[index] == element2replace:\n table[index] = address_result\n break\n elif mode==\"MRU\":\n if address_result in MRU2list(container.items()):\n for element in container.items():\n if element[1] == address_result:\n container[element[0]] = address_result\n result = Fore.GREEN + \"HIT\" + Style.RESET_ALL\n elif \" \" in MRU2list(container.items()):\n for element in container.items():\n if element[1] == \" \":\n container[element[0]] = address_result\n break\n result = Fore.RED + \"MISSED\" + Style.RESET_ALL\n for index in range(len(table)):\n if table[index] == \" \":\n table[index] = address_result\n break\n else:\n element2replace = MRU2list(container.items())[0]\n container[0] = address_result\n result = Fore.YELLOW + \"COLLISION\" + Style.RESET_ALL\n for index in range(len(table)):\n if table[index] == element2replace:\n table[index] = address_result\n break\n elif mode==\"FIFO\":\n if address_result in table:\n result = Fore.GREEN + \"HIT\" + Style.RESET_ALL\n elif \" \" in table:\n table[iterator] = address_result\n iterator = iterator + 1\n result = Fore.RED + \"MISSED\" + Style.RESET_ALL\n else:\n table[iterator] = address_result\n iterator = iterator + 1\n result = Fore.YELLOW + \"COLLISION\" + Style.RESET_ALL\n if (iterator==block_size):\n iterator = 0\n if(extended):\n full_table.append(flat_list(eval(str([address,tag,address_result,table,result]))))\n else:\n full_table.append(flat_list(eval(str([address,table,result]))))\n if pretty_print:\n t = PrettyTable(headerFA(block_size,extended))\n for row in full_table:\n t.add_row(row)\n print(t)\n return full_table","def make_data(self, limit: int):","def get_268_data(self, dbca_initial_control=None):\n qs_regions = get_sorted_regions()\n\n if dbca_initial_control:\n # get the fires managed by DBCA\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED], initial_control=Agency.DBCA,reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\n else:\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED],reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\n\n pbs_fires_dict = get_pbs_bushfires(outstanding_fires) or []\n\n if not dbca_initial_control:\n self.pbs_fires_dict = pbs_fires_dict\n #logger.info(\"self.pbs_fires_dict: \" + str(self.pbs_fires_dict))\n self.found_fires = [i['fire_id'] for i in self.pbs_fires_dict]\n self.missing_fires = list(set(outstanding_fires).difference(self.found_fires)) # fire_numbers not returned from PB\n\n rpt_map = {}\n for i in pbs_fires_dict: \n region_id = i['region']\n\n exists = [i for r in qs_regions if r.id==region_id]\n if exists:\n if rpt_map.has_key(region_id):\n rpt_map[region_id]['area'] = rpt_map[region_id]['area'] + float(i['area'])\n rpt_map[region_id]['number'] = rpt_map[region_id]['number'] + 1\n \n else:\n rpt_map[region_id] = {\n 'area' : float(i['area']),\n 'number' : 1\n }\n\n else:\n raise Exception(\"PBS Region id({}) Not Found in BFRS\".format(region_id))\n\n return rpt_map","def spotmap(week, bam, pt):\n print('Mapping MCAP data to Metrics... ',end=''), \n bam['Spotfire Data'] = bam.index.to_series().map(pt.fillna(0)['len',week])\n print('Done')\n return bam","def locate(self):\n \n #CONNECT TO API\n api = GoogleV3(api_key = self.google_key)\n\n #INITALIZE ARRAY\n array = []\n\n #START GEOCODING ADDRESSES\n for i in tqdm(range(len(self.df)), desc='Geocoding Addresses'):\n\n \n row = self.df.iloc[i]\n\n #GET ADDRESS VARIABLES\n st_name = row['street_name']\n st_number = row['house_number']\n city = row['city']\n state = row['state/province']\n listing_number = row['listing_number']\n zip = row['postal_code']\n\n\n #FORMAT ADDRESS FOR API\n full_address = str(\"{} {},{},{},{}\".format(st_number, st_name, city, state, zip))\n\n #TRY TO LOCATE WITH GOOGLE\n try:\n \n location = api.geocode(full_address, timeout=10)\n\n lat = location.latitude\n lon = location.longitude\n \n\n info = [lat,lon, listing_number]\n\n array.append(info)\n\n next \n\n #Go to next if you cant locate\n except:\n\n info = [0,0, listing_number]\n\n array.append(info)\n\n next\n\n #CONVERT SERIES TO DATAFRAME\n geo_data = pd.DataFrame(data = array, columns = ['lat', 'lon', 'listing_number'])\n \n #INNER JOIN DATA TO DATAFRAME\n self.df = pd.merge(self.df, geo_data, on= 'listing_number', how = 'inner')","def search_results():\n skip = int(flask.request.args.get(\"skip\", \"0\"))\n limit = int(flask.request.args.get(\"limit\", \"20\"))\n\n obj = {}\n\n # query : will be event kit in case of triage information\n uidstr = flask.request.args.get(\"query\", None)\n\n if uidstr == None:\n obj[\"error\"] = \"Missing search ID\"\n\n uidstr = json.loads(uidstr)\n\n obj[\"query\"] = {}\n obj[\"query\"][\"uid\"] = uidstr\n obj[\"clips\"] = []\n states = backend.get_search_sessions()\n obj[\"sessions\"] = []\n for astate in states:\n obj[\"sessions\"].append(str(astate))\n try:\n uid = uuid.UUID(uidstr)\n state = backend.get_iqr_search_state(uid)\n # use the uid of the state and get the information from the database\n col = str(state.uuid)\n obj[\"collection\"] = col\n searchdb[col].ensure_index([(\"model_id\", pymongo.ASCENDING),(\"probability\", pymongo.DESCENDING) ])\n # Force probabilities\n obj[\"positives\"] = list(state.positives)\n obj[\"negatives\"] = list(state.negatives)\n log = \"\"\n for id in state.positives:\n # log = log + \"Found %d\"%(searchdb[col].find({\"model_id\" : \"FUSION\", \"clip_id\" : id}).count()) + \", \"\n # res = searchdb[col].update({\"model_id\" : \"FUSION\", \"clip_id\" : id}, {\"$set\" : { \"probability\" : 1.0}})\n # log = log + \"Done %d\"%id + \", \"\n news = searchdb[col].find_one({\"model_id\" : \"FUSION\", \"clip_id\" : id})\n news[\"probability\"] = 1.0001\n searchdb[col].save(news)\n log = log + \"Now : \" + str(news)\n\n\n for id in state.negatives:\n # log = log + \"Found %d\"%(searchdb[col].find({\"model_id\" : \"FUSION\", \"clip_id\" : id}).count()) + \", \"\n # res = searchdb[col].update({\"model_id\" : \"FUSION\", \"clip_id\" : id}, {\"$set\" : { \"probability\" : 0.0}})\n # log = log + \"Done %d\"%id + \", \"\n news = searchdb[col].find_one({\"model_id\" : \"FUSION\", \"clip_id\" : id})\n news[\"probability\"] = 0.0\n searchdb[col].save(news)\n log = log + \"Now : \" + str(news)\n\n obj[\"log\"] = log\n\n allres = searchdb[col].find({\"model_id\" : \"FUSION\"}).sort([(\"probability\", pymongo.DESCENDING)]).skip(skip).limit(limit)\n rank = skip + 1\n for one in allres:\n aclip = {}\n aclip[\"score\"] = one[\"probability\"]\n aclip[\"id\"] = \"HVC\" + str(one[\"clip_id\"]).zfill(6)\n clipobj = db[\"clips\"].find_one({\"id\" : \"HVC\" + str(one[\"clip_id\"]).zfill(6)},{\"duration\" : 1})\n aclip[\"duration\"] = clipobj[\"duration\"]\n aclip[\"rank\"] = rank\n rank = rank + 1\n obj[\"clips\"].append(aclip)\n obj[\"count\"] = len(obj[\"clips\"])\n\n except Exception as e:\n obj[\"error\"] = str(type(e)) + \": \" + str(e)\n return jsonify(obj)\n\n obj[\"next\"] = \"http://localhost:5003/iqr/search_results?\" + urllib.urlencode({\"uid\" : uid, \"skip\" : skip+limit } )\n return jsonify(obj)","def main():\n href_list = fundlist.get_fund_list()\n\n single_values = None\n asset_allocations = None\n geo_allocations = None\n sector_allocations = None\n top10_holdings = None\n\n for href in href_list:\n url = 'http://idata.fundata.com' + href\n fund_profile = FundProfileScraper(url)\n\n value_dict = fund_profile.scrape_all_single_value()\n if single_values is None:\n single_values = pd.DataFrame([value_dict.values()],\n columns=value_dict.keys())\n else:\n temp_df = pd.DataFrame(value_dict.values(),\n columns=value_dict.keys())\n single_values.append(temp_df)\n\n asset_allocation_list = fund_profile.scrape_asset_allocation()\n allocations_with_href = [[href, asset_class]\n for asset_class in asset_allocation_list]\n if asset_allocations is None:\n asset_allocations = pd.DataFrame(\n allocations_with_href,\n columns=['href', 'asset_allocation']\n )\n else:\n temp_df = pd.DataFrame(\n allocations_with_href,\n columns=['href', 'asset_allocation']\n )\n asset_allocations.append(temp_df)\n\n\n geo_allocations_list = fund_profile.scrape_geo_allocation()\n geo_allocations_href = [[href, geo_class]\n for geo_class in geo_allocations_list]\n if geo_allocations is None:\n geo_allocations = pd.DataFrame(\n geo_allocations_href,\n columns=['href', 'geo_allocation']\n )\n else:\n temp_df = pd.DataFrame(\n geo_allocations_href,\n columns=['href', 'geo_allocation']\n )\n geo_allocations.append(temp_df)\n\n sector_allocations_list = fund_profile.scrape_sector_allocation()\n sector_allocations_href = [[href, sector_class]\n for sector_class in sector_allocations_list]\n if sector_allocations is None:\n sector_allocations = pd.DataFrame(\n sector_allocations_href,\n columns=['href', 'sector_allocation']\n )\n else:\n temp_df = pd.DataFrame(\n sector_allocations_href,\n columns=['href', 'sector_allocation']\n )\n sector_allocations.append(temp_df)\n\n top10_holding_list = fund_profile.scrape_top10_holdings()\n top10_holding_href = [[href, holding]\n for holding in top10_holding_list]\n if top10_holdings is None:\n top10_holdings = pd.DataFrame(\n top10_holding_href,\n columns=['href', 'holding']\n )\n else:\n temp_df = pd.DataFrame(\n top10_holding_href,\n columns=['href', 'holding']\n )\n top10_holdings.append(temp_df)\n\n time.sleep(randint(1, 5))\n\n single_values.to_pickle('./single_values.pkl')\n asset_allocations.to_pickle('./asset_allocations.pkl')\n geo_allocations.to_pickle('./geo_allocations.pkl')\n sector_allocations.to_pickle('sector_allocations.pkl')\n top10_holdings.to_pickle('top10_holdings.pkl')","def load_street_address(data):\n street_addresses = [address['address1'] for address in data]\n street_address_objects = [StreetAddress(data=street_address)\n for street_address\n in street_addresses]\n StreetAddress.objects.bulk_create(street_address_objects)","def load_restaurants(city):\n session = connect_db()\n # Start offset at 0 to return the first 20 results from Yelp API request\n offset = 0\n\n # Get total number of restaurants for this city\n bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\n result_len = 20\n \n # Get all restaurants for a city and load each restaurant into the database\n # Note: Yelp has a limitation of 1000 for accessible results, so get total results\n # if less than 1000 or get only 1000 results back even if there should be more\n while (1000 > offset) and (result_len==20):\n results = search(bearer_token, 'restaurant', city, offset)\n result_len = len(results['businesses'])\n\n # API response returns a SearchResponse object with accessible attributes\n # response.businesses returns a list of business objects with further attributes\n for business in results['businesses']:\n biz = get_business(bearer_token, business['id'])\n try:\n table.insert(biz)\n except DuplicateKeyError:\n print 'DUPS!'\n\n hour_start_monday = None\n hour_end_monday = None \n hour_start_tuesday = None\n hour_end_tuesday = None\n hour_start_wednesday = None\n hour_end_wednesday = None \n hour_start_thursday = None\n hour_end_thursday = None \n hour_start_friday = None\n hour_end_friday = None \n hour_start_saturday = None\n hour_end_saturday = None \n hour_start_sunday = None\n hour_end_sunday = None\n try:\n yelp_price_level = biz['price']\n except:\n yelp_price_level = None\n try:\n hours_type = biz['hours'][0]['hours_type']\n is_open_now = biz['hours'][0]['is_open_now']\n for item in biz['hours'][0]['open']:\n if item['day'] == 1:\n hour_start_tuesday = item['start']\n hour_end_tuesday = item['end']\n elif item['day'] == 0:\n hour_start_monday = item['start']\n hour_end_monday = item['end']\n elif item['day'] == 2:\n hour_start_wednesday = item['start']\n hour_end_wednesday = item['end']\n elif item['day'] == 3:\n hour_start_thursday = item['start']\n hour_end_thursday = item['end']\n elif item['day'] == 4:\n hour_start_friday = item['start']\n hour_end_friday = item['end']\n elif item['day'] == 5:\n hour_start_saturday = item['start']\n hour_end_saturday = item['end']\n elif item['day'] == 6:\n hour_start_sunday = item['start']\n hour_end_sunday = item['end']\n except:\n hours_type = None\n is_open_now = None\n hour_start_monday = None\n hour_end_monday = None \n hour_start_tuesday = None\n hour_end_tuesday = None\n hour_start_wednesday = None\n hour_end_wednesday = None \n hour_start_thursday = None\n hour_end_thursday = None \n hour_start_friday = None\n hour_end_friday = None \n hour_start_saturday = None\n hour_end_saturday = None \n hour_start_sunday = None\n hour_end_sunday = None\n restaurant = Restaurant(\n yelp_id = business['id'],\n yelp_rating = biz['rating'],\n yelp_review_count = biz['review_count'],\n name = biz['name'],\n phone = biz['phone'],\n yelp_url = biz['url'],\n yelp_price_level = yelp_price_level,\n latitude = biz['coordinates']['latitude'],\n longitude = biz['coordinates']['longitude'],\n hours_type = hours_type,\n is_open_now = is_open_now,\n hour_start_monday = hour_start_monday,\n hour_end_monday = hour_end_monday,\n hour_start_tuesday = hour_start_tuesday,\n hour_end_tuesday = hour_end_tuesday,\n hour_start_wednesday = hour_start_wednesday,\n hour_end_wednesday = hour_end_wednesday, \n hour_start_thursday = hour_start_thursday,\n hour_end_thursday = hour_end_thursday, \n hour_start_friday = hour_start_friday,\n hour_end_friday = hour_end_friday, \n hour_start_saturday = hour_start_saturday,\n hour_end_saturday = hour_end_saturday, \n hour_start_sunday = hour_start_sunday,\n hour_end_sunday = hour_end_sunday, \n is_closed = biz['is_closed'],\n categories = biz['categories'][0]['alias'],\n display_phone = biz['display_phone'],\n location = ' '.join(biz['location']['display_address']),\n location_city = biz['location']['city'],\n location_state = biz['location']['state'],\n location_zip_code = biz['location']['zip_code'],\n location_city_id = biz['location']['city'] + ', ' + biz['location']['state'])\n session.merge(restaurant)\n # Yelp returns only 20 results each time, so need to offset by 20 while iterating\n offset += 20\n print('current offset: ', offset)\n session.commit()","def _setordering_customer_50A(self, val):\n self.swift_obj.OrderingCustomer_A = val\n self.swift_obj.OrderingCustomer_A.swiftTag = '50A'","def process_ticket_data():\r\n c = conn.cursor()\r\n c.execute('Select Count(*) from raw_ticket_data')\r\n totalleft = c.fetchone()[0]\r\n print('{} total rows required'.format(totalleft))\r\n np.random.seed(1)\r\n df_total = pd.read_sql_query('Select Ticketnumber, TickIssueDate, TickIssueTime, ViolationDesc, '\r\n ' VehMake, TickRPPlate, TickStreetNo, TickMeter, Agency, TickBadgeIssued, '\r\n 'TickStreetName , TotalPaid, TotalAmtDue from raw_ticket_data ', conn)\r\n columnlist = df_total.columns.tolist()\r\n df_total.sort_values(by = 'TickIssueDate', inplace = True)\r\n n = 500000\r\n totalsize = df_total.shape[0]\r\n indexes = [i for i in range(0,totalsize, n)]\r\n columnlist = df_total.columns.tolist()\r\n columnlist.append('address')\r\n tqdm.pandas()\r\n j = 1\r\n for i in indexes:\r\n df = df_total[i:i+n]\r\n print('Iteration {} started at {}. {} records left'.format(j, dt.datetime.now().strftime(\"%H:%M\"), totalsize))\r\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\r\n df['ViolationDesc'] = df['ViolationDesc'].apply(lambda x: x.replace('METER DTN','MTR OUT DT'))\r\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\r\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\r\n df['TotalPaid'] = df['TotalPaid'].apply(return_cost)\r\n df['TotalAmtDue'] = df['TotalAmtDue'].apply(lambda x: re.sub('[^1-9]', '', str(x)))\r\n df['TickRPPlate'] = df['TickRPPlate'].apply(lambda x: 'None' if len(re.findall('[\\w+]', str(x))) == 0 else str(x).replace('[^\\w+]', ''))\r\n df['Tdelt'] = df['TickIssueTime'].apply(return_time_delta)\r\n\r\n\r\n df_1 = df.merge(single_address, left_on = ['TickStreetNo', 'TickStreetName'], right_on = ['number', 'streetname'])\r\n df_2 = df.merge(double_address, left_on = ['TickStreetNo', 'TickStreetName'], right_on = ['number', 'streetname'])\r\n\r\n df_2 = df_2.merge(df_1, how = 'left', left_on = ['TickIssueDate', 'TickBadgeIssued', 'nhood'], right_on = ['TickIssueDate', 'TickBadgeIssued', 'nhood'])\r\n df_3 = df_2[pd.isnull(df_2['Tdelt_y'])]\r\n df_2.dropna(subset = ['Tdelt_y'], inplace = True)\r\n df_2['timedelta'] = df_2.apply(lambda x: np.abs(x['Tdelt_y'] - x['Tdelt_x']), axis = 1)\r\n df_2.sort_values(by = 'timedelta', inplace = True)\r\n\r\n df_2.columns = [col.replace('_x', '') for col in df_2.columns]\r\n df_3.columns = [col.replace('_x', '') for col in df_3.columns]\r\n df_2.drop_duplicates(subset = 'TicketNumber', inplace = True)\r\n print(\"Searching for unmatchable addresses\")\r\n df_3['address'] = df_3.progress_apply(return_address, axis = 1)\r\n\r\n df = df_1.append(df_2)\r\n df = df.append(df_3)\r\n df['TickIssueDate'] = df.apply(Time, axis = 1)\r\n df = df[columnlist]\r\n\r\n if i == 0:\r\n df.to_sql('ticket_data', if_exists = 'replace',con = conn)\r\n else:\r\n df.to_sql('ticket_data', if_exists = 'append',con = conn)\r\n\r\n totalsize -= n\r\n j+=1\r\n\r\n del c\r\n\r\n return","def setup_sample_data(no_of_records):\n rows_in_database = [{'id': counter, 'name': get_random_string(string.ascii_lowercase, 20), 'dt': '2017-05-03'}\n for counter in range(0, no_of_records)]\n return rows_in_database","def searchPT(self, vpn, PPN_new):\n if vpn in self.PT:#Mapping exists in page table. \n #vb = self.PT.get(vpn)[1] #\n self.pagehits += 1\n #Update access time for a hit.\n #print(\"PAGE HIT!\")\n for i in range(len(self.memory)):\n page = self.memory[i]\n if page[2] == vpn:\n self.memory[i] = (page[0], self.accesses, vpn)\n break\n\n #self.memory.append((ppn, self.accesses, vpn))\n return self.PT.get(vpn)[0]\n # else:\n # self.pagefaults += 1\n # ppn = self.next_available_PPN() #Get next available page number in memory to load from. \n # self.PT[vpn] = (ppn, 1) #Set page table.\n # self.TLB[vpn] = ppn\n # if len(self.memory) < self.MaxMemPages:\n # self.memory.append((ppn, self.accesses))\n\n else: #Mapping does not exist. \n self.pagefaults += 1 #Not in memory. Must load.\n ppn = self.next_available_PPN() #Get next available page number in memory to load from. \n #LRU_ppn = self.getLRUPPN() #Get frame number to replace. \n #Update memory, PT, and TLB\n removed_memory = False\n removed_ppn = 0\n removed_vpn = 0\n #Update memory FIRST \n if len(self.memory) < self.MaxMemPages:\n self.memory.append((ppn, self.accesses, vpn))\n else: #Need to replace LRU frame number (PPN).\n #print(\"Going to replace page\", ppn)\n for PPN_s, access_num, VPN_S in self.memory:\n if PPN_s == ppn:\n removed_ppn = PPN_s\n removed_vpn = VPN_S\n self.memory.remove((PPN_s,access_num, VPN_S)) #Remove LRU PTE\n self.memory.append((ppn, self.accesses, vpn)) #Replace it with new one. \n break \n removed_memory = True \n #Update page table.\n if len(self.PT) < self.MaxPTEntries:\n self.PT[vpn] = (ppn, 1) #Set page table.\n if len(self.TLB) < self.TLBEntries:\n self.TLB[vpn] = ppn #Set page table.\n\n if removed_memory:\n #Need to replace an entry in TLB AND Page table.\n for VPN_s, PTE in self.PT.items():\n if PTE[0] == removed_ppn:\n self.PT.pop(VPN_s) #Remove LRU PTE\n self.PT[vpn] = (ppn, 1) #Replace it with new one.\n break\n for VPN_S, PPN_S in self.TLB.items():\n if PPN_S == removed_ppn:\n self.TLB.pop(VPN_S) #Remove LRU PTE\n self.TLB[vpn] = ppn #Replace it with new one. \n break \n return ppn","def _prep_data( self, db_device_adapter, db_start, db_end, min_points ):\n msg = f\"Preparing data for {db_device_adapter.name}\"\n AppGlobal.gui.display_info_string( msg )\n #self.logger.debug( f\"_prep_data {db_start}, {db_end}\" )\n\n# set_zero = self.parameters.graph_time_zero # \"max\" # min max\n# units = self.parameters.graph_time_units # \"hour\" # day hour use my converter in future\n\n db_device_name = db_device_adapter.name\n time_data = [] # raw data on time may be timestamp......\n\n inst_pw_data = [] #\n total_power_data = [] #\n\n# ( plug_name, plug_time, measure_type, plug_state, voltage, current, inst_power, total_power )\n\n sql = ( \"SELECT plug_name, plug_time, measure_type, plug_state, voltage, current, inst_power, total_power \" +\n \" FROM plug_measurements WHERE ( plug_time > ? ) AND ( plug_time < ? ) AND ( plug_name = ? ) order by plug_time asc\" )\n\n a_datetime_begin = datetime.datetime.fromtimestamp( db_start )\n# print( f\"a_datetime_begin = { type(a_datetime_begin)} {a_datetime_begin} \" )\n\n a_datetime_end = datetime.datetime.fromtimestamp( db_end )\n# print( f\"a_datetime_end = { type(a_datetime_end)} {a_datetime_end} \" )\n\n db_file_name = AppGlobal.gui.get_db_file_name()\n if not( os.path.isfile( db_file_name )):\n msg = f\"Error: db file does not exist: {db_file_name}\"\n AppGlobal.gui.display_info_string( msg )\n return( None, None, None )\n\n sql_con = lite.connect( db_file_name )\n with sql_con:\n cur = sql_con.cursor()\n# print(f\"db_device_name{db_device_name}\")\n cur.execute( sql , ( db_start, db_end, db_device_name ) )\n\n # get rows one at a time in loop\n while True:\n row = cur.fetchone()\n\n if row is None:\n break\n print( f\"{row} [1] {row[1]} {row[6]}\" )\n\n time_data.append( row[1] )\n inst_pw_data.append( row[6] )\n total_power_data.append( row[7] )\n\n msg = f\"For device {db_device_name}: data points fetched: {len( time_data )}\"\n AppGlobal.gui.display_info_string( msg )\n\n if len( time_data ) < 10:\n msg = f\"Not enough data to process for {db_device_name}\"\n AppGlobal.gui.display_info_string( msg )\n return( None, None, None )\n\n temp = [] # temporary to build new time data will put back ... !! list comp makes this not needed\n\n zero = self.parameters.graph_time_zero.lower()\n if zero in [ \"db_sql_begin\", ]:\n #convert_offset = time_data[0] # sec to minutes\n convert_offset = db_start\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\n self.graph_time_zero = f\"sql select begin( {a_datetime} )\"\n\n elif zero in [ \"data_begin\" ]:\n\n convert_offset = time_data[0]\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\n self.graph_time_zero = f\"first data point( {a_datetime} )\"\n else: # default or error ??\n convert_offset = db_start\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\n self.graph_time_zero = f\"sql select begin( {a_datetime} )\"\n\n# print( f\"parameters say units {self.parameters.graph_time_units}\" )\n units = self.parameters.graph_time_units.lower()\n if units in [ \"min\", \"minutes\" ]:\n convert_factor = 1./60. # sec to minutes\n self.graph_time_units = \"minutes\"\n elif units in [ \"hr\", \"hour\", \"hours\" ]:\n convert_factor = 1./( 60. * 60 )\n self.graph_time_units = \"hours\"\n elif units in [ \"day\", \"days\", ]:\n convert_factor = 1./( 60. * 60 * 24 )\n self.graph_time_units = \"days\"\n else: # seconds\n convert_factor = 1.\n self.graph_time_units = \"seconds\"\n\n temp = [ ( ( x - convert_offset ) * convert_factor ) for x in time_data ] # temp is new time_data\n\n # !! add this for energy zero self.graph_energy_zero = \"absolute\" # \"absolute\" \"first_value\"\n # !! convert to named tuple\n graph_data = ( temp, inst_pw_data, total_power_data )\n\n return graph_data","def _put_reg_prep_in_rc_db(context: 'IconScoreContext', address: 'Address'):\n\n rc_tx_batch: list = context.rc_tx_batch\n block_height: int = context.block.height\n\n tx: 'PRepRegisterTx' = RewardCalcDataCreator.create_tx_prep_reg()\n iiss_tx_data: 'TxData' = RewardCalcDataCreator.create_tx(address, block_height, tx)\n context.storage.rc.put(rc_tx_batch, iiss_tx_data)","def populateNewFields(nadPoints):\n with arcpy.da.UpdateCursor(nadPoints,\n ['SHAPE@X', 'SHAPE@Y', 'longitude', 'latitude', 'Source'],\n spatial_reference=arcpy.SpatialReference(4326)) as cursor:\n for row in cursor:\n row[2] = row[0]\n row[3] = row[1]\n row[4] = 'Utah AGRC'\n cursor.updateRow(row)","def test_ordered_amount(self):\n self.app = self.make_app(argv = ['report', 'project_status', self.examples[\"project\"], '--debug', '-o', \"{'P001_101_index3':10, 'P001_102':20}\"],extensions=['scilifelab.pm.ext.ext_couchdb'])\n handler.register(DeliveryReportController)\n self._run_app()\n data = ast.literal_eval(self.app._output_data['debug'].getvalue())\n ordered = {x[0]:x[4] for x in data['table']}\n self.assertEqual(ordered[\"P001_101_index3\"], 10)\n self.assertEqual(ordered[\"P001_102\"], 20)","def sequence_ingest(self,areacode):\n\t\tdata=self.data[self.data['Area code']==areacode]\n\t\tareaname=data['Area name'].unique().item()\n\t\tlog.debug(f'Ingesting cases from {areacode}: {areaname}')\n\t\t\n\t\tcounter=0\n\t\tfor day in data['Specimen date']:\n\t\t\tdate=fetchdate(day)\n\t\t\trow,created=DailyCases.objects.get_or_create(specimenDate=date,areacode=areacode)\n\t\t\tthis_day=data[data['Specimen date']==day]\n\t\t\trow.areaname=areaname \n\t\t\t#add head(1) (faster than unique() ) to deal with some areas returned twice as part of both UTLA AND LTLA sequences\n\t\t\trow.dailyLabConfirmedCases=this_day['Daily lab-confirmed cases'].head(1).item()\n\t\t\trow.totalLabConfirmedCases=this_day['Cumulative lab-confirmed cases'].head(1).item()\n\t\t\trow.save()\n\t\t\tcounter+=1\n\t\tlog.debug(f'Processed: {counter} rows')","def fill_priority_table(target_table, curs, conn, no_bins=5, no_obs=4):\n tar_ids = list(target_table['TAR_ID'])\n no_bins_1 = [no_bins]*len(target_table)\n noobs_bin_1 = [no_obs]*len(target_table)\n complete_1 = ['00'*no_bins]*len(target_table)\n no_bins_2 = [no_bins]*len(target_table)\n noobs_bin_2 = [no_obs]*len(target_table)\n complete_2 = ['00'*no_bins]*len(target_table)\n urgency = [0]*len(target_table)\n for i in range(0,len(target_table)):\n item = [tar_ids[i], no_bins_1[i], noobs_bin_1[i], complete_1[i], \n no_bins_2[i], noobs_bin_2[i], complete_2[i], urgency[i]]\n connect_database.add_priority_to_database(item, curs, conn)","def _set_top(self, user_n, item_n):\n self.user_n = user_n\n self.item_n = item_n","def reap():\n\n # This might be more efficient by paginating manually and do memcache.get_multi\n for counter in get_all_counters():\n value = memcache.get(counter.key.string_id(), namespace=NAMESPACE)\n # if value is None:\n # continue\n _increment_db(counter, value)\n memcache.decr(counter.key.string_id(), value, namespace=NAMESPACE)\n print 'memcache: %s => %s' % (counter.key.string_id(), memcache.get(counter.key.string_id(), namespace=NAMESPACE))","def getNBMGenerator():\n limit = 100\n basesearchurl = u'http://nbm-asp.adlibhosting.com/wwwopacx/wwwopac.ashx?database=collect&search=object_name=schilderij&output=json&limit=%s&startfrom=%s'\n baseitemurl = u'http://nbm-asp.adlibhosting.com/wwwopacx/wwwopac.ashx?database=collect&search=priref=%s&output=json'\n baseurl = u'http://collectie.hetnoordbrabantsmuseum.nl/Details/collect/%s'\n\n for i in range(0,11):\n searchurl = basesearchurl % (limit, limit * i,)\n searchPage = requests.get(searchurl)\n searchJson = searchPage.json()\n\n for searchrecord in searchJson.get('adlibJSON').get('recordList').get('record'):\n metadata = {}\n priref = searchrecord.get('@attributes').get('priref')\n itemurl = baseitemurl % (priref,)\n url = baseurl % (priref,)\n\n metadata['url'] = url\n\n itempage = requests.get(itemurl)\n itemjson = itempage.json()\n record = itemjson.get('adlibJSON').get('recordList').get('record')[0]\n\n metadata['collectionqid'] = u'Q12013217'\n metadata['collectionshort'] = u'NBM'\n metadata['locationqid'] = u'Q12013217'\n\n #No need to check, I'm actually searching for paintings.\n metadata['instanceofqid'] = u'Q3305213'\n\n # Get the ID. This needs to burn if it's not available\n metadata['id'] = record['object_number'][0]\n metadata['idpid'] = u'P217'\n\n if record.get('Title'):\n metadata['title'] = { u'nl' : record.get('Title')[0].get('title')[0].get('value')[0],\n }\n\n if record.get('Production') and record.get('Production')[0].get('creator')[0]:\n name = record.get('Production')[0].get('creator')[0].get('value')[0]\n if u',' in name:\n (surname, sep, firstname) = name.partition(u',')\n name = u'%s %s' % (firstname.strip(), surname.strip(),)\n metadata['creatorname'] = name\n\n metadata['description'] = { u'nl' : u'%s van %s' % (u'schilderij', metadata.get('creatorname'),),\n u'en' : u'%s by %s' % (u'painting', metadata.get('creatorname'),),\n }\n else:\n metadata['creatorname'] = u'anonymous'\n metadata['description'] = { u'nl' : u'schilderij van anonieme schilder',\n u'en' : u'painting by anonymous painter',\n }\n metadata['creatorqid'] = u'Q4233718'\n\n # Dimensions are available!\n # Material is available\n\n # Set the inception only if start and end is the same\n if record.get('Production_date') and \\\n record.get('Production_date')[0].get('production.date.start') and \\\n record.get('Production_date')[0].get('production.date.end'):\n proddate = record.get('Production_date')[0].get('production.date.start')[0]\n if proddate == record.get('Production_date')[0].get('production.date.end')[0]:\n metadata['inception']=proddate\n\n yield metadata\n\n return","def test_can_lookup_postcode(self):\n postcode_to_lookup = \"SW1A 1AA\"\n os_places_key = self.app.config.get(\"OS_PLACES_API_KEY\")\n addresses = AddressLookup(key=os_places_key).by_postcode(postcode_to_lookup)\n self.assertGreater(len(addresses), 0)\n result_postcode = addresses[0].get(\"DPA\", {}).get(\"POSTCODE\")\n self.assertEqual(result_postcode, postcode_to_lookup)","def get_potential_matches_from_address(self, address):\n\n def get_potential_matches(sub_tokens):\n \n #Create a FTS SQL query using all these tokens\n\n search_tokens = \" & \".join(sub_tokens)\n \n #logger.debug(\"before {}\".format(search_tokens))\n SQL = self.token_SQL.format(search_tokens, limit)\n # logger.debug(SQL)\n try:\n df = pd.read_sql(SQL,self.data_con)\n except DatabaseError as e:\n logger.debug(\"db error\")\n df = pd.DataFrame()\n\n \n return df\n\n return_list = []\n\n logger.debug(\"------------\")\n logger.debug(\"looking for: \" + address.full_address)\n\n tokens = address.tokens_original_order_postcode\n # Get rid of tokens which aren't in AddressBasePremium\n\n if address.tokens_specific_to_general_by_freq:\n tokens_orig = [t for t in tokens if t in address.tokens_specific_to_general_by_freq]\n else:\n tokens_orig = tokens\n tokens_ordered = address.tokens_specific_to_general_by_freq\n limit = self.max_results\n\n #If the address has two token or less, don't even try to match\n if len(tokens)<3:\n return return_list\n\n #Start with full list of tokens \n #and get more general by dropping the tokens left to right\n #at a time until we find a match\n\n\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\n #CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\n #LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\n #TOTTERNHOE, DUNSTABLE LU6 2BZ\n #etc\n\n for tokens in [tokens_orig, tokens_ordered]:\n for i in range(len(tokens)):\n\n sub_tokens = tokens[i:]\n if len(sub_tokens)<3:\n df= pd.DataFrame()\n break\n\n df = get_potential_matches(sub_tokens)\n\n # If there's a single match, then we've very likely found the right address. Return just the one\n # if len(df) == 1:\n # return self.df_to_address_objects(df)\n\n if len(df)>0 and len(df)<limit:\n return_list.extend(self.df_to_address_objects(df))\n break\n\n #Now try going in the opposite direction - i.e. getting rid of the latter\n #parts of the address first\n\n #Do a specific to general search i.e. FTS\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 \n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE\n #1, CHAPEL LANE, TOTTERNHOE, \n #etc\n\n\n for tokens in [tokens_orig, tokens_ordered]:\n for i in range(1,len(tokens)):\n sub_tokens = tokens[:-i]\n if len(sub_tokens)<3: #to make sure it ends with a postcode search\n break\n df = get_potential_matches(sub_tokens)\n\n # If there's a single match, then we've very likely found the right address. Return just the one\n # if len(df) == 1:\n # return self.df_to_address_objects(df)\n\n if len(df)>0 and len(df)<limit:\n return_list.extend(self.df_to_address_objects(df))\n break\n\n if len(df) == 1:\n return self.df_to_address_objects(df)\n\n #If we still haven't found anything make a last ditch attempt by taking random selections\n # of the tokens\n num_tokens = len(tokens_ordered)\n\n if len(return_list) < 1 and num_tokens > 3:\n\n tried = []\n num_tokens = len(tokens_ordered)\n if num_tokens > 10:\n take = num_tokens-5 #at least 6\n elif num_tokens > 8:\n take = num_tokens-4 #at least 5\n elif num_tokens > 3:\n take = num_tokens-1\n\n\n for i in range(self.SEARCH_INTENSITY):\n\n sub_tokens = random.sample(tokens_ordered, take)\n \n # logger.debug(\", \".join(sub_tokens))\n if tuple(sub_tokens) in tried: \n continue\n\n df = get_potential_matches(sub_tokens)\n \n tried.append(tuple(sub_tokens))\n\n if len(df)>0 and len(df)<limit:\n return_list.extend(self.df_to_address_objects(df))\n break\n\n #Finally deduplicate based on text of address \n\n final_list = []\n full_address_set = set()\n for a in return_list:\n if a.full_address not in full_address_set:\n final_list.append(a)\n full_address_set.add(a.full_address)\n\n\n\n\n return final_list","def main():\n # Pull variables from pf\n profileref = pfget('google_mapfeed.pf', profile)\n dbname = profileref['dbname']\n path = profileref['webbase']\n finalfile = '%s/%s' % (path, profileref['file'])\n bufferfile = '%s+' % finalfile\n max_nquakes = 600\n element_fields = ['lat', 'lon', 'depth', 'time', 'local_timestring', 'utc_timestring', 'magnitude', 'auth']\n\n if verbose:\n print \"Start: Creating main JSON file '%s' for all stations at %s\" % (finalfile, time.strftime(\"%a, %d %b %Y %H:%M:%S +0000\", time.gmtime()))\n\n now = time.time()\n # Set time zone\n os.putenv('TZ','US/Pacific')\n time.tzset()\n if verbose:\n print \"The time zone is: %s\" % (time.tzname)[0]\n print \"The current time is: %s\" % now\n\n # Override defaults\n if override_number:\n if verbose:\n print \"Overriding default number of events (%d) with %d\" % (max_nquakes, override_number)\n nquakes = override_number\n else:\n nquakes = max_nquakes\n if override_timerange:\n if verbose:\n print \"Overiding default number of events (%d) with time range %d seconds\" % (max_nquakes, override_timerange)\n nquakes = False\n\n # Database processing\n if verbose:\n print \"Opening database\";\n print \"Number of events requested: %s\" % nquakes\n db = dbopen(dbname, 'r')\n\n '''\n Occasionally there is more than one magnitude for a single orid\n (such as provided by QED). We need the most recent magnitude for\n a given orid, so sort on orid and lddate, then group on orid,\n then get the most recent record number (greatest lddate) for each\n group. Add that to a dictionary we will use later.\n '''\n netmag_dict = {}\n db_netmag = dblookup(db, table='netmag')\n db_netmag.sort(['orid', 'lddate'])\n db_netmag_grp = dbgroup(db_netmag, 'orid')\n if verbose:\n print \"There are %s records\" % db_netmag_grp.query('dbRECORD_COUNT')\n for i in range(db_netmag_grp.query('dbRECORD_COUNT')):\n db_netmag_grp[3] = i\n orid, [dbptr, view, end_record, start_record] = db_netmag_grp.getv('orid', 'bundle')\n if verbose:\n print \"\\t- Iteration: %s: Orid: %s, Start record: %s, End record: %s\"% (i, orid, start_record, end_record)\n db_netmag[3] = end_record - 1\n if verbose:\n print \"\\t\\t- Magnitude: %s, Magtype: %s\" % (db_netmag.getv('magnitude')[0], db_netmag.getv('magtype')[0] )\n magnitude, magtype = db_netmag.getv('magnitude', 'magtype')\n netmag_dict[orid] = { 'rec':end_record, 'magnitude':magnitude, 'magtype':magtype }\n\n '''\n if verbose:\n for key in sorted(netmag_dict.iterkeys()):\n print \"%s: %s\" % (key, netmag_dict[key])\n '''\n\n '''\n Now get the event information\n '''\n db.lookup(table='origin')\n db.join('event')\n if verbose:\n print \"Number of joined records of event and origin tables: %s\" % db.query('dbRECORD_COUNT')\n if override_timerange:\n override_oldest = now - override_timerange\n if verbose:\n print \"Override time defined - get events in the last %s seconds - 'time >= %s'\" % (override_timerange, override_oldest)\n db.subset('time >= %d' % override_oldest)\n if verbose:\n print \"Subset on time. Number of records: %s\" % db.query('dbRECORD_COUNT')\n # Join views\n # db_joined = dbjoin(db, db_netmag)\n\n if verbose:\n print \"Subset orid == prefor\"\n db.subset('orid == prefor')\n if verbose:\n print \"Number of subsetted records: %s\" % db.query('dbRECORD_COUNT')\n print \"Subset for time != NULL\"\n db.subset('time != NULL')\n if verbose:\n print \"Number of subsetted records: %s\" % db.query('dbRECORD_COUNT')\n # We want the most recent first for the comparison with nquakes\n db.sort(['time'], reverse=True)\n if verbose:\n print \"Number of sorted records: %s\" % db.query('dbRECORD_COUNT')\n if nquakes:\n if db.query('dbRECORD_COUNT') > nquakes:\n db[3] = nquakes - 1\n min_time = db.getv('time')[0]\n db.subset(\"time >= %s\" % min_time)\n else:\n override_oldest = now - override_timerange\n if verbose:\n print \"Override time defined - get events in the last %s seconds - time > %s\" % (override_timerange, override_oldest)\n db.subset(\"time >= %s\" % override_oldest)\n # Sort in normal time - we want the most recent events plotted on top\n db.sort(('time'))\n if verbose:\n print \"Number of records without subset on time: %s\" % db.query('dbRECORD_COUNT')\n '''\n Build event dictionary\n '''\n event_dict = {'metadata':{},'events':{}}\n\n '''\n Build metadata dictionary\n '''\n if nquakes:\n event_dict['metadata']['max_nquakes'] = nquakes\n event_dict['metadata']['oldest_time_readable'] = epoch2str( int(min_time), \"%H:%M UTC %A %B %o, %Y\" )\n event_dict['metadata']['oldest_time'] = int(min_time)\n event_dict['metadata']['type'] = 'event_limited'\n elif override_oldest:\n event_dict['metadata']['time_range'] = int(override_timerange)\n event_dict['metadata']['oldest_time_readable'] = epoch2str( int(override_oldest), \"%H:%M UTC %A %B %o, %Y\" )\n event_dict['metadata']['oldest_time'] = int(override_oldest)\n event_dict['metadata']['type'] = 'time_limited'\n event_dict['metadata']['modification_time'] = int(time.time())\n event_dict['metadata']['modification_time_readable'] = epoch2str( int(time.time()), \"%H:%M UTC %A %B %o, %Y\" )\n\n '''\n Build event dictionary\n '''\n events = {}\n for i in range(db.query('dbRECORD_COUNT')):\n db[3] = i\n if verbose:\n epoch_time, orid = db.getv('time', 'orid')\n print \"\\tRecord number is: %s Orid is: %d Time is: %s\" % (db[3], orid, epoch2str(epoch_time, '%Y-%m-%d %H:%M:%S'))\n\n orid = db.getv('orid')[0]\n\n if orid in netmag_dict:\n events[i] = {}\n for ef in element_fields:\n # Parse values\n if ef is 'local_timestring' or ef is 'utc_timestring' or ef is 'time':\n value = dbgetv(db, 'time')[0]\n difference = float(now) - float(value)\n if difference < 6 * 3600:\n color = 'red'\n elif difference < 12 * 3600:\n color = 'orange'\n elif difference < 24 * 3600:\n color = 'yellow'\n elif difference < 72 * 3600:\n color = 'chartreuse'\n elif difference < 168 * 3600:\n color = 'blue'\n else:\n color = 'grey'\n events[i]['color'] = color\n elif ef is 'depth':\n value = dbgetv(db, 'depth')[0]\n elif ef is 'auth':\n value = dbgetv(db, 'auth')[0]\n elif ef is 'magnitude':\n # Magnitude\n # mlval, mbval, msval, magnitudeval, magtypeval = db.getv('ml', 'mb', 'ms', 'magnitude', 'magtype')\n # Null magnitude is -999.00\n magnitudeval = netmag_dict[orid]['magnitude']\n magtypeval = netmag_dict[orid]['magtype']\n if int(magnitudeval) > 0:\n scale = magtypeval\n value = '%.1f' % magnitudeval\n else:\n scale = ''\n value = 'N/A'\n events[i]['scale'] = scale\n else:\n value = dbgetv(db, ef)\n\n # Override formatting for specific fields\n if ef is 'lat' or ef is 'lon':\n value = '%.4f' % value\n elif ef is 'local_timestring':\n value = epoch2str( value, \"%H:%M:%S %Z %A %B %o, %Y\", \"US/Pacific\" )\n elif ef is 'utc_timestring':\n value = epoch2str( value, \"%H:%M:%S UTC %A %B %o, %Y\" )\n events[i][ef] = value\n\n full_lat, full_lon = db.getv('lat', 'lon')\n events[i]['grname'] = (grname(full_lat,full_lon)).title()\n events[i]['srname'] = (srname(full_lat,full_lon)).title()\n\n event_dict['events'] = events\n\n # Dump JSON file\n f = open(bufferfile, 'w') \n json.dump(event_dict, f, sort_keys=True, indent=2)\n f.flush()\n\n # Move the file to replace the older one\n try:\n os.rename(bufferfile, finalfile)\n except OSError:\n print \"Cannot rename JSON file from %s to %s\" % (bufferfile,finalfile)\n\n if verbose:\n print \"End: Creating main JSON file '%s' for all stations %s\" % (finalfile, time.strftime(\"%a, %d %b %Y %H:%M:%S +0000\", time.gmtime()))\n\n db.close()\n return 0","def ranking_by_address_in_ascending_order(filename):\r\n in_address = sort_by_address(filename) #[['201808',1744',희우정로길','5955','69941'],['201808','1743','휘경로길','10483',143839']]\r\n address_dict = {}\r\n for i in in_address:\r\n if i[2] not in address_dict:\r\n address_dict[i[2]] = int(i[-1])\r\n else:\r\n address_dict[i[2]] += int(i[-1]) #주소별로 데이터합산 후 딕셔너리 형태로 저장\r\n \r\n address_dict_items = sorted(address_dict.items()) #데이터정렬후 튜플 in 리스트로 저장\r\n y = []\r\n for i in address_dict_items:\r\n y.append(list(i)) #튜플 in 리스트 형태를 리스트 in 리스트 형태로 변환\r\n for i in range(len(y)):\r\n k = y[i][0]\r\n y[i][0] = y[i][1]\r\n y[i][1] = k #리스트 안에 있는 리스트의 순서를 바꿈 (ex. [행당로,3] -> [3,행당로])\r\n rank = []\r\n count = 0\r\n for i in range(len(y)):\r\n s = 0\r\n x = y[i][0]\r\n for j in range(len(y)):\r\n z = y[j][0]\r\n if x>z:\r\n s += 1\r\n rank.append([y[i][1],s+1])\r\n count += 1\r\n if count == len(y):\r\n break #같은 크기의 데이터에 대해 같은 순위를 부여한다\r\n result_list = []\r\n for i in range(len(rank)):\r\n result_list.append([str(rank[i][1])+'위',rank[i][0]])\r\n return result_list","def query3() :","def fetch(index, outfile):\n populate_index(index, outfile=outfile)","def _partial_dbscan(df, settings, sufix):\n stack = []\n cluster_label = 0\n UNMARKED = -1\n\n df = df.reset_index(drop=True)\n num_ids = len(df)\n eps = settings['eps']\n minPts = settings['minPts']\n columns = settings['feature']\n cluster_col = settings['predCol']\n\n # creating a new tmp_id\n cols = df.columns\n id_col = 'tmp_dbscan'\n i = 0\n while id_col in cols:\n id_col = 'tmp_dbscan_{}'.format(i)\n i += 1\n df[id_col] = ['id{}{}'.format(sufix, j) for j in range(len(df))]\n settings['idCol'] = id_col\n\n C_UNMARKED = \"{}{}\".format(sufix, UNMARKED)\n C_NOISE = \"{}{}\".format(sufix, '-0')\n df[cluster_col] = [C_UNMARKED for _ in range(num_ids)]\n\n df = df.reset_index(drop=True)\n\n for index in range(num_ids):\n point = df.loc[index]\n CLUSTER = point[cluster_col]\n\n if CLUSTER == C_UNMARKED:\n X = _retrieve_neighbors(df, index, point, eps, columns)\n\n if len(X) < minPts:\n df.loc[df.index[index], cluster_col] = C_NOISE\n else: # found a core point and assign a label to this point\n cluster_label += 1\n df.loc[index, cluster_col] = sufix + str(cluster_label)\n for new_index in X: # assign core's label to its neighborhood\n label = sufix + str(cluster_label)\n df.loc[df.index[new_index], cluster_col] = label\n if new_index not in stack:\n stack.append(new_index) # append neighborhood to stack\n while len(stack) > 0:\n # find new neighbors from core point neighborhood\n newest_index = stack.pop()\n new_point = df.loc[newest_index]\n Y = _retrieve_neighbors(df, newest_index,\n new_point, eps, columns)\n\n if len(Y) >= minPts:\n # current_point is a new core\n for new_index_neig in Y:\n neig_cluster = \\\n df.loc[new_index_neig][cluster_col]\n if neig_cluster == C_UNMARKED:\n df.loc[df.index[new_index_neig],\n cluster_col] = \\\n sufix + str(cluster_label)\n if new_index_neig not in stack:\n stack.append(new_index_neig)\n\n settings['clusters'] = df[cluster_col].unique()\n return [df, settings]","def main():\n\tresults = collections.OrderedDict()\n\n\tdb = read_database()\n\tprint(db)\n\tfor name in db.keys():\n\t\tresults[name] = []\n\n\n\tfor i in range(NUMBER_OF_RACES):\n\t\tsimulation = simulate_performance(db)\n\t\tpos = position(simulation)\n\n\t\tfor score, name in enumerate(pos,start = 1):\n\t\t\tresults[name].append(score)\n\t\t\n\n\tprint(results)\n\tresults = list(results.items()) # converts OrderedDict to the list\n\tprint(results)\n\tprint()\n\tprint(\"SORTED SCORES\")\n\tprint(sorted_scores(results))\n\tfor idx, sailor in enumerate(sorted_scores(results), start=1):\n\t\tprint(\"{:>2} {:>10} {:>10}\".format(idx, sailor[0], total_score(sailor)))\n\tss = sorted_scores(results)\n\n\tprint(\"\\n\\n*** PLACINGS ***\")\n\tprint(results)\n\treturn results\n\n\tprint(\"\\n\\n*** THE ORDER ***\")\n\tprint([x[0] for x in sorted_scores(results)])\n\treturn [x[0] for x in sorted_scores(results)]","def per_page():\n return 100","def SitesPredict(Chain, pdb_file, ppdb_ATOM, ProbMap, ScoreThreshold = 0.75, SearchRadius = 5.5, ChemicalElement = 'H'):\n\n ResStart = min(ppdb_ATOM['residue_number'][ppdb_ATOM['chain_id']==Chain]) #First residue number\n ResStop = max(ppdb_ATOM['residue_number'][ppdb_ATOM['chain_id']==Chain]) #Last residue number\n LOCAL_coord = []\n Score = [[],[]]\n\n console_output = sys.stdout \n if(pdb_file[-4:] == '.pdb'):\n OutFile = open(pdb_file[:-4].replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\n elif(pdb_file[-3:] == '.gz'):\n OutFile = open(pdb_file[:-7].replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\n else:\n OutFile = open(pdb_file.replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\n OutFile.close()\n\n #Scan all protein structure assigning scores to each residue\n for i in range(ResStart, ResStop+1):\n # Scan one residue per time \n # Missing residues present in the pdb structure are skipped\n try: \n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==i] # Atoms of residue considered\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\n RES = ppdb_RES['residue_name'].iloc[0]\n REF = RefAtom(RES) # reference atoms(s) for residue considered \n reference_coord = [0.0, 0.0, 0.0]\n add_SearchRadius = 0.0 # For residues with more reference points\n # SearchRadius augmented, adding distance from midpoint\n if(len(REF)==1): \n reference_coord = [ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0], ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0], ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0]] \n else:\n # if more than one atom is used as reference, the mean position is calculated as reference point\n for r in range(0,len(REF)):\n reference_coord[0] += (ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0])\n reference_coord[1] += (ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0])\n reference_coord[2] += (ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]) \n reference_coord[0] /= len(REF)\n reference_coord[1] /= len(REF)\n reference_coord[2] /= len(REF)\n dist = 0.0\n for r in range(0,len(REF)):\n dist += (reference_coord[0]-(ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2+(reference_coord[1]-(ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2+(reference_coord[2]-(ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2 \n dist = np.sqrt(dist)\n add_SearchRadius += dist\n add_SearchRadius /= len(REF)\n \n # Distance from reference point to any other atom of the structure\n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(reference_coord[0],reference_coord[1],reference_coord[2]))\n ppdb_LOCAL = ppdb_ATOM[distances <= (SearchRadius + add_SearchRadius)]\n ppdb_LOCAL = ppdb_LOCAL[ppdb_LOCAL['residue_number']!=i]\t\n \n # Save local environment for residue considered\n # Other residues in LOCAL if their reference point(s) distance from the reference_coord\n # within SearchRadius+add_SearchRadius threshold\n LOCAL = [[RES],[i]]\n for l in ppdb_LOCAL['atom_number']:\n l_index = int(ppdb_LOCAL[ppdb_LOCAL['atom_number']==l].index.to_numpy())\n if(ppdb_LOCAL['atom_name'].loc[l_index] in RefAtom(ppdb_LOCAL['residue_name'].loc[l_index])):\n LOCAL[0].append(ppdb_LOCAL['residue_name'].loc[l_index])\n LOCAL[1].append(ppdb_LOCAL['residue_number'].loc[l_index])\n\n # Conversion to 1-letter format, alphabetically sorted\n for l in range(0,len(LOCAL[0])):\n LOCAL[0][l] = res_1Letter(LOCAL[0][l])\n LOCAL_coord.append(''.join(sorted(LOCAL[0])))\n # Score vector with score for each residue considered\n # assigned from ProbMap\n Score[0].append(i)\n Score[1].append(ScoreLoc(LOCAL_coord[-1], ProbMap))\n except:\n continue\n sortedlist = sorted(zip(Score[1][:],Score[0][:]), reverse=True)\n \n coeffScore = 1. - ScoreThreshold \n highestscoredRES = [] # residue number, score, ref. point coord \n for i in range(0,len(Score[0])):\n if(sortedlist[[i][0]][0]>=coeffScore*sortedlist[[0][0]][0]):\n x, y, z = 0.0, 0.0, 0.0\n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==sortedlist[[i][0]][1]]\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\n for l in range(0,len(RefAtom(ppdb_RES['residue_name'].iloc[0]))):\n # last iloc[0] to consider only first in case of alt_loc\n x += float(ppdb_RES['x_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n y += float(ppdb_RES['y_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n z += float(ppdb_RES['z_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n x /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n y /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n z /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n highestscoredRES.append([sortedlist[[i][0]][1],sortedlist[[i][0]][0], x, y, z])\n highestscoredRES_df = pd.DataFrame([row[2:5] for row in highestscoredRES], columns=['x','y','z'], index=[row[0] for row in highestscoredRES])\n highestscoredRES_dmatrix = pd.DataFrame(distance_matrix(highestscoredRES_df.values,highestscoredRES_df.values), index=highestscoredRES_df.index, columns=highestscoredRES_df.index)\n\n # nearby (closer than 2*Searchradius) residues grouped in clusters\n # producing 1 predicted site for each group\n Clusters = []\n possibleCluster = []\n for rw in range(0,len(highestscoredRES_dmatrix.index.values)):\n possibleCluster = []\n for cl in range(0,len(highestscoredRES_dmatrix.index.values)):\n if(any(highestscoredRES_dmatrix.index.values[cl] in row for row in Clusters)):\n continue \n else:\n if(highestscoredRES_dmatrix.values[rw][cl]<2*SearchRadius): \n if(any(highestscoredRES_dmatrix.index.values[rw] in row for row in Clusters)):\n # residue added to group already existing\n Clusters[[Clusters.index(row) for row in Clusters if (highestscoredRES_dmatrix.index.values[rw]) in row][0]].append(highestscoredRES_dmatrix.index.values[cl])\n else:\n possibleCluster.append(highestscoredRES_dmatrix.index.values[cl])\n if(len(possibleCluster)>0):\n Clusters.append(possibleCluster)\n # highestscoredRES contains RES number, score, x_pos, y_pos, z_pos for each residue\n # in case of residues with more than one reference atom, midpoint is calculated\n for i in range(0,len(Clusters)):\n if(len(Clusters[i][:])==1):\n # append closest highest scored within threshold\n for j in range(0,len(Score[0])): \n if(sortedlist[[j][0]][1] != Clusters[i][0]):\n x, y, z = 0.0, 0.0, 0.0\n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==sortedlist[[j][0]][1]]\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\n for l in range(0,len(RefAtom(ppdb_RES['residue_name'].iloc[0]))):\n #last iloc[0] to consider only first in case of alt_loc\n x += float(ppdb_RES['x_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n y += float(ppdb_RES['y_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n z += float(ppdb_RES['z_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\n x /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n y /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n z /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\n x_c = ([row[2] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\n y_c = ([row[3] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\n z_c = ([row[4] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\n if(np.sqrt((x-x_c)**2+(y-y_c)**2+(z-z_c)**2)<2*(SearchRadius)):\n Clusters[i].append(sortedlist[[j][0]][1])\n if(sortedlist[[j][0]][0]>=coeffScore*([row[1] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]):\n highestscoredRES.append([sortedlist[[j][0]][1],sortedlist[[j][0]][0], x, y, z])\n else:\n highestscoredRES.append([sortedlist[[j][0]][1],coeffScore*([row[1] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])], x, y, z])\n break \n else:\n continue\n # For each cluster xyz coord for site predicted as weighted average\n # between positions of RefAtom for each residue\n # weight depending on the score of the residue\n # Each predicted location is scored based on surrounding residues\n # within 0.6*SearchRadius \n # if the site is farther than SearchRadius from any protein atom the site is discarded\n # (possible for sites predicted in bulk water)\n for j in range(0,len(Clusters)):\n x_avg, y_avg, z_avg = 0.0, 0.0, 0.0\n sumWeights = 0.0\n for k in range(0,len(Clusters[j])):\n resindex = [row[0] for row in highestscoredRES].index(Clusters[j][k])\n x_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][2]\n y_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][3]\n z_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][4]\n sumWeights += highestscoredRES[resindex][1]\n x_avg /= sumWeights \n y_avg /= sumWeights \n z_avg /= sumWeights\n\t# site discarded if farther than SearchRadius from any protein atom the site \n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(x_avg,y_avg,z_avg))\n if(min(distances)>SearchRadius):\n break \t\n # during the loop coordinations temporary written in the output file\n # edited at the end of the loop according to xyz files formatting\n # and sorting predicted sites based on score\n if(pdb_file[-4:] == '.pdb'):\n sys.stdout = OutFile = open(pdb_file[:-4].replace('../','')+'_PredictedSites.xyz', 'a')\n elif(pdb_file[-3:] == '.gz'):\n sys.stdout = OutFile = open(pdb_file[:-7].replace('../','')+'_PredictedSites.xyz', 'a')\n else:\n sys.stdout = OutFile = open(pdb_file.replace('../','')+'_PredictedSites.xyz', 'a')\n\n sys.stdout.write('\\n'+ChemicalElement+'\\t'+str(x_avg)+'\\t'+str(y_avg)+'\\t'+str(z_avg))\n # Score the predicted location based on surrounding residues\n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(x_avg,y_avg,z_avg))\n ppdb_LOCAL = ppdb_ATOM[distances <= 0.6*SearchRadius]\n SITE_coord = ''\n for l in ppdb_LOCAL.index.tolist():\n if(ppdb_LOCAL['atom_name'].loc[l] in RefAtom(ppdb_LOCAL['residue_name'].loc[l])):\n SITE_coord += str(res_1Letter(ppdb_LOCAL['residue_name'].loc[l])) \n # site score added last column in the temporary output file\n sys.stdout.write('\\t'+str(ScoreLoc(''.join(sorted(SITE_coord)), ProbMap)))\n OutFile.close()\n sys.stdout = console_output","def set_top_unique_num(self, number):\n self.top_unique_num = number","def set_address_values(layer):\n cursor = arcpy.SearchCursor(layer)\n for row in cursor:\n layer_fields = arcpy.ListFields(layer)\n for x in range(len(layer_fields)):\n layer_fields[x] = layer_fields[x].name\n for key in address_dict:\n if key in layer_fields and address_dict.get(key) is None:\n address_dict[key] = row.getValue(key)","def test1 (self, testStore, dbh, dbn, dbu, dbp):","def __init__(self):\n array = db.getDataFromString(\"execute [dbo].[ranking] '1/1/2016', 365\")\n self.ranking = {}\n for i in array:\n if i[0] not in self.ranking:\n self.ranking[i[0]] = {}\n self.ranking[i[0]][i[1]] = i[2]","def initalize():\n global itemlist\n global limit\n global weightlimit\n global indivcount\n\n \n itemlist = []\n \n limit = 50000\n print(\"Initializing with \",limit,\" Items to choose from\")\n sack = generatesack(limit)\n \n weightlimit = 0\n for i in sack:\n weightlimit += i.weight\n weightlimit = weightlimit//2\n print(\"The napsack weightlimit is: \", weightlimit)\n \n indivcount = 200\n print(\"Initializing with \",indivcount,\" Individuals per generation\")\n takelist = geninitialpopulation(indivcount, sack)\n final_output = evolution(takelist)\n \n generations = final_output[1]\n final_output = final_output[0]\n \n print(\"\\n\")\n print(\"Best individual:\")\n bestindiv = prettytable.PrettyTable()\n bestindiv.field_names = [\"weight\",\"total value\",\"fitness\"]\n bestindiv.add_row([final_output.mass,final_output.value,final_output.fitness])\n print(bestindiv)\n print(\"Best solution acheived after \",generations, \" generations!\")\n print(\"Distance to weightlimit: \",weightlimit - final_output.mass)","def update_nypd_complaint_results():\n start_datetime, end_datetime = get_start_end_datetimes()\n\n cols_to_keep = \"boro_nm,cmplnt_fr_dt,cmplnt_to_dt,juris_desc,law_cat_cd,ofns_desc,prem_typ_desc,longitude,latitude\"\n results = SOCRATA_CLIENT.get(\n NYPD_COMPLAINT_ID, \n limit=10, \n select=cols_to_keep,\n where=f\"cmplnt_to_dt IS NULL and cmplnt_fr_dt between '{start_datetime.isoformat()}' and '{end_datetime.isoformat()}'\")\n\n df = pd.DataFrame.from_records(results)\n cols = list(df)\n for c in cols:\n df[c].fillna(\"null\", inplace=True)\n __upload_to_gcp_bucket(df, NYPD_COMPLAINT_FNAME)\n return df","def __init__(self):\n self.capacity = 1000\n self.data = [None]*self.capcity","def __init__(self):\n self.buckets = 1009\n self.table = [[] for _ in range(self.buckets)]","def sweetcoconut_databank(df_tax_id_fromCompleteDatabank, taxonomy_Double,sweetcoconut_database,port):\n client2 = MongoClient(port)\n db_s = client2[sweetcoconut_database]\n collection2 = db_s.sweetNaturalProduct\n sweetnp = pd.DataFrame(list(collection2.find({\"contains_sugar\": True})))\n sweetnp_with_tax = pd.merge(sweetnp, df_tax_id_fromCompleteDatabank, how=\"left\", on=\"coconut_id\")\n df_cutout_sweetnp_with_tax = pd.DataFrame({\"coconut_id\": sweetnp_with_tax.coconut_id,\n \"taxonomy\": sweetnp_with_tax.taxonomy,\n \"all_deglycosilated_smiles\": sweetnp_with_tax.all_deglycosilated_smiles\n })\n df_cutout_no_nan = df_cutout_sweetnp_with_tax.fillna('no')\n df_cutout_explode = df_cutout_no_nan.explode(\"all_deglycosilated_smiles\",ignore_index=True)\n #display(df_cutout_explode)\n unique_deglycosilated_smiles = set(df_cutout_explode[\"all_deglycosilated_smiles\"])\n unique_deglycosilated_smiles.pop()\n df_NP = pd.DataFrame(unique_deglycosilated_smiles, columns=[\"deglycosilated_smiles\"])\n df_NP[\"coconut_id\"] = \"\"\n df_NP[\"taxonomy\"] = \"\"\n index = 0\n for mol in df_NP.deglycosilated_smiles:\n all_rows = df_cutout_explode[df_cutout_explode[\"all_deglycosilated_smiles\"]==mol]\n df_NP.coconut_id[index] = (all_rows.coconut_id.values)\n df_NP.taxonomy[index] = (all_rows.taxonomy.values)\n index += 1\n #display(df_NP)\n # **-----------------for tax prediction-------------------**\n df_NP.to_pickle(\"output_data/for_predict_multiple_tax.pkl\")\n # **----------------end tax prediction--------------------**\n index = 0\n for tax_list in df_NP.taxonomy:\n df_NP.taxonomy[index] = set(tax_list)\n if len(df_NP.taxonomy[index]) >= 2:\n if 'no' in df_NP.taxonomy[index]:\n df_NP.taxonomy[index].remove('no')\n index += 1\n #display(df_NP)\n bar_plot(df_NP)\n venn_diagram(df_NP,taxonomy_Double)\n aglycon_single_tax(df_NP)","def createQWord(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","def hist_data(self):\n # database address\n jydb_address = \"117.122.223.35\"\n jydb_user_id = \"zpy\"\n jydb_user_pwd = \"Z1pe1y1@zpy\"\n jydb_db_name = \"jydb02\"\n # preallocate data set\n back_testing_data = {}\n \n # on-line mode\n conn = pymysql.connect(jydb_address, jydb_user_id, jydb_user_pwd, jydb_db_name)\n # not using moving average\n if not self.moving_average: \n # iterate on all ism packages\n for _i, ism_pack in enumerate(tqdm(self.ism_data)):\n ismcode = ism_pack[0][0]\n ProRunDate = ism_pack[0][5]\n ProStopDate = ism_pack[0][6]\n MaxStoreSum = ism_pack[0][7]\n MinInvestShare = ism_pack[0][8]\n InnerCode_ls = flatten(list(map(lambda x: [y[0] for y in x[1:]], ism_pack[1:])))\n SecuCode_ls = flatten(list(map(lambda x: [y[1] for y in x[1:]], ism_pack[1:])))\n PriorType_ls = flatten(list(map(lambda x: [y[2] for y in x[1:]], ism_pack[1:])))\n # collect data from source conn\n flag_run = \"SELECT InnerCode, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \" + \\\n \"InnerCode IN (\" + \",\".join(InnerCode_ls) + \") AND \" + \\\n \"TradingDay=\\'\" + ProRunDate + \"\\'\"\n flag_stop = \"SELECT InnerCode, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \" + \\\n \"InnerCode IN (\" + \",\".join(InnerCode_ls) + \") AND \" + \\\n \"TradingDay=\\'\" + ProStopDate + \"\\'\"\n run_price = pd.read_sql(flag_run, conn)\n stop_price = pd.read_sql(flag_stop, conn)\n back_testing_data[ismcode] = pd.merge(run_price, stop_price, on='InnerCode', \n suffixes=('_run', '_stop'))\n else: # using moving average \n # iterate on all ism packages\n for _i, ism_pack in enumerate(self.ism_data):\n ismcode = ism_pack[0][0]\n ProRunDate = ism_pack[0][5]\n TradingDay_begin = former_market_date(ProRunDate, self.L_shift, conn)\n TradingDay_end = future_market_date(ProRunDate, self.R_shift, conn)\n InnerCode_ls = flatten(list(map(lambda x: [y[0] for y in x[1:]], ism_pack[1:])))\n SecuCode_ls = flatten(list(map(lambda x: [y[1] for y in x[1:]], ism_pack[1:])))\n PriorType_ls = flatten(list(map(lambda x: [y[2] for y in x[1:]], ism_pack[1:])))\n flag = \"SELECT InnerCode, TradingDay, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \" + \\\n \"InnerCode IN (\" + \",\".join(InnerCode_ls) + \") AND \" + \\\n \"TradingDay BETWEEN \\'\" + TradingDay_begin + \"\\' AND \\'\" + TradingDay_end + \"\\'\"\n back_testing_data[ismcode] = pd.read_sql(flag, conn)\n \n # close sql connection\n conn.close()\n \n return back_testing_data","def populate_db_command():\n print(\"Populating DB with sample data.\")\n populate_db()\n print \"Done\"","def insert_domains_into_onprogress(db, domains):\r\n cursor = db.cursor()\r\n print 'domain-----------------------------------------------------------------------------'\r\n print domains[0]\r\n print 'domain-----------------------------------------------------------------------------'\r\n sql_string = \"INSERT INTO on_progress_domains(url, max_pages) VALUES(%s, %s)\"\r\n try:\r\n cursor.execute(sql_string, domains[0])\r\n db.commit()\r\n except:\r\n cursor.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n cursor.close()","def fill_db(self, data):\n check_input_params(data, self.DB)\n self.db = data[self.DB]","def stake_associated_addresses(self, stake_address: str, data_order: str='asc', nb_of_results: int=None, pandas: bool=False) -> Union[pd.DataFrame, dict]:\n \n stake_associated_addresses_url = \"{}{}{}\".format(bf_stake_url,\n stake_address,\n bf_associated_addresses_url)\n \n response, count_api_calls = query_on_several_pages(self.network, self.api_key, data_order, nb_of_results, stake_associated_addresses_url, self.proxies)\n \n #print('[INFO] Function stake_associated_addresses, {} API calls.'.format(count_api_calls))\n \n return pd.DataFrame.from_dict(response) if pandas else response","def array_update(self, table_list):\r\n for tbl in table_list:\r\n x = kit.SQL_pull('name, subject_id', tbl)\r\n r = {i[0]: i[1] for i in x}\r\n h = {i[1]: tbl for i in x}\r\n \r\n self.refference.update(r)\r\n self.home_table.update(h)\r\n \r\n self.counts[tbl] = len(x)","def step070() -> None:\n logger.logMessage('Begin: elasticsearch bulk update')\n client = es.Elasticsearch(hostlist)\n\n def generate():\n with open(renumFile,'r') as f:\n line = f.readline().rstrip()\n while line != '':\n fields = line.split(';')\n oper = { '_index': fields[3], \n '_op_type': 'update',\n '_id': fields[2].rstrip(),\n '_type': 'doc',\n '_source:': {'doc': {'tsa': fields[0]}}}\n \n yield oper\n line = f.readline().rstrip()\n result = eshelp.bulk(client,generate())\n logger.logMessage('Bulk result: {0}'.format(result))\n logger.logMessage('End : elasticsearch bulk update')","def resAlloc(self,band):\n schd = self.schType[0:2]\n if schd=='PF' and len(list(self.ues.keys()))>0:\n exp_num = float(self.schType[2])\n exp_den = float(self.schType[3])\n self.setUEfactor(exp_num, exp_den)\n maxInd = self.findMaxFactor()\n for ue in list(self.ues.keys()):\n if ue == maxInd:\n self.ues[ue].prbs = band\n else:\n self.ues[ue].prbs = 0\n if len(self.ues[ue].pastTbsz)>self.promLen:\n self.ues[ue].pastTbsz.popleft()\n self.ues[ue].pastTbsz.append(self.ues[ue].tbsz)\n self.ues[ue].tbsz = 1\n # Print Resource Allocation\n self.printResAlloc()","def save_pages_to_onprogress_pages(db, pages, domain):\r\n cursor = db.cursor()\r\n #get domain id\r\n try:\r\n cursor.execute(\"SELECT domain_id, max_pages FROM on_progress_domains WHERE url = %(d)s\", {'d':domain})\r\n domain_id = cursor.fetchone()\r\n if domain_id == None:\r\n print \"foriegn key not found\"\r\n return\r\n except:\r\n cursor.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n\r\n for page in pages:\r\n #if max pages reached\r\n if domain_id[1] < 0:\r\n print \"max pages reached zero, Terminating crawler for the domain:\", domain, \"after waiting pages are done processing\"\r\n return\r\n max_pages_updated = int(domain_id[1]) - 1\r\n sql_string1 = \"INSERT INTO on_progress_pages(domain_id, page_url) VALUES(%s, %s)\"\r\n sql_string2 = \"UPDATE on_progress_domains SET max_pages = %s WHERE domain_id = %s\"\r\n try:\r\n\r\n cursor.execute(sql_string1, (int(domain_id[0]), page))\r\n cursor.execute(sql_string2, (max_pages_updated, domain_id[0]))\r\n db.commit()\r\n except:\r\n cursor.close()\r\n raise RuntimeError(\"An Exception happened with the Database, make sure you are connected\")\r\n cursor.close()","def main():\r\n windows_driver = '/mnt/c/Users/kurtrm/Documents/bin/chromedriver.exe'\r\n browser = Chrome(executable_path=windows_driver)\r\n\r\n url = 'https://www.pcta.org/discover-the-trail/' \\\r\n 'thru-hiking-long-distance-hiking/2600-miler-list/'\r\n\r\n browser.get(url)\r\n year_range = range(1952, 2018) # Range of years of recorded thru-hikes\r\n\r\n for year in year_range:\r\n select = Select(browser.find_element_by_id('year'))\r\n select.select_by_value(str(year))\r\n time.sleep(1.5)\r\n miler_list = browser.find_elements_by_css_selector('td')\r\n if miler_list[0].text != 'No records found for the selected year.':\r\n people = extract_names(miler_list, year)\r\n load_mongo_db('pct', 'completions', people)","def connected_devices_arp(self, run_test):\n\n\n if not run_test:\n return\n\n res = {}\n\n ts = int(time.time())\n\n route_cmd = \"ip r | grep /24 | awk '{print $1;}'\"\n subnet = Popen(route_cmd, shell=True,\n stdout=PIPE).stdout.read().decode('utf-8')\n\n nmap_cmd = f'nmap -sn {subnet}'\n Popen(nmap_cmd, shell=True, stdout=PIPE)\n\n arp_cmd = (\"/usr/sbin/arp -i eth0 -n | grep : |\"\n \"grep -v '_gateway' | tr -s ' ' | \"\n \"cut -f3 -d' ' | sort | uniq\")\n\n arp_res = Popen(arp_cmd, shell=True,\n stdout=PIPE).stdout.read().decode('utf-8')\n res['arp'] = arp_res\n\n devices = set(arp_res.strip().split(\"\\n\"))\n active_devices = [[dev, ts, 1] for dev in devices]\n\n for device in active_devices:\n if self.dev_db.contains(where('mac_addr') == device[0]):\n self.dev_db.update(increment(\"n\"),\n where('mac_addr') == device[0])\n self.dev_db.update(tdb_set('last_seen', device[1]),\n where('mac_addr') == device[0])\n else:\n self.dev_db.insert({'mac_addr': device[0],\n 'last_seen': device[1],\n 'n': device[2]})\n\n print(self.dev_db.all())\n ndev_past_day = len(self.dev_db.search(\n where('last_seen') > (ts - 86400)))\n ndev_past_week = len(self.dev_db.search(\n where('last_seen') > (ts - 86400*7)))\n\n print(ndev_past_day)\n self.results[\"devices_active\"] = len(active_devices)\n self.results[\"devices_total\"] = self.dev_db.count(where('n') >= 1)\n self.results[\"devices_1day\"] = ndev_past_day\n self.results[\"devices_1week\"] = ndev_past_week\n\n if not self.quiet:\n print('\\n --- Number of Devices ---')\n print(f'Number of active devices: '\n f'{self.results[\"devices_active\"]}')\n print(f'Number of total devices: '\n f'{self.results[\"devices_total\"]}')\n print(f'Number of devices in last 1 day:'\n f' {self.results[\"devices_1day\"]}')\n print(f'Number of devices in last week:'\n f' {self.results[\"devices_1week\"]}')\n return res","def test_place(self):\n places = self.geographies.find({ 'geoid': '1562600' })\n\n self.assertEqual(places.count(), 1)\n\n place = places[0]\n\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\n self.assertEqual(place['metadata']['STATE'], '15')\n self.assertEqual(place['metadata']['PLACE'], '62600')\n\n pop_2000 = 30976\n pop_2010 = 47698 \n self._test_totalpop(place, pop_2000, pop_2010)","def restart_index(ips, server):\r\n\ticepaps = []\r\n\r\n#CREATING ICEPAP PARSERS FOR EVERY ADRESS IN ips\r\n\tfor ip in ips:\r\n\t\ticepaps.append(ElasticClient(ip))\r\n\t\r\n\tfor icepap in icepaps:\r\n\t\ticepap.setup_cards(server)\r\n\r\n\tprint \"- - - - - \" + datetime.now().strftime(\"%d-%b-%Y (%H:%M:%S)\") + \" - - - - -\"\r\n\treturn icepaps","def query_ptr_records_for_all_ips(self):\n\n log.debug(\"Starting to look up PTR records for IP addresses\")\n\n # store IP addresses to look them up in bulk\n ip_lookup_dict = dict()\n\n # iterate over all IP addresses and try to match them to a prefix\n for ip in self.get_all_items(NBIPAddress):\n\n # ignore IPs which are not handled by any source\n if ip.source is None:\n continue\n\n # get IP and prefix length\n ip_a = grab(ip, \"data.address\", fallback=\"\").split(\"/\")[0]\n\n # check if we meant to look up DNS host name for this IP\n if grab(ip, \"source.dns_name_lookup\", fallback=False) is True:\n\n if ip_lookup_dict.get(ip.source) is None:\n\n ip_lookup_dict[ip.source] = {\n \"ips\": list(),\n \"servers\": grab(ip, \"source.custom_dns_servers\")\n }\n\n ip_lookup_dict[ip.source].get(\"ips\").append(ip_a)\n\n # now perform DNS requests to look up DNS names for IP addresses\n for source, data in ip_lookup_dict.items():\n\n if len(data.get(\"ips\")) == 0:\n continue\n\n # get DNS names for IP addresses:\n records = perform_ptr_lookups(data.get(\"ips\"), data.get(\"servers\"))\n\n for ip in self.get_all_items(NBIPAddress):\n\n if ip.source != source:\n continue\n\n ip_a = grab(ip, \"data.address\", fallback=\"\").split(\"/\")[0]\n\n dns_name = records.get(ip_a)\n\n if dns_name is not None:\n\n ip.update(data={\"dns_name\": dns_name})\n\n log.debug(\"Finished to look up PTR records for IP addresses\")","def getDataBefore(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\n ...","def load_absolute_case_numbers():\n client = MongoClient(f'mongodb://{os.getenv(\"USR_\")}:{os.getenv(\"PWD_\")}@{os.getenv(\"REMOTE_HOST\")}:{os.getenv(\"REMOTE_PORT\")}/{os.getenv(\"AUTH_DB\")}')\n db = client[os.getenv(\"MAIN_DB\")]\n rki_collection = db[\"rkidata\"]\n data = pd.DataFrame(list(rki_collection.find()))\n data[\"IdLandkreis\"] = pd.to_numeric(data[\"IdLandkreis\"])\n return data","def set_bibs(self, number):","def main():\r\n print(\"Initializing Database\")\r\n global conn\r\n conn = create_db()\r\n\r\n print(\"Inserting Raw Ticket Data\")\r\n create_raw_data()\r\n print(\"Creating Block Limits DataFrame\")\r\n\r\n global streetnamedict\r\n global streetintersections\r\n streetintersections, streetnamedict = create_block_limits()\r\n\r\n print(\"Starting Address Creation\")\r\n global single_address\r\n global double_address\r\n global addresses\r\n single_address, double_address, addresses = create_address_data()\r\n print(\"Finished Creating addresses\")\r\n\r\n global nhoodtype\r\n nhoodtype = pd.read_sql_query('Select nhood, violationdesc, count(*) tickets from raw_ticket_data t1 join single_address t2 '\r\n ' on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname group by nhood, violationdesc', conn)\r\n\r\n print(\"Processing Ticket Data\")\r\n process_ticket_data()\r\n print('Finished processing Ticket Data!')\r\n print('Starting Street Data Creation')\r\n streetsweeping, streetvolume = process_volume()\r\n print(' Finished Street Data Creation')\r\n\r\n print('Pairing Addresses with Street Data')\r\n pair_address(streetsweeping, streetvolume)\r\n print('Finished Pairing Addresses')\r\n\r\n print('Pairing Parking')\r\n pair_parking(streetvolume)\r\n print('Finished Pairing Parking')\r\n\r\n conn.close()\r\n\r\n print('Finished Creating Entire Database and updated Shapefiles at {}'.format( dt.datetime.now().strftime(\"%H:%M\")))","def test_query_train_jobs_with_lower_offset(self, client):\n params = dict(offset=-1, limit=10)\n url = get_url(BASE_URL, params)\n response = client.get(url)\n result = response.get_json()\n assert result.get('error_code') == '50540002'"],"string":"[\n \"def partition_geocode(con: sqlite3.Connection, cur: sqlite3.Cursor, quarter: str, county_cht: str):\\n cur.execute('''SELECT 土地區段位置或建物區門牌 FROM \\\"{0}/TRX\\\"\\n WHERE 縣市 = ?\\n GROUP BY 土地區段位置或建物區門牌;'''.format(quarter), (county_cht,))\\n for address, in cur.fetchall():\\n cur.execute('''SELECT GEO.編號\\n FROM \\\"{0}/TRX\\\" AS TRX, \\\"{0}/GEO\\\" AS GEO\\n WHERE TRX.編號 = GEO.編號\\n AND TRX.土地區段位置或建物區門牌 = ?\\n AND GEO.LAT_Avg ISNULL;'''.format(quarter), (address,))\\n identities = cur.fetchall()\\n if not identities:\\n continue\\n print(\\\"[%d] \\\"%(len(identities)) + address)\\n try:\\n results = selective_geocode(address)\\n except geo.AddressError:\\n continue\\n if len(results[\\\"lat\\\"]) != 5 or len(results[\\\"lon\\\"]) != 5:\\n continue\\n results[\\\"lat\\\"].append(sum(results[\\\"lat\\\"]) / len(results[\\\"lat\\\"]))\\n results[\\\"lon\\\"].append(sum(results[\\\"lon\\\"]) / len(results[\\\"lon\\\"]))\\n combined = [num for zipped in zip(results[\\\"lat\\\"], results[\\\"lon\\\"]) for num in zipped]\\n values = [(tuple(combined) + identity) for identity in identities]\\n cur.executemany('''UPDATE \\\"{0}/GEO\\\" SET\\n LAT_1 = ?, LON_1 = ?,\\n LAT_2 = ?, LON_2 = ?,\\n LAT_3 = ?, LON_3 = ?,\\n LAT_4 = ?, LON_4 = ?,\\n LAT_5 = ?, LON_5 = ?,\\n LAT_Avg = ?, LON_Avg = ?\\n WHERE 編號 = ?;'''.format(quarter), values)\\n con.commit()\",\n \"def load_presn_search(search, start, end, offset, limit):\\n now_local = datetime.now()\\n timelimit = timedelta(hours=100)\\n server = couchdb.Server(\\\"http://snoplus:\\\"+app.config[\\\"COUCHDB_PASSWORD\\\"]+\\\"@\\\"+app.config[\\\"COUCHDB_HOSTNAME\\\"])\\n db = server[\\\"pre-supernova\\\"]\\n \\n results = []\\n skip = offset\\n\\n if search == \\\"run\\\":\\n startkey = [int(start)]\\n endkey = [int(end)]\\n view = '_design/presn/_view/presn_by_run_date'\\n\\n elif search == \\\"date\\\":\\n start_year = start[0:4]\\n start_month = start[5:7]\\n start_day = start[8:10]\\n end_year = end[0:4]\\n end_month = end[5:7]\\n end_day = end[8:10]\\n if start_month[0] == \\\"0\\\":\\n start_month = start_month[1]\\n if end_month[0] == \\\"0\\\":\\n end_month = end_month[1]\\n if start_day[0] == \\\"0\\\":\\n start_day = start_day[1]\\n if end_day[0] == \\\"0\\\":\\n end_day = end_day[1]\\n startkey = [int(start_year), int(start_month), int(start_day)]\\n endkey = [int(end_year), int(end_month), int(end_day)]\\n view = '_design/presn/_view/presn_by_date_run'\\n \\n if search == \\\"run\\\":\\n try:\\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\\n total = len(all.rows)\\n print \\\"OK, run gives us\\\", total\\n print all\\n except:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB.\\\")\\n\\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\\n try:\\n year = row.value[0]\\n mon = row.value[1]\\n day = row.value[2]\\n hour = row.value[3]\\n minute = row.value[4]\\n sec = row.value[5]\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n run = row.key\\n run_id = row.id\\n if timediff<timelimit:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n\\n elif search == \\\"date\\\":\\n try:\\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\\n total = len(all.rows)\\n except:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB.\\\")\\n\\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\\n try:\\n year = row.key[0]\\n mon = row.key[1]\\n day = row.key[2]\\n hour = row.key[3]\\n minute = row.key[4]\\n sec = row.key[5]\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n run = row.value\\n run_id = row.id\\n if timediff<timelimit:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n return results, total, offset, limit\",\n \"def update_take_x_ip_requests(limit):\\n global ip_report\\n\\n for remote_host, record in ip_report.items():\\n ip_report[remote_host]['requests'] = {k: ip_report[remote_host]['requests'][k] for k in list(ip_report[remote_host]['requests'])[:limit]}\",\n \"def Process_address(self):\\n\\n self.data = np.load(self.cache_path, allow_pickle=True)[()]\\n\\n ID = self.data.keys()\\n\\n cnt = 0\\n for id in tqdm(ID):\\n if not 'address' in self.data[id] and 'post' in self.data[id]:\\n self.data[id]['address'] = ''\\n self.data[id]['location'] = ''\\n Q = self.Query_baidu(self.data[id]['post'])\\n self.data[id]['address'] = Q['address']\\n self.data[id]['location'] = Q['location']\\n cnt += 1\\n\\n print(\\\"Query %d info\\\" % cnt)\\n\\n np.save(self.cache_path, self.data)\",\n \"def populate_db(dbase):\\n # In this order: Iron, Blood, Shadow, Fel, Storm\\n wowhead_ids = []\\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-8))\\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-9))\\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-10))\\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-11))\\n wowhead_ids.extend(item.get_ids_from_wowhead_by_type(-17))\\n item_ids = set(wowhead_ids)\\n print(item_ids)\\n\\n pos = 0\\n for item_id in item_ids:\\n if pos % 10 == 0:\\n print(\\\"Relic %d of %d\\\" % (pos, len(item_ids)))\\n pos += 1\\n import_relic(dbase, item_id)\",\n \"def load_presn_runs(offset, limit):\\n now_local = datetime.now()\\n timelimit = timedelta(hours=100)\\n server = couchdb.Server(\\\"http://snoplus:\\\"+app.config[\\\"COUCHDB_PASSWORD\\\"]+\\\"@\\\"+app.config[\\\"COUCHDB_HOSTNAME\\\"])\\n db = server[\\\"pre-supernova\\\"]\\n results = []\\n skip = offset\\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\\n total = all.total_rows\\n offset = all.offset\\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\\n year = row.key[0]\\n mon = row.key[1]\\n day = row.key[2]\\n hour = row.key[3]\\n minute = row.key[4]\\n sec = row.key[5]\\n run = row.value\\n run_id = row.id\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n if timediff<timelimit:\\n try:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n results.sort(reverse=True)\\n return results, total, offset, limit\",\n \"def reset_trending_db():\\n db.execute(\\\"SELECT * FROM stocksera_trending ORDER BY count DESC LIMIT 10\\\")\\n top_10 = db.fetchall()\\n\\n db.execute(\\\"DELETE FROM stocksera_trending\\\")\\n\\n count = 20\\n for row in top_10:\\n row = list(row)\\n row[2] = count\\n print(row)\\n db.execute(\\\"INSERT OR IGNORE INTO stocksera_trending VALUES (?, ?, ?, ?)\\\", tuple(row))\\n conn.commit()\\n count -= 1\",\n \"def populate_index(db):\\n\\tfor url in URL:\\n\\t\\tprint url\\n\\t\\trequest = urllib2.Request(url)\\n\\t\\ttry :\\n\\t\\t\\tresponse = urllib2.urlopen(request)\\n\\t\\texcept urllib2.URLError:\\n\\t\\t\\tprint \\\"Network Unreachable \\\"\\n\\t\\t\\tsys.exit()\\t\\n\\t\\ttext = html2text(response.read())\\n\\t\\tdb.generate_index(text,url)\",\n \"def getNextNonUndefinedDataAfter(program: ghidra.program.model.listing.Program, addr: ghidra.program.model.address.Address, maxAddr: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def crawl(db):\\n cur = db.cursor()\\n\\n dailyMax = 3000\\n batchNum = 20\\n sleeptimeforPubmed = 5\\n backstep = 20\\n\\n cur.execute('select pmid from articles order by pmid desc')\\n startingPMID = cur.fetchall()[backstep][0]\\n\\n\\t################\\n\\t# for testing\\n # startingPMID=28315500\\n\\n cur.execute('truncate table articles')\\n for i in range (startingPMID, startingPMID+dailyMax, batchNum):\\n PMIDs = \\\"\\\"\\n\\n for j in range (batchNum):\\n PMIDs = PMIDs + str(i + j ) +\\\",\\\"\\n\\n url = \\\"https://www.ncbi.nlm.nih.gov/pubmed/\\\"+ PMIDs +\\\"?report=medline&format=text\\\"\\n\\n time.sleep(sleeptimeforPubmed)\\n http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\\n r = http.request('GET', url)\\n soup = BeautifulSoup(r.data, \\\"lxml\\\")\\n\\n allInfo = unicode(soup.pre.string)\\n\\n if allInfo.find('PMID- ')<0:\\n print url\\n print 'extraction complete'\\n break\\n\\n while (allInfo.find('AB -')>0 and allInfo.find('TI -')>0):\\n IdIndexStart = allInfo.index('PMID- ')+6\\n IdIndexEnd = allInfo.index('\\\\n', IdIndexStart)\\n PMID = allInfo[IdIndexStart:IdIndexEnd]\\n\\n try:\\n tiIndexStart = allInfo.index('TI -')+6\\n\\n if allInfo.find( 'PG -', tiIndexStart)>0:\\n tiIndexEnd = allInfo.index('PG -', tiIndexStart)-1\\n elif allInfo.find('LID -', tiIndexStart)>0:\\n tiIndexEnd = allInfo.index('LID -', tiIndexStart)-1\\n else:\\n tiIndexEnd = allInfo.index('AB -', tiIndexStart)-1\\n ti = allInfo[tiIndexStart:tiIndexEnd]\\n\\n except:\\n ti =\\\"\\\"\\n\\n abIndexStart = allInfo.index('AB -')+6\\n try:\\n abIndexEnd = allInfo.index('FAU -', abIndexStart)-1\\n except:\\n abIndexEnd = abIndexStart + 1000\\n ab = ti+\\\" Abstract:\\\"+allInfo[abIndexStart:abIndexEnd]\\n\\n query = \\\"insert into articles (pmid, abstract) values (\\\"+ PMID +\\\", '\\\"+ ab + \\\"')\\\"\\n endingPMID = int(PMID)\\n\\n\\n if (endingPMID%10==0):\\n print endingPMID\\n\\n try:\\n cur.execute(query)\\n db.commit()\\n\\n except:\\n db.rollback()\\n\\n allInfo = allInfo[abIndexEnd:]\\n\\n now = datetime.datetime.now()\\n query = 'insert into last_pmid (record_date, pmid) values (\\\"%s\\\", %d)'%(now, endingPMID)\\n cur.execute(query)\\n db.commit()\",\n \"def _reset_top_preps(self) -> None:\\n if self._system.getIISSInfo()[\\\"nextPRepTerm\\\"] > self._block_height_week.get() + (7 * 43200):\\n self._block_height_week.set(self._system.getIISSInfo()[\\\"nextPRepTerm\\\"])\\n for i in range(len(self._top_preps)):\\n self._top_preps.pop()\\n self._set_top_preps()\",\n \"def collector_numbers(db):\\n\\n # create indicies to make the important queries much faster.\\n db.dbase.execute('CREATE INDEX IF NOT EXISTS cnames ON cards (cardname);')\\n db.dbase.execute('CREATE INDEX IF NOT EXISTS pubexp ON published (expansion);')\\n db.dbase.execute('CREATE INDEX IF NOT EXISTS pubnames ON published (name);')\\n\\n # get a cursor of the list of sets in the db\\n setlist = db.dbase.execute('SELECT abbreviation FROM sets ORDER BY released')\\n\\n # HACK -- planar chaos split cards\\n for scard in ['Boom // Bust', 'Dead // Gone', 'Rough // Tumble']:\\n db.dbase.execute('UPDATE cards SET cn_position = 54 WHERE cards.cardname = ?', (scard,))\\n\\n for expansion in setlist:\\n # special case for time spiral\\n if expansion[0] == 'TSP':\\n cardlist = db.dbase.execute('SELECT DISTINCT published.name,published.rarity FROM published JOIN cards ON cards.cardname = published.name WHERE published.expansion = ? AND cards.virtual = ? ORDER BY CASE published.rarity WHEN ? THEN 2 ELSE 1 END,cards.cn_position, published.name', (expansion[0], 'No', 'S'))\\n\\n # other sets\\n else:\\n cardlist = db.dbase.execute('SELECT DISTINCT published.name FROM published JOIN cards ON cards.cardname = published.name WHERE published.expansion = ? AND cards.virtual = ? ORDER BY cards.cn_position, published.name', (expansion[0], 'No'))\\n\\n cardnumber = 1\\n for card in cardlist:\\n db.dbase.execute('UPDATE published SET cnum = ? WHERE published.name = ? AND published.expansion = ?', (cardnumber, card[0], expansion[0]) )\\n cardnumber += 1\",\n \"def load_disasters():\\n\\n print \\\"Disasters\\\"\\n\\n #deletes any data within the table before seeding\\n Disaster.query.delete()\\n\\n\\n result_count = 1000\\n iteration = 0\\n records_returned = 1000\\n\\n # makes payload requests from FEMA API\\n while records_returned == 1000:\\n payload = {'$top': result_count,\\n '$skip': result_count * iteration,\\n '$inlinecount': 'allpages',\\n '$filter': 'declarationDate ge \\\\'1990-01-01T04:00:00.000z\\\\'',\\n '$select': 'disasterNumber,declarationDate,state,incidentType,title,incidentBeginDate,incidentEndDate,placeCode,declaredCountyArea'}\\n r = requests.get(\\n \\\"http://www.fema.gov/api/open/v1/DisasterDeclarationsSummaries\\\",\\n params=payload)\\n\\n # iteration counter, starts at zero, for every iteration add 1\\n iteration += 1\\n\\n disaster_info = r.json()\\n metadata = disaster_info['metadata']\\n record_count = metadata['count']\\n records_returned = len(disaster_info['DisasterDeclarationsSummaries'])\\n\\n # parsing through the information returned from API\\n for incident_dict in disaster_info['DisasterDeclarationsSummaries']:\\n disasterNumber = incident_dict.get('disasterNumber')\\n declarationDate = incident_dict.get('declarationDate')\\n state = incident_dict.get('state')\\n incidentType = incident_dict.get('incidentType')\\n title = incident_dict.get('title')\\n incidentBeginDate = incident_dict.get('incidentBeginDate')\\n incidentEndDate = incident_dict.get('incidentEndDate')\\n placeCode = incident_dict.get('placeCode')\\n declaredCountyArea = incident_dict.get('declaredCountyArea')\\n\\n \\\"\\\"\\\"Try/Except does two things: the try is doing a check to see if the county is already in the counties tables and if it is, then setting the Disaster.countyArea_id in the disasters table. The except is occuring only when the NoResultFound occurs and is creating the county and adding it to the counties table.\\\"\\\"\\\"\\n try:\\n #variable county set to \\\"answer\\\" of query\\n county_check = County.query.filter(County.county_name==declaredCountyArea, County.state_code==state).one()\\n\\n countyArea_id = county_check.county_id\\n\\n # creating a county when NoResultFound error occurs\\n except NoResultFound:\\n\\n county = County(state_code=state,\\n county_name=declaredCountyArea)\\n\\n db.session.add(county)\\n #!!!!!!!!! ask bonnie about this again !!!!!!!!!!#\\n db.session.flush()\\n\\n countyArea_id = county.county_id\\n\\n county = County.query.filter(County.county_name==declaredCountyArea, County.state_code==state).one()\\n countyArea_id = county.county_id\\n\\n disaster = Disaster(disasterNumber=disasterNumber,\\n state=state,\\n declarationDate=declarationDate,\\n incidentType=incidentType,\\n title=title,\\n incidentBeginDate=incidentBeginDate,\\n incidentEndDate=incidentEndDate,\\n placeCode=placeCode,\\n declaredCountyArea=declaredCountyArea,\\n countyArea_id=countyArea_id)\\n\\n db.session.add(disaster)\\n\\n db.session.commit()\\n print \\\"Disasters and Counties seeded\\\"\",\n \"def create_address_data():\\r\\n print(\\\"Reading address data file\\\")\\r\\n addresses = pd.read_csv(raw_loc + 'san_francisco_addresses.csv')\\r\\n addresses.columns = map(str.lower, addresses.columns)\\r\\n\\r\\n keepcolumns = ['lon', 'lat', 'number', 'street']\\r\\n addresses = addresses[keepcolumns]\\r\\n addresses['number'] = addresses['number'].apply(lambda x: re.findall( '\\\\d+', x)[0]).astype(int)\\r\\n addresses['address'] = addresses.apply(lambda x: str(x['number']) + \\\" \\\" + str(x['street']), axis = 1)\\r\\n addresses['streetname'] = addresses['street'].apply(return_street)\\r\\n addresses.drop_duplicates(subset = 'address', inplace = True)\\r\\n addresses['type'] = 'known'\\r\\n addresses.to_sql('raw_address_data', if_exists = 'replace', con = conn)\\r\\n\\r\\n\\r\\n print(\\\"Finding similar addresses\\\")\\r\\n df = pd.read_sql_query('Select distinct tickstreetno , tickstreetname , count(*) total_tickets from raw_ticket_data t1'\\r\\n ' left join raw_address_data t2 on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname '\\r\\n \\\" where t2.address is null group by tickstreetno, tickstreetname \\\", conn)\\r\\n\\r\\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\\r\\n df['blocknum'] = df['TickStreetNo'].apply(lambda x: math.ceil(x/100))\\r\\n df.drop_duplicates(inplace = True)\\r\\n\\r\\n df2 = addresses\\r\\n df2['blocknum'] = df2['number'].apply(lambda x: math.ceil(x/100))\\r\\n newdf = df.merge(df2, how = 'left', left_on = ['TickStreetName', 'blocknum'], \\\\\\r\\n right_on = ['streetname', 'blocknum'])\\r\\n\\r\\n\\r\\n unfound = newdf[pd.isnull(newdf.number)]\\r\\n unfound['type'] == \\\"unknown\\\"\\r\\n newdf = newdf[pd.isnull(newdf.number) == False]\\r\\n newdf['delta'] = np.abs(newdf['number'] - newdf['TickStreetNo'])\\r\\n newdf.sort_values(by = 'delta', inplace = True)\\r\\n newdf.drop_duplicates(subset = ['TickStreetName', 'TickStreetNo'], keep = 'first', inplace = True)\\r\\n\\r\\n newdf = newdf[[ 'lon', 'lat', 'TickStreetNo', 'street', 'address','streetname' ]]\\r\\n newdf.columns = ['lon', 'lat', 'number', 'street', 'address','streetname' ]\\r\\n newdf['address'] = newdf['number'].map(str) + ' ' + newdf['street']\\r\\n newdf.drop_duplicates(inplace = True)\\r\\n newdf['type'] = 'similar'\\r\\n newdf.to_sql('raw_address_data', conn, if_exists = 'append')\\r\\n unfound = unfound[unfound.TickStreetNo < 10000]\\r\\n\\r\\n\\r\\n print(\\\"Searching for Intersection Addresses\\\")\\r\\n #unfound = unfound[(unfound.TickStreetNo < 10000) & (unfound.TickStreetNo > 0)]\\r\\n isection = unfound[['TickStreetNo','TickStreetName', 'total_tickets']]\\r\\n isection['address'] = isection['TickStreetName'].apply(return_intersections)\\r\\n unfound = isection[pd.isnull(isection.address) == True]\\r\\n isection = isection[pd.isnull(isection.address) == False]\\r\\n isection = isection.merge(addresses, left_on = 'address', right_on = 'address')\\r\\n isection = isection[['number', 'streetname', 'street', 'address', 'lat', 'lon']]\\r\\n isection.to_sql('raw_address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n\\r\\n print(\\\"Searching for Unknown Addresses\\\")\\r\\n unfound.drop_duplicates(inplace = True)\\r\\n tqdm.pandas()\\r\\n unfound['street'] = unfound.apply(lambda x: return_streetname_unknown(x['TickStreetNo'], x['TickStreetName']), axis = 1)\\r\\n unfound['address'] = unfound.apply(lambda x: str(x['TickStreetNo']) + \\\" \\\" + str(x['street']), axis = 1)\\r\\n numlookup = 5000\\r\\n print(\\\"There are \\\" + str(unfound.shape[0]) + \\\" addresses we couldn't find, we're goin to lookup \\\" + str(numlookup))\\r\\n lookup = unfound.sort_values(by = 'total_tickets', ascending = False)[:numlookup] #CHANGE TO 5000\\r\\n lookup['coordinates'] = lookup['address'].progress_apply(lambda x: create_locs(x + ' SAN FRANCISCO CA'))\\r\\n lookup.dropna(subset = ['coordinates'], inplace = True)\\r\\n lookup['lat'] = lookup['coordinates'].apply(lambda x: x[0])\\r\\n lookup['lon'] = lookup['coordinates'].apply(lambda x: x[1])\\r\\n lookup.rename(columns = {'TickStreetNo':'number', 'TickStreetName':'streetname'}, inplace = True)\\r\\n lookup = lookup[['lat', 'lon', 'street', 'number', 'streetname', 'address']]\\r\\n unfound = unfound[unfound['address'].isin(lookup['address']) == False]\\r\\n unfound['type'] = 'unfound'\\r\\n lookup['type'] = 'searched'\\r\\n lookup.to_sql('raw_address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n print(\\\"associating neighborhoods\\\")\\r\\n addresses = pd.read_sql_query('Select * from raw_address_data', conn)\\r\\n addresses['geometry'] = addresses.apply(lambda x: Point(x['lon'], x['lat']), axis = 1)\\r\\n point = gpd.GeoDataFrame(addresses['geometry'])\\r\\n point.crs = {'init': 'epsg:4326'}\\r\\n poly = gpd.GeoDataFrame.from_file(raw_loc+ 'AnalysisNeighborhoods.geojson')\\r\\n pointInPolys = gpd.tools.sjoin(point, poly, how='left')\\r\\n addresses['geometry'] = addresses['geometry'].astype(str)\\r\\n pointInPolys['geometry'] = pointInPolys['geometry'].astype(str)\\r\\n addresses = addresses.merge(pointInPolys, left_on = 'geometry', right_on = 'geometry')\\r\\n addresses.drop(columns = ['geometry', 'index', 'index_right'], inplace = True)\\r\\n addresses.drop_duplicates(subset = 'address', inplace = True)\\r\\n addresses['number'] = addresses['number'].astype(int)\\r\\n addresses.to_sql('address_data', conn, if_exists = 'replace')\\r\\n\\r\\n\\r\\n unfound.rename(columns = {'TickStreetNo':'number', 'TickStreetName': 'streetname'}, inplace = True)\\r\\n unfound.drop(columns = 'total_tickets', inplace = True)\\r\\n unfound['number'] = unfound['number'].astype(int)\\r\\n unfound.to_sql('address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"Function is to separate addresses into those that may have have more than one address associated with a ticket and street name combo. \\\"\\\"\\\"\\r\\n grouped = addresses.groupby(by = ['number', 'streetname'], as_index = False)['address'].agg('count')\\r\\n grouped.sort_values(by = 'address', ascending = False)\\r\\n grouped.columns = ['number', 'streetname', 'count_ad']\\r\\n single_address = grouped[grouped.count_ad ==1]\\r\\n single_address = single_address.merge(addresses, left_on = ['number', 'streetname'], right_on = ['number', 'streetname'])\\r\\n double_address = addresses[addresses.address.isin(single_address['address']) == False]\\r\\n single_address.to_sql('single_address', conn, if_exists = 'replace')\\r\\n\\r\\n return single_address, double_address, addresses\",\n \"def populate_homes(self, breakdown):\\n #check!#\\n\\n ###your code here###\\n tot=self.nx*self.ny\\n for n in range(len(breakdown)):\\n breakdown[n]=int(round(tot*breakdown[n]))\\n for i in range(breakdown[n]):\\n new_home=self.empty_homes.pop(random.randrange(len(self.empty_homes)))\\n home_address=(new_home.x,new_home.y)\\n x=Person(group=n,home=self.homes[home_address])\\n self.homes[home_address].occupant=x\\n self.people.append(x)\",\n \"def top10(self, top10: List[Word]):\\n\\n self._top10 = top10\",\n \"def complete_databank(port=\\\"localhost:27017\\\",coconut_database=\\\"COCONUT2020-10\\\",sweetcoconut_database=\\\"sweetcoconut\\\"):\\n client = MongoClient(port)\\n db_complete = client[coconut_database]\\n collection = db_complete.uniqueNaturalProduct\\n db_complete_only_ring_sugars = pd.DataFrame(list(collection.find({\\\"contains_ring_sugars\\\": True})))\\n df_complete_tax = pd.DataFrame({\\\"taxonomy\\\": db_complete_only_ring_sugars[\\\"textTaxa\\\"],\\n \\\"smiles\\\": db_complete_only_ring_sugars[\\\"smiles\\\"],\\n \\\"coconut_id\\\": db_complete_only_ring_sugars[\\\"coconut_id\\\"],\\n \\\"no_sugar_smiles\\\": db_complete_only_ring_sugars[\\\"sugar_free_smiles\\\"]\\n })\\n complete_names = []\\n indexes = []\\n for i in range(len(df_complete_tax.taxonomy)):\\n # some entries are empty lists\\n # doubles\\n if df_complete_tax.taxonomy[i] != [] and (\\\"plants\\\" in df_complete_tax.taxonomy[i] or \\\"bacteria\\\" in df_complete_tax.taxonomy[i] or \\\"marine\\\" in df_complete_tax.taxonomy[i] or \\\"animals\\\" in df_complete_tax.taxonomy[i] or \\\"fungi\\\" in df_complete_tax.taxonomy[i]):\\n indexes.append(i)\\n complete_names.append(df_complete_tax.taxonomy[i])\\n df_five_tax = df_complete_tax.loc[indexes[:]]\\n df_tax_id = pd.DataFrame({\\\"taxonomy\\\": df_five_tax.taxonomy,\\n \\\"coconut_id\\\": df_five_tax.coconut_id})\\n df_tax_id = df_tax_id.reset_index()\\n taxonomies = [\\\"plants\\\",\\\"bacteria\\\",\\\"fungi\\\",\\\"marine\\\",\\\"animals\\\"]\\n biology_names = []\\n for row in df_tax_id.taxonomy:\\n for name in row:\\n if name not in taxonomies:\\n biology_names.append(name)\\n for biology_name in biology_names:\\n for row in df_tax_id.taxonomy:\\n if biology_name in row:\\n row.remove(biology_name)\\n # **------------for tax prediction---------------**\\n df_tax_id.to_pickle(\\\"output_data/for_predict_doubletriple.pkl\\\")\\n # **----------end tax prediction--------------**\\n for ind, tax_list in enumerate(df_tax_id.taxonomy):\\n if \\\"marine\\\" in tax_list:\\n #print(ind, tax_list)\\n if len(tax_list) > 1:\\n df_tax_id.taxonomy[ind].remove(\\\"marine\\\")\\n else:\\n df_tax_id.taxonomy[ind].append(\\\"no\\\")\\n df_tax_id.taxonomy[ind].remove(\\\"marine\\\")\\n #df_tax_id.taxonomy[ind] = [\\\"no\\\"]\\n taxonomy_Double = []\\n taxonomy_Triple = []\\n taxonomy_single_entry = []\\n for ind, tax_list in enumerate(df_tax_id.taxonomy):\\n #print(ind, tax_list)\\n if len(tax_list) == 1:\\n taxonomy_single_entry.append(tax_list[0])\\n elif len(tax_list) == 2: \\n taxonomy_single_entry.append('double')\\n # save original annotation\\n taxonomyDouble1 = []\\n for tax in tax_list:\\n taxonomyDouble1.append(tax)\\n taxonomy_Double.append(taxonomyDouble1)\\n elif len(tax_list) == 3:\\n taxonomy_single_entry.append('triple')\\n # save original annotation\\n taxonomyTriple1 = []\\n for tax in tax_list:\\n taxonomyTriple1.append(tax)\\n taxonomy_Triple.append(taxonomyTriple1)\\n else:\\n print('Error: Too many taxonomies for one aglycon','\\\\n','create a new elif statement in line 102 in tanimoto_index.py')\\n df_tax_id_fromCompleteDatabank = pd.DataFrame({\\\"taxonomy\\\": taxonomy_single_entry,\\n \\\"coconut_id\\\": df_five_tax.coconut_id})\\n sweetcoconut_databank(df_tax_id_fromCompleteDatabank,taxonomy_Double,sweetcoconut_database,port)\",\n \"def addresses_per_kvk_to_sql(self):\\n\\n self.logger.info(\\\"Start writing the addressees to the sql Addresses table\\\")\\n if self.address_df.index.size == 0:\\n self.logger.debug(\\\"Empty address data frame. Nothing to write\\\")\\n return\\n\\n # create selection of data columns\\n self.address_df[COMPANY_KEY] = None\\n columns = [KVK_KEY, NAME_KEY, ADDRESS_KEY, POSTAL_CODE_KEY, CITY_KEY, COMPANY_KEY]\\n df = self.address_df[columns].copy()\\n df.sort_values([KVK_KEY], inplace=True)\\n # count the number of urls per kvk\\n\\n n_postcode_per_kvk = df.groupby(KVK_KEY)[KVK_KEY].count()\\n self.logger.info(f\\\"Found: {self.n_company} companies\\\")\\n wdg = PB_WIDGETS\\n if self.progressbar:\\n wdg[-1] = progress_bar_message(0, self.n_company)\\n progress = pb.ProgressBar(widgets=wdg, maxval=self.n_company, fd=sys.stdout).start()\\n else:\\n progress = None\\n\\n company_list = list()\\n for counter, company in enumerate(self.company_vs_kvk):\\n kvk_nr = int(company.kvk_nummer)\\n # we need to check if this kvk is in de address list still\\n\\n try:\\n n_postcode = n_postcode_per_kvk.loc[kvk_nr]\\n except KeyError:\\n continue\\n\\n # add the company number of url time to the list\\n company_list.extend([company] * n_postcode)\\n\\n if progress:\\n wdg[-1] = progress_bar_message(counter, self.n_company, kvk_nr, company.naam)\\n progress.update(counter)\\n if counter % MAX_SQL_CHUNK == 0:\\n self.logger.info(\\\" Added {} / {}\\\".format(counter, self.n_company))\\n if progress:\\n progress.finish()\\n\\n df[COMPANY_KEY] = company_list\\n\\n self.logger.info(\\\"Converting addresses to dict. This make take some time...\\\")\\n address_list = list(df.to_dict(orient=\\\"index\\\").values())\\n\\n # turn the list of dictionaries into a sql table\\n self.logger.info(\\\"Start writing table addresses\\\")\\n n_batch = int(len(address_list) / MAX_SQL_CHUNK) + 1\\n if self.progressbar:\\n wdg = PB_WIDGETS\\n wdg[-1] = progress_bar_message(0, self.n_company)\\n progress = pb.ProgressBar(widgets=wdg, maxval=n_batch, fd=sys.stdout).start()\\n else:\\n progress = None\\n with self.database.atomic():\\n for cnt, batch in enumerate(pw.chunked(address_list, MAX_SQL_CHUNK)):\\n self.logger.info(\\\"Address chunk nr {}/{}\\\".format(cnt + 1, n_batch))\\n self.AddressTbl.insert_many(batch).execute()\\n if progress:\\n wdg[-1] = progress_bar_message(cnt, n_batch)\\n progress.update(cnt)\\n if progress:\\n progress.finish()\",\n \"def pagerank(self, limit=20):\\r\\n\\t\\tfor urlid in self.url_ids:\\r\\n\\t\\t\\tself.all_scores[urlid] = 1.0\\r\\n\\r\\n\\t\\tfor i in range(limit):\\r\\n\\t\\t\\tfor urlid in self.url_ids:\\r\\n\\t\\t\\t\\tscore = self.all_scores[urlid]\\r\\n\\t\\t\\t\\tfor fromid in self.from_ids[urlid]:\\r\\n\\t\\t\\t\\t\\tscore += self.all_scores[fromid] / \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t (len(self.from_ids[fromid])+len(self.to_ids[fromid]))\\r\\n\\t\\t\\t\\tscore *= 0.85\\r\\n\\t\\t\\t\\tscore += 0.15\\r\\n\\t\\t\\t\\tself.all_scores[urlid] = score\\r\\n\\t\\tself.save_pr()\",\n \"def topstreet_pub(self):\\n out=self.df.withColumn('street', split(col('address'), ',')[0]) \\\\\\n .groupby('street').agg(count('name').alias('st_count')) \\\\\\n .sort(desc(\\\"st_count\\\")).select(\\\"street\\\").limit(1) \\n out.withColumnRenamed('street','street which has highest number of pubs') \\\\\\n .write.mode(\\\"overwrite\\\").csv('{}streetname/'.format(self.target))\\n\\n return out.rdd.map(lambda l:l.street).collect()\",\n \"def update_db(bus_id=def_id):\\n # Instantiate the SQL class for the business data we will be pulling\\n sql = Sql(bus_id)\\n\\n # Check if we have previously analyzed the requested business\\n # If not, pull the raw data and processing the data\\n if sql.check() is not False:\\n print \\\"Already in database!\\\"\\n return\\n\\n # Get business data (name, country, etc) from Yelp API\\n # Limited to 25,000 Yelp API calls per day\\n # There are over 4 million reviews and over 140,000 businesses in database\\n while True:\\n try:\\n bus_info = Yelp(bus_id)\\n break\\n except ValueError:\\n pass\\n except YelpAPI.YelpAPIError:\\n return\\n\\n # Grab review text from SQL database\\n sql.pull_reviews()\\n\\n # Use our trained XGBoost Classifier and TFIDF vectorizer\\n # to determine whether each review is \\\"Favorable\\\" or \\\"Unfavorable\\\"\\n model.predict(sql.reviews)\\n\\n # Conduct sentiment analysis and evaluate word counts in order to\\n # \\\"penalize\\\" the weighting of reviews that don't fit the threshold\\n nlp = Nlp(sql.reviews, sql.stars, model.preds,\\n bus_info.name, bus_info.country, bus_info.city)\\n\\n # Assign variables from all the objects attributes we created\\n # and then input them into a tuple.\\n # The tuple is used to populate the SQL database for faster lookup of\\n # our analysis at a later time\\n # The tuple is also used to populate our dictionary which will be\\n # used for variables that will be rendered on our website\\n name = nlp.name\\n city = nlp.city\\n country = nlp.country\\n old_rating = int(100 * nlp.stars_avg / 5)\\n new_rating = int(nlp.new_rating * 100)\\n rev_count = len(sql.reviews)\\n count_5 = sql.stars.count(5)\\n count_4 = sql.stars.count(4)\\n count_3 = sql.stars.count(3)\\n count_2 = sql.stars.count(2)\\n count_1 = sql.stars.count(1)\\n fav_count = (model.preds == 1).sum()\\n unfav_count = (model.preds == 0).sum()\\n avg_wts = int(100*sum(nlp.avg_wts) / len(nlp.avg_wts))\\n bus_tup = (bus_id, name, city, country, old_rating, new_rating,\\n rev_count, count_5, count_4, count_3, count_2, count_1,\\n fav_count, unfav_count, avg_wts)\\n sql.insert(bus_tup)\\n print bus_tup\",\n \"def query_all():\\n all_nutrients = {}\\n offset_counter = 0\\n\\n while offset_counter <= 7500:\\n query_string = 'https://api.nal.usda.gov/ndb/nutrients/?format=json&api_key={}&nutrients=205&nutrients=204&nutrients=208&nutrients=269&offset={}'.format(api_key, offset_counter)\\n results = requests.get(query_string)\\n all_nutrients[offset_counter] = results.json()\\n offset_counter += 150\\n\\n print all_nutrients\",\n \"def address_to_update(id,con,cur):\\n\\n psql=f\\\"\\\"\\\"select line1,line2,city,state,postal_code,country from address where extern_client_id='{id}'\\\"\\\"\\\"\\n cur.execute(psql)\\n record=cur.fetchall()\\n \\n address={'line1':record[0][0],\\n 'line2':record[0][1],\\n 'city':record[0][2],\\n 'state':record[0][3],\\n 'postal_code':record[0][4],\\n 'country':record[0][5]}\\n return address\",\n \"def _process_pub_dbxref(self, limit):\\n\\n if self.testMode:\\n g = self.testgraph\\n else:\\n g = self.graph\\n model = Model(g)\\n raw = '/'.join((self.rawdir, 'pub_dbxref'))\\n logger.info(\\\"processing pub_dbxref\\\")\\n\\n line_counter = 0\\n\\n with open(raw, 'r') as f:\\n filereader = csv.reader(f, delimiter='\\\\t', quotechar='\\\\\\\"')\\n f.readline() # read the header row; skip\\n for line in filereader:\\n (pub_dbxref_id, pub_id, dbxref_id, is_current) = line\\n # 49648\\t43222\\t395730\\tt\\n\\n pub_key = pub_id\\n pub_id = self.idhash['publication'][pub_key]\\n\\n if self.testMode and int(pub_key) not in self.test_keys['pub']:\\n continue\\n\\n # get any dbxrefs for pubs, including pmids and dois\\n dbxref_key = dbxref_id\\n if str(dbxref_key) in self.dbxrefs:\\n dbxrefs = self.dbxrefs[str(dbxref_key)]\\n # pub_dbs = [75, 51, 76, 95, 126]\\n pmid_ids = [50, 77, 275, 286, 347]\\n # flybase_ids = [4] # TODO unused\\n isbn = [75, 51]\\n for d in dbxrefs:\\n dbxref_id = None\\n if int(d) in pmid_ids:\\n if re.match(r'^PMID', dbxrefs[d]):\\n dbxref_id = dbxrefs[d].strip()\\n else:\\n dbxref_id = 'PMID:'+dbxrefs[d].strip()\\n model.makeLeader(dbxref_id)\\n elif int(d) in isbn:\\n dbxref_id = 'ISBN:'+dbxrefs[d].strip()\\n elif int(d) == 161:\\n dbxref_id = 'DOI:'+dbxrefs[d].strip()\\n # elif int(d) == 4:\\n # dbxref_id = 'FlyBase:'+dbxrefs[d].strip()\\n\\n if dbxref_id is not None:\\n reference = Reference(\\n g, dbxref_id,\\n Reference.ref_types['publication'])\\n reference.addRefToGraph()\\n model.addSameIndividual(pub_id, dbxref_id)\\n line_counter += 1\\n\\n if not self.testMode \\\\\\n and limit is not None and line_counter > limit:\\n break\\n\\n return\",\n \"def get_all_from_top_ten(title,users,max = 3):\\n \\\"\\\"\\\" ten prolific users \\\"\\\"\\\"\\n \\\"\\\"\\\" max : number of user with related followers \\\"\\\"\\\"\\n getAllUsers(users,all_users,users_set,proceeded_users,max,user_cpt,title)\\n for data in users_set:\\n print(data.id)\",\n \"def setpmidInfo():\\n DB = PT.DB\\n for p in PT.proteins:\\n f = DB[p]['PMID_link']\\n #print f\\n try:\\n auth, tit = t.fetchPMIDSummary(f['text'])\\n #print 'got info', tit\\n except:\\n print 'no pmid'\\n try:\\n f['authors'] = auth\\n f['title'] = tit\\n print auth, tit\\n #print DB[p]['PMID_link']\\n except:\\n print 'no dict'\\n \\n return\",\n \"def placesBuides():\\n con=lite.connect('parking.db')\\n cursor=con.cursor()\\n cursor.execute(\\\"SELECT (10-count(*)) FROM parking where placa NOT NULL\\\")\\n row=cursor.fetchone()\\n if row:\\n print \\\"El nombre de places disponibles es:\\\",row[0]\\n con.close()\",\n \"def _BuildAddressBook(self, zone, counter, address):\\n if zone not in self.addressbook:\\n self.addressbook[zone] = collections.defaultdict(list)\\n if str(counter) in self.addressbook[zone]:\\n return counter\\n self.addressbook[zone][str(counter)].append(address)\\n return counter + 1\",\n \"def get_sorted_cities(db):\\n city_rec = {'Vancouver' : 0,\\n 'Calgary' : 0,\\n 'Edmonton' : 0,\\n 'Saskatoon' : 0,\\n 'Winnipeg' : 0,\\n 'Toronto' : 0} #to simplify the exam I am providing this, but in practice you would build this structure on the fly\\n\\n #YOUR CODE GOES HERE\\n \\n\\n sales = city_rec.sales\\n sorted_sales = sales.sort(reverse = True)\\n\\n \\n for index in range(1, len(sorted_sales)):\\n currentValue = sorted_sales[index]\\n currentPosition = index\\n\\n while currentPosition > 0 and compare_function(sorted_sales[currentPosition - 1], currentValue):\\n sorted_sales[currentPosition] = array[currentPosition - 1]\\n currentPosition = currentPosition - 1\\n\\n array[currentPosition] = currentValue\\n\\n return get_sorted_cities(city_rec, sorted_sales)\",\n \"def populate(self):\\n\\n NUM_COUNTRIES = 2 # random.randint(1, 4)\\n\\n # find a suitable hex\\n with Timer(\\\"Creating initial data\\\", debug=self.debug):\\n\\n for i in range(NUM_COUNTRIES):\\n country, provinces, pops = create_country(self, self.map)\\n country.determine_tax_policy()\\n self.countries.append(country)\",\n \"def addQueryArp(self, num=1):\\n self.query_arp += num\",\n \"def build_addresses(self):\\n \\n from ambry.geo.geocoders import DstkGeocoder\\n\\n facilities = self.partitions.find(table='facilities')\\n\\n def address_gen():\\n for row in facilities.query(\\\"SELECT * FROM facilities\\\"):\\n address = \\\"{}, {}, {} {}\\\".format(row['dba_address1'], row['dba_city'], 'CA', row['dba_zip_code'])\\n yield (address, row)\\n\\n dstk_service = self.config.service('dstk')\\n \\n dstk_gc = DstkGeocoder(dstk_service, address_gen())\\n \\n p = self.partitions.find_or_new(table='facilities_addresses')\\n p.clean()\\n \\n lr = self.init_log_rate(500)\\n \\n with p.inserter() as ins:\\n for i, (k, r, inp_row) in enumerate(dstk_gc.geocode()):\\n lr(\\\"Addresses \\\"+str(i))\\n r['facilities_id'] = inp_row['id']\\n ins.insert(r)\",\n \"def placement_fix():\\r\\n def func(place):\\r\\n if place in ['3', '4']:\\r\\n return '3-4'\\r\\n elif place in ['5', '6', '7', '8']:\\r\\n return '5-8'\\r\\n else:\\r\\n return place\\r\\n \\r\\n for place in decks_coll.find({}):\\r\\n record_id = place['_id']\\r\\n decks_coll.update_one({'_id': record_id}, {'$set': {'placement': func(place['placement'])}})\",\n \"def firstPass(self, priorityBondList=[]):\\r\\n self.lastRefreshTime = datetime.datetime.now()\\r\\n if priorityBondList == []:\\r\\n emptyLines = list(self.df.index)\\r\\n isins = self.embondsisins + BBGHand + ' Corp'\\r\\n else:\\r\\n emptyLines = priorityBondList\\r\\n isins = self.df.loc[priorityBondList, 'ISIN'] + BBGHand + ' Corp'\\r\\n isins = list(isins.astype(str))\\r\\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceLongQuery)\\r\\n blptsStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\\r\\n blpts.register(blptsStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n isins = self.rfbondsisins + ' @CBBT Corp'\\r\\n isins = list(isins.astype(str))\\r\\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceRFQuery)\\r\\n blptsStream = StreamWatcher(self, BloombergQuery.FIRSTPASS)\\r\\n blpts.register(blptsStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n specialBondList = list(set(emptyLines) & set(SPECIALBONDS))\\r\\n specialIsins = map(lambda x:self.df.at[x,'ISIN'] + BBGHand + ' Corp',specialBondList)\\r\\n blpts = blpapiwrapper.BLPTS(specialIsins, self.bbgPriceLongSpecialQuery)\\r\\n specialbondStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\\r\\n blpts.register(specialbondStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n for bond in emptyLines:\\r\\n self.updateStaticAnalytics(bond) # This will update benchmarks and fill grid. Has to be done here so all data for benchmarks is ready.\\r\",\n \"async def fetch(self, hostname, **params):\\n\\n self.source_records.extend(\\n await self.source.client.paginate(\\n url=_IPAM_ADDR_URL, filters=dict(device=hostname, **params)\\n )\\n )\",\n \"def readdata(self, prefix, date, county):\\n print('F30A: prefix and date', prefix, date)\\n\\n filetoread = open(prefix + 'EL30A')\\n\\n lines = []\\n for line in filetoread:\\n lines.append(line)\\n\\n linelimit = len(lines)\\n# print('LINELIMIT', linelimit)\\n linesub = 0\\n while linesub < linelimit:\\n line = lines[linesub]\\n\\n if len(line) < 4:\\n linesub += 1\\n continue\\n if len(line.split()) < 2:\\n linesub += 1\\n continue\\n possiblepctnumber = line[0:4]\\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\\n self._pctnumber = possiblepctnumber\\n self._pctname = line[4:].strip()\\n if self._pctnumber not in globalpcts:\\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\\n else:\\n onepct = globalpcts[self._pctnumber]\\n\\n # here's the new 12 June 2018 kluge to get the numbers\\n if 'BALLOTS CAST - TOTAL' in line:\\n line = line.replace('.', ' ')\\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\\n line = line.replace(',', '') # commas in numbers\\n\\n# linesplit = line.split()\\n self._ballots = []\\n for item in line.split():\\n self._ballots.append(int(item))\\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\\n onepct.updatefrom30a(self._registered, self._ballots, county)\\n globalpcts[self._pctnumber] = onepct\\n linesub += 1\",\n \"def bulk_lookup_rdap(addresses=None, inc_raw=False, retry_count=3, depth=0,\\n excluded_entities=None, rate_limit_timeout=60,\\n socket_timeout=10, asn_timeout=240, proxy_openers=None):\\n\\n if not isinstance(addresses, list):\\n\\n raise ValueError('addresses must be a list of IP address strings')\\n\\n # Initialize the dicts/lists\\n results = {}\\n failed_lookups_dict = {}\\n rated_lookups = []\\n stats = {\\n 'ip_input_total': len(addresses),\\n 'ip_unique_total': 0,\\n 'ip_lookup_total': 0,\\n 'lacnic': {'failed': [], 'rate_limited': [], 'total': 0},\\n 'ripencc': {'failed': [], 'rate_limited': [], 'total': 0},\\n 'apnic': {'failed': [], 'rate_limited': [], 'total': 0},\\n 'afrinic': {'failed': [], 'rate_limited': [], 'total': 0},\\n 'arin': {'failed': [], 'rate_limited': [], 'total': 0},\\n 'unallocated_addresses': []\\n }\\n asn_parsed_results = {}\\n\\n if proxy_openers is None:\\n\\n proxy_openers = [None]\\n\\n proxy_openers_copy = iter(proxy_openers)\\n\\n # Make sure addresses is unique\\n unique_ip_list = list(unique_everseen(addresses))\\n\\n # Get the unique count to return\\n stats['ip_unique_total'] = len(unique_ip_list)\\n\\n # This is needed for iteration order\\n rir_keys_ordered = ['lacnic', 'ripencc', 'apnic', 'afrinic', 'arin']\\n\\n # First query the ASN data for all IPs, can raise ASNLookupError, no catch\\n bulk_asn = get_bulk_asn_whois(unique_ip_list, timeout=asn_timeout)\\n\\n # ASN results are returned as string, parse lines to list and remove first\\n asn_result_list = bulk_asn.split('\\\\n')\\n del asn_result_list[0]\\n\\n # We need to instantiate IPASN, which currently needs a Net object,\\n # IP doesn't matter here\\n net = Net('1.2.3.4')\\n ipasn = IPASN(net)\\n\\n # Iterate each IP ASN result, and add valid RIR results to\\n # asn_parsed_results for RDAP lookups\\n for asn_result in asn_result_list:\\n\\n temp = asn_result.split('|')\\n\\n # Not a valid entry, move on to next\\n if len(temp) == 1:\\n\\n continue\\n\\n ip = temp[1].strip()\\n\\n # We need this since ASN bulk lookup is returning duplicates\\n # This is an issue on the Cymru end\\n if ip in asn_parsed_results.keys(): # pragma: no cover\\n\\n continue\\n\\n try:\\n\\n results = ipasn.parse_fields_whois(asn_result)\\n\\n except ASNRegistryError: # pragma: no cover\\n\\n continue\\n\\n # Add valid IP ASN result to asn_parsed_results for RDAP lookup\\n asn_parsed_results[ip] = results\\n stats[results['asn_registry']]['total'] += 1\\n\\n # Set the list of IPs that are not allocated/failed ASN lookup\\n stats['unallocated_addresses'] = list(k for k in addresses if k not in\\n asn_parsed_results)\\n\\n # Set the total lookup count after unique IP and ASN result filtering\\n stats['ip_lookup_total'] = len(asn_parsed_results)\\n\\n # Track the total number of LACNIC queries left. This is tracked in order\\n # to ensure the 9 priority LACNIC queries/min don't go into infinite loop\\n lacnic_total_left = stats['lacnic']['total']\\n\\n # Set the start time, this value is updated when the rate limit is reset\\n old_time = time.time()\\n\\n # Rate limit tracking dict for all RIRs\\n rate_tracker = {\\n 'lacnic': {'time': old_time, 'count': 0},\\n 'ripencc': {'time': old_time, 'count': 0},\\n 'apnic': {'time': old_time, 'count': 0},\\n 'afrinic': {'time': old_time, 'count': 0},\\n 'arin': {'time': old_time, 'count': 0}\\n }\\n\\n # Iterate all of the IPs to perform RDAP lookups until none are left\\n while len(asn_parsed_results) > 0:\\n\\n # Sequentially run through each RIR to minimize lookups in a row to\\n # the same RIR.\\n for rir in rir_keys_ordered:\\n\\n # If there are still LACNIC IPs left to lookup and the rate limit\\n # hasn't been reached, skip to find a LACNIC IP to lookup\\n if (\\n rir != 'lacnic' and lacnic_total_left > 0 and\\n (rate_tracker['lacnic']['count'] != 9 or\\n (time.time() - rate_tracker['lacnic']['time']\\n ) >= rate_limit_timeout\\n )\\n ): # pragma: no cover\\n\\n continue\\n\\n # If the RIR rate limit has been reached and hasn't expired,\\n # move on to the next RIR\\n if (\\n rate_tracker[rir]['count'] == 9 and (\\n (time.time() - rate_tracker[rir]['time']\\n ) < rate_limit_timeout)\\n ): # pragma: no cover\\n\\n continue\\n\\n # If the RIR rate limit has expired, reset the count/timer\\n # and perform the lookup\\n elif ((time.time() - rate_tracker[rir]['time']\\n ) >= rate_limit_timeout): # pragma: no cover\\n\\n rate_tracker[rir]['count'] = 0\\n rate_tracker[rir]['time'] = time.time()\\n\\n # Create a copy of the lookup IP dict so we can modify on\\n # successful/failed queries. Loop each IP until it matches the\\n # correct RIR in the parent loop, and attempt lookup\\n tmp_dict = asn_parsed_results.copy()\\n\\n for ip, asn_data in tmp_dict.items():\\n\\n # Check to see if IP matches parent loop RIR for lookup\\n if asn_data['asn_registry'] == rir:\\n\\n log.debug('Starting lookup for IP: {0} '\\n 'RIR: {1}'.format(ip, rir))\\n\\n # Add to count for rate-limit tracking only for LACNIC,\\n # since we have not seen aggressive rate-limiting from the\\n # other RIRs yet\\n if rir == 'lacnic':\\n\\n rate_tracker[rir]['count'] += 1\\n\\n # Get the next proxy opener to use, or None\\n try:\\n\\n opener = next(proxy_openers_copy)\\n\\n # Start at the beginning if all have been used\\n except StopIteration:\\n\\n proxy_openers_copy = iter(proxy_openers)\\n opener = next(proxy_openers_copy)\\n\\n # Instantiate the objects needed for the RDAP lookup\\n net = Net(ip, timeout=socket_timeout, proxy_opener=opener)\\n rdap = RDAP(net)\\n\\n try:\\n\\n # Perform the RDAP lookup. retry_count is set to 0\\n # here since we handle that in this function\\n results = rdap.lookup(\\n inc_raw=inc_raw, retry_count=0, asn_data=asn_data,\\n depth=depth, excluded_entities=excluded_entities\\n )\\n\\n log.debug('Successful lookup for IP: {0} '\\n 'RIR: {1}'.format(ip, rir))\\n\\n # Lookup was successful, add to result. Set the nir\\n # key to None as this is not supported\\n # (yet - requires more queries)\\n results[ip] = results\\n results[ip]['nir'] = None\\n\\n # Remove the IP from the lookup queue\\n del asn_parsed_results[ip]\\n\\n # If this was LACNIC IP, reduce the total left count\\n if rir == 'lacnic':\\n\\n lacnic_total_left -= 1\\n\\n log.debug(\\n '{0} total lookups left, {1} LACNIC lookups left'\\n ''.format(str(len(asn_parsed_results)),\\n str(lacnic_total_left))\\n )\\n\\n # If this IP failed previously, remove it from the\\n # failed return dict\\n if (\\n ip in failed_lookups_dict.keys()\\n ): # pragma: no cover\\n\\n del failed_lookups_dict[ip]\\n\\n # Break out of the IP list loop, we need to change to\\n # the next RIR\\n break\\n\\n except HTTPLookupError: # pragma: no cover\\n\\n log.debug('Failed lookup for IP: {0} '\\n 'RIR: {1}'.format(ip, rir))\\n\\n # Add the IP to the failed lookups dict if not there\\n if ip not in failed_lookups_dict.keys():\\n\\n failed_lookups_dict[ip] = 1\\n\\n # This IP has already failed at least once, increment\\n # the failure count until retry_count reached, then\\n # stop trying\\n else:\\n\\n failed_lookups_dict[ip] += 1\\n\\n if failed_lookups_dict[ip] == retry_count:\\n\\n del asn_parsed_results[ip]\\n stats[rir]['failed'].append(ip)\\n\\n if rir == 'lacnic':\\n\\n lacnic_total_left -= 1\\n\\n # Since this IP failed, we don't break to move to next\\n # RIR, we check the next IP for this RIR\\n continue\\n\\n except HTTPRateLimitError: # pragma: no cover\\n\\n # Add the IP to the rate-limited lookups dict if not\\n # there\\n if ip not in rated_lookups:\\n\\n rated_lookups.append(ip)\\n stats[rir]['rate_limited'].append(ip)\\n\\n log.debug('Rate limiting triggered for IP: {0} '\\n 'RIR: {1}'.format(ip, rir))\\n\\n # Since rate-limit was reached, reset the timer and\\n # max out the count\\n rate_tracker[rir]['time'] = time.time()\\n rate_tracker[rir]['count'] = 9\\n\\n # Break out of the IP list loop, we need to change to\\n # the next RIR\\n break\\n\\n return_tuple = namedtuple('return_tuple', ['results', 'stats'])\\n return return_tuple(results, stats)\",\n \"def update_weekly_total(areacode=AREACODE,areaname=AREA):\\n start,stop=model_calcs.RANGE_WEEK\\n log.debug(f'Processing {areaname}')\\n for week in range(start,stop+1):\\n end_day=ons_week.week(week)\\n \\n week_total=weekly_total(end_day,areacode=areacode,areaname=areaname)\\n #print(f'{areaname}: Weektotal for week number {week} ending {end_day}: {week_total}')\\n \\n if week_total is not None:\\n try:\\n stored,created=CovidWeek.objects.get_or_create(areacode=areacode,week=week)\\n #print(stored.weeklycases)\\n if stored.weeklycases != week_total:\\n log.debug(f'{areaname}: updating week {week} from {stored.weeklycases} to {week_total}')\\n stored.weeklycases=week_total\\n stored.areaname=areaname\\n stored.save()\\n if created:\\n stored.nation=ons_week.nation[areacode]\\n stored.areaname=areaname\\n log.debug(f'Created new entry for week {week} for {areaname}')\\n stored.week=week\\n stored.save()\\n except Exception as e:\\n log.error(e)\\n log.error(f'No data stored for {areaname} week {week}')\\n else:\\n log.error(f'Bypassing {areaname} - no data')\",\n \"def sequence_ingest(self,sequence):\\n\\t\\tdata=self.data\\n\\t\\t\\n\\t\\tcounter=0\\n\\n\\t\\tfor item in data[sequence]:\\n\\t\\t\\tdatestring=item['specimenDate']\\n\\t\\t\\tdate=fetchdate(datestring)\\n\\t\\t\\trow,created=DailyCases.objects.get_or_create(specimenDate=date,areacode=item['areaCode'])\\n\\t\\t\\trow.areaname=item['areaName']\\n\\t\\t\\trow.dailyLabConfirmedCases=item['dailyLabConfirmedCases']\\n\\t\\t\\trow.totalLabConfirmedCases=item['totalLabConfirmedCases']\\n\\t\\t\\trow.changeInDailyCases=item['changeInDailyCases']\\n\\t\\t\\trow.dailyTotalLabConfirmedCasesRate=item['dailyTotalLabConfirmedCasesRate']\\n\\t\\t\\trow.previouslyReportedDailyCases=item['previouslyReportedDailyCases']\\n\\t\\t\\trow.previouslyReportedTotalCases=item['previouslyReportedTotalCases']\\n\\t\\t\\trow.changeInTotalCases=item['changeInTotalCases']\\n\\t\\t\\trow.save()\\n\\t\\t\\tcounter+=1\\n\\t\\tlog.info(f'Processed: {counter} rows')\",\n \"def fullAssociative(addresses,block_size,mode,extended=True,pretty_print=True):\\n container = LRU(block_size)\\n for i in range(block_size):\\n container[i] = \\\" \\\"\\n table = [\\\" \\\"]* block_size\\n full_table = []\\n iterator = 0\\n for address in addresses:\\n parseResult = parseAddressFA(address)\\n tag, address_result = parseResult[\\\"tag\\\"], parseResult[\\\"address_result\\\"]\\n if mode==\\\"RANDOM\\\":\\n if address_result in table:\\n result = Fore.GREEN + \\\"HIT\\\" + Style.RESET_ALL\\n elif \\\" \\\" in table:\\n for i in range(0,block_size):\\n if \\\" \\\" == table[i]:\\n table[i] = address_result\\n break\\n result = Fore.RED + \\\"MISSED\\\" + Style.RESET_ALL\\n else:\\n position = randint(0,block_size - 1)\\n result = Fore.YELLOW + \\\"COLLISION\\\" + Style.RESET_ALL\\n table[position] = address_result\\n elif mode==\\\"LRU\\\":\\n if address_result in MRU2list(container.items()):\\n for element in container.items():\\n if element[1] == address_result:\\n container[element[0]] = address_result\\n result = Fore.GREEN + \\\"HIT\\\" + Style.RESET_ALL\\n elif \\\" \\\" in MRU2list(container.items()):\\n for element in container.items():\\n if element[1] == \\\" \\\":\\n container[element[0]] = address_result\\n break\\n result = Fore.RED + \\\"MISSED\\\" + Style.RESET_ALL\\n for index in range(len(table)):\\n if table[index] == \\\" \\\":\\n table[index] = address_result\\n break\\n else:\\n element2replace = MRU2list(container.items())[block_size-1]\\n index = container.peek_last_item()\\n container[index] = address_result\\n result = Fore.YELLOW + \\\"COLLISION\\\" + Style.RESET_ALL\\n for index in range(len(table)):\\n if table[index] == element2replace:\\n table[index] = address_result\\n break\\n elif mode==\\\"MRU\\\":\\n if address_result in MRU2list(container.items()):\\n for element in container.items():\\n if element[1] == address_result:\\n container[element[0]] = address_result\\n result = Fore.GREEN + \\\"HIT\\\" + Style.RESET_ALL\\n elif \\\" \\\" in MRU2list(container.items()):\\n for element in container.items():\\n if element[1] == \\\" \\\":\\n container[element[0]] = address_result\\n break\\n result = Fore.RED + \\\"MISSED\\\" + Style.RESET_ALL\\n for index in range(len(table)):\\n if table[index] == \\\" \\\":\\n table[index] = address_result\\n break\\n else:\\n element2replace = MRU2list(container.items())[0]\\n container[0] = address_result\\n result = Fore.YELLOW + \\\"COLLISION\\\" + Style.RESET_ALL\\n for index in range(len(table)):\\n if table[index] == element2replace:\\n table[index] = address_result\\n break\\n elif mode==\\\"FIFO\\\":\\n if address_result in table:\\n result = Fore.GREEN + \\\"HIT\\\" + Style.RESET_ALL\\n elif \\\" \\\" in table:\\n table[iterator] = address_result\\n iterator = iterator + 1\\n result = Fore.RED + \\\"MISSED\\\" + Style.RESET_ALL\\n else:\\n table[iterator] = address_result\\n iterator = iterator + 1\\n result = Fore.YELLOW + \\\"COLLISION\\\" + Style.RESET_ALL\\n if (iterator==block_size):\\n iterator = 0\\n if(extended):\\n full_table.append(flat_list(eval(str([address,tag,address_result,table,result]))))\\n else:\\n full_table.append(flat_list(eval(str([address,table,result]))))\\n if pretty_print:\\n t = PrettyTable(headerFA(block_size,extended))\\n for row in full_table:\\n t.add_row(row)\\n print(t)\\n return full_table\",\n \"def make_data(self, limit: int):\",\n \"def get_268_data(self, dbca_initial_control=None):\\n qs_regions = get_sorted_regions()\\n\\n if dbca_initial_control:\\n # get the fires managed by DBCA\\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED], initial_control=Agency.DBCA,reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\\n else:\\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED],reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\\n\\n pbs_fires_dict = get_pbs_bushfires(outstanding_fires) or []\\n\\n if not dbca_initial_control:\\n self.pbs_fires_dict = pbs_fires_dict\\n #logger.info(\\\"self.pbs_fires_dict: \\\" + str(self.pbs_fires_dict))\\n self.found_fires = [i['fire_id'] for i in self.pbs_fires_dict]\\n self.missing_fires = list(set(outstanding_fires).difference(self.found_fires)) # fire_numbers not returned from PB\\n\\n rpt_map = {}\\n for i in pbs_fires_dict: \\n region_id = i['region']\\n\\n exists = [i for r in qs_regions if r.id==region_id]\\n if exists:\\n if rpt_map.has_key(region_id):\\n rpt_map[region_id]['area'] = rpt_map[region_id]['area'] + float(i['area'])\\n rpt_map[region_id]['number'] = rpt_map[region_id]['number'] + 1\\n \\n else:\\n rpt_map[region_id] = {\\n 'area' : float(i['area']),\\n 'number' : 1\\n }\\n\\n else:\\n raise Exception(\\\"PBS Region id({}) Not Found in BFRS\\\".format(region_id))\\n\\n return rpt_map\",\n \"def spotmap(week, bam, pt):\\n print('Mapping MCAP data to Metrics... ',end=''), \\n bam['Spotfire Data'] = bam.index.to_series().map(pt.fillna(0)['len',week])\\n print('Done')\\n return bam\",\n \"def locate(self):\\n \\n #CONNECT TO API\\n api = GoogleV3(api_key = self.google_key)\\n\\n #INITALIZE ARRAY\\n array = []\\n\\n #START GEOCODING ADDRESSES\\n for i in tqdm(range(len(self.df)), desc='Geocoding Addresses'):\\n\\n \\n row = self.df.iloc[i]\\n\\n #GET ADDRESS VARIABLES\\n st_name = row['street_name']\\n st_number = row['house_number']\\n city = row['city']\\n state = row['state/province']\\n listing_number = row['listing_number']\\n zip = row['postal_code']\\n\\n\\n #FORMAT ADDRESS FOR API\\n full_address = str(\\\"{} {},{},{},{}\\\".format(st_number, st_name, city, state, zip))\\n\\n #TRY TO LOCATE WITH GOOGLE\\n try:\\n \\n location = api.geocode(full_address, timeout=10)\\n\\n lat = location.latitude\\n lon = location.longitude\\n \\n\\n info = [lat,lon, listing_number]\\n\\n array.append(info)\\n\\n next \\n\\n #Go to next if you cant locate\\n except:\\n\\n info = [0,0, listing_number]\\n\\n array.append(info)\\n\\n next\\n\\n #CONVERT SERIES TO DATAFRAME\\n geo_data = pd.DataFrame(data = array, columns = ['lat', 'lon', 'listing_number'])\\n \\n #INNER JOIN DATA TO DATAFRAME\\n self.df = pd.merge(self.df, geo_data, on= 'listing_number', how = 'inner')\",\n \"def search_results():\\n skip = int(flask.request.args.get(\\\"skip\\\", \\\"0\\\"))\\n limit = int(flask.request.args.get(\\\"limit\\\", \\\"20\\\"))\\n\\n obj = {}\\n\\n # query : will be event kit in case of triage information\\n uidstr = flask.request.args.get(\\\"query\\\", None)\\n\\n if uidstr == None:\\n obj[\\\"error\\\"] = \\\"Missing search ID\\\"\\n\\n uidstr = json.loads(uidstr)\\n\\n obj[\\\"query\\\"] = {}\\n obj[\\\"query\\\"][\\\"uid\\\"] = uidstr\\n obj[\\\"clips\\\"] = []\\n states = backend.get_search_sessions()\\n obj[\\\"sessions\\\"] = []\\n for astate in states:\\n obj[\\\"sessions\\\"].append(str(astate))\\n try:\\n uid = uuid.UUID(uidstr)\\n state = backend.get_iqr_search_state(uid)\\n # use the uid of the state and get the information from the database\\n col = str(state.uuid)\\n obj[\\\"collection\\\"] = col\\n searchdb[col].ensure_index([(\\\"model_id\\\", pymongo.ASCENDING),(\\\"probability\\\", pymongo.DESCENDING) ])\\n # Force probabilities\\n obj[\\\"positives\\\"] = list(state.positives)\\n obj[\\\"negatives\\\"] = list(state.negatives)\\n log = \\\"\\\"\\n for id in state.positives:\\n # log = log + \\\"Found %d\\\"%(searchdb[col].find({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id}).count()) + \\\", \\\"\\n # res = searchdb[col].update({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id}, {\\\"$set\\\" : { \\\"probability\\\" : 1.0}})\\n # log = log + \\\"Done %d\\\"%id + \\\", \\\"\\n news = searchdb[col].find_one({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id})\\n news[\\\"probability\\\"] = 1.0001\\n searchdb[col].save(news)\\n log = log + \\\"Now : \\\" + str(news)\\n\\n\\n for id in state.negatives:\\n # log = log + \\\"Found %d\\\"%(searchdb[col].find({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id}).count()) + \\\", \\\"\\n # res = searchdb[col].update({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id}, {\\\"$set\\\" : { \\\"probability\\\" : 0.0}})\\n # log = log + \\\"Done %d\\\"%id + \\\", \\\"\\n news = searchdb[col].find_one({\\\"model_id\\\" : \\\"FUSION\\\", \\\"clip_id\\\" : id})\\n news[\\\"probability\\\"] = 0.0\\n searchdb[col].save(news)\\n log = log + \\\"Now : \\\" + str(news)\\n\\n obj[\\\"log\\\"] = log\\n\\n allres = searchdb[col].find({\\\"model_id\\\" : \\\"FUSION\\\"}).sort([(\\\"probability\\\", pymongo.DESCENDING)]).skip(skip).limit(limit)\\n rank = skip + 1\\n for one in allres:\\n aclip = {}\\n aclip[\\\"score\\\"] = one[\\\"probability\\\"]\\n aclip[\\\"id\\\"] = \\\"HVC\\\" + str(one[\\\"clip_id\\\"]).zfill(6)\\n clipobj = db[\\\"clips\\\"].find_one({\\\"id\\\" : \\\"HVC\\\" + str(one[\\\"clip_id\\\"]).zfill(6)},{\\\"duration\\\" : 1})\\n aclip[\\\"duration\\\"] = clipobj[\\\"duration\\\"]\\n aclip[\\\"rank\\\"] = rank\\n rank = rank + 1\\n obj[\\\"clips\\\"].append(aclip)\\n obj[\\\"count\\\"] = len(obj[\\\"clips\\\"])\\n\\n except Exception as e:\\n obj[\\\"error\\\"] = str(type(e)) + \\\": \\\" + str(e)\\n return jsonify(obj)\\n\\n obj[\\\"next\\\"] = \\\"http://localhost:5003/iqr/search_results?\\\" + urllib.urlencode({\\\"uid\\\" : uid, \\\"skip\\\" : skip+limit } )\\n return jsonify(obj)\",\n \"def main():\\n href_list = fundlist.get_fund_list()\\n\\n single_values = None\\n asset_allocations = None\\n geo_allocations = None\\n sector_allocations = None\\n top10_holdings = None\\n\\n for href in href_list:\\n url = 'http://idata.fundata.com' + href\\n fund_profile = FundProfileScraper(url)\\n\\n value_dict = fund_profile.scrape_all_single_value()\\n if single_values is None:\\n single_values = pd.DataFrame([value_dict.values()],\\n columns=value_dict.keys())\\n else:\\n temp_df = pd.DataFrame(value_dict.values(),\\n columns=value_dict.keys())\\n single_values.append(temp_df)\\n\\n asset_allocation_list = fund_profile.scrape_asset_allocation()\\n allocations_with_href = [[href, asset_class]\\n for asset_class in asset_allocation_list]\\n if asset_allocations is None:\\n asset_allocations = pd.DataFrame(\\n allocations_with_href,\\n columns=['href', 'asset_allocation']\\n )\\n else:\\n temp_df = pd.DataFrame(\\n allocations_with_href,\\n columns=['href', 'asset_allocation']\\n )\\n asset_allocations.append(temp_df)\\n\\n\\n geo_allocations_list = fund_profile.scrape_geo_allocation()\\n geo_allocations_href = [[href, geo_class]\\n for geo_class in geo_allocations_list]\\n if geo_allocations is None:\\n geo_allocations = pd.DataFrame(\\n geo_allocations_href,\\n columns=['href', 'geo_allocation']\\n )\\n else:\\n temp_df = pd.DataFrame(\\n geo_allocations_href,\\n columns=['href', 'geo_allocation']\\n )\\n geo_allocations.append(temp_df)\\n\\n sector_allocations_list = fund_profile.scrape_sector_allocation()\\n sector_allocations_href = [[href, sector_class]\\n for sector_class in sector_allocations_list]\\n if sector_allocations is None:\\n sector_allocations = pd.DataFrame(\\n sector_allocations_href,\\n columns=['href', 'sector_allocation']\\n )\\n else:\\n temp_df = pd.DataFrame(\\n sector_allocations_href,\\n columns=['href', 'sector_allocation']\\n )\\n sector_allocations.append(temp_df)\\n\\n top10_holding_list = fund_profile.scrape_top10_holdings()\\n top10_holding_href = [[href, holding]\\n for holding in top10_holding_list]\\n if top10_holdings is None:\\n top10_holdings = pd.DataFrame(\\n top10_holding_href,\\n columns=['href', 'holding']\\n )\\n else:\\n temp_df = pd.DataFrame(\\n top10_holding_href,\\n columns=['href', 'holding']\\n )\\n top10_holdings.append(temp_df)\\n\\n time.sleep(randint(1, 5))\\n\\n single_values.to_pickle('./single_values.pkl')\\n asset_allocations.to_pickle('./asset_allocations.pkl')\\n geo_allocations.to_pickle('./geo_allocations.pkl')\\n sector_allocations.to_pickle('sector_allocations.pkl')\\n top10_holdings.to_pickle('top10_holdings.pkl')\",\n \"def load_street_address(data):\\n street_addresses = [address['address1'] for address in data]\\n street_address_objects = [StreetAddress(data=street_address)\\n for street_address\\n in street_addresses]\\n StreetAddress.objects.bulk_create(street_address_objects)\",\n \"def load_restaurants(city):\\n session = connect_db()\\n # Start offset at 0 to return the first 20 results from Yelp API request\\n offset = 0\\n\\n # Get total number of restaurants for this city\\n bearer_token = obtain_bearer_token(API_HOST, TOKEN_PATH)\\n result_len = 20\\n \\n # Get all restaurants for a city and load each restaurant into the database\\n # Note: Yelp has a limitation of 1000 for accessible results, so get total results\\n # if less than 1000 or get only 1000 results back even if there should be more\\n while (1000 > offset) and (result_len==20):\\n results = search(bearer_token, 'restaurant', city, offset)\\n result_len = len(results['businesses'])\\n\\n # API response returns a SearchResponse object with accessible attributes\\n # response.businesses returns a list of business objects with further attributes\\n for business in results['businesses']:\\n biz = get_business(bearer_token, business['id'])\\n try:\\n table.insert(biz)\\n except DuplicateKeyError:\\n print 'DUPS!'\\n\\n hour_start_monday = None\\n hour_end_monday = None \\n hour_start_tuesday = None\\n hour_end_tuesday = None\\n hour_start_wednesday = None\\n hour_end_wednesday = None \\n hour_start_thursday = None\\n hour_end_thursday = None \\n hour_start_friday = None\\n hour_end_friday = None \\n hour_start_saturday = None\\n hour_end_saturday = None \\n hour_start_sunday = None\\n hour_end_sunday = None\\n try:\\n yelp_price_level = biz['price']\\n except:\\n yelp_price_level = None\\n try:\\n hours_type = biz['hours'][0]['hours_type']\\n is_open_now = biz['hours'][0]['is_open_now']\\n for item in biz['hours'][0]['open']:\\n if item['day'] == 1:\\n hour_start_tuesday = item['start']\\n hour_end_tuesday = item['end']\\n elif item['day'] == 0:\\n hour_start_monday = item['start']\\n hour_end_monday = item['end']\\n elif item['day'] == 2:\\n hour_start_wednesday = item['start']\\n hour_end_wednesday = item['end']\\n elif item['day'] == 3:\\n hour_start_thursday = item['start']\\n hour_end_thursday = item['end']\\n elif item['day'] == 4:\\n hour_start_friday = item['start']\\n hour_end_friday = item['end']\\n elif item['day'] == 5:\\n hour_start_saturday = item['start']\\n hour_end_saturday = item['end']\\n elif item['day'] == 6:\\n hour_start_sunday = item['start']\\n hour_end_sunday = item['end']\\n except:\\n hours_type = None\\n is_open_now = None\\n hour_start_monday = None\\n hour_end_monday = None \\n hour_start_tuesday = None\\n hour_end_tuesday = None\\n hour_start_wednesday = None\\n hour_end_wednesday = None \\n hour_start_thursday = None\\n hour_end_thursday = None \\n hour_start_friday = None\\n hour_end_friday = None \\n hour_start_saturday = None\\n hour_end_saturday = None \\n hour_start_sunday = None\\n hour_end_sunday = None\\n restaurant = Restaurant(\\n yelp_id = business['id'],\\n yelp_rating = biz['rating'],\\n yelp_review_count = biz['review_count'],\\n name = biz['name'],\\n phone = biz['phone'],\\n yelp_url = biz['url'],\\n yelp_price_level = yelp_price_level,\\n latitude = biz['coordinates']['latitude'],\\n longitude = biz['coordinates']['longitude'],\\n hours_type = hours_type,\\n is_open_now = is_open_now,\\n hour_start_monday = hour_start_monday,\\n hour_end_monday = hour_end_monday,\\n hour_start_tuesday = hour_start_tuesday,\\n hour_end_tuesday = hour_end_tuesday,\\n hour_start_wednesday = hour_start_wednesday,\\n hour_end_wednesday = hour_end_wednesday, \\n hour_start_thursday = hour_start_thursday,\\n hour_end_thursday = hour_end_thursday, \\n hour_start_friday = hour_start_friday,\\n hour_end_friday = hour_end_friday, \\n hour_start_saturday = hour_start_saturday,\\n hour_end_saturday = hour_end_saturday, \\n hour_start_sunday = hour_start_sunday,\\n hour_end_sunday = hour_end_sunday, \\n is_closed = biz['is_closed'],\\n categories = biz['categories'][0]['alias'],\\n display_phone = biz['display_phone'],\\n location = ' '.join(biz['location']['display_address']),\\n location_city = biz['location']['city'],\\n location_state = biz['location']['state'],\\n location_zip_code = biz['location']['zip_code'],\\n location_city_id = biz['location']['city'] + ', ' + biz['location']['state'])\\n session.merge(restaurant)\\n # Yelp returns only 20 results each time, so need to offset by 20 while iterating\\n offset += 20\\n print('current offset: ', offset)\\n session.commit()\",\n \"def _setordering_customer_50A(self, val):\\n self.swift_obj.OrderingCustomer_A = val\\n self.swift_obj.OrderingCustomer_A.swiftTag = '50A'\",\n \"def process_ticket_data():\\r\\n c = conn.cursor()\\r\\n c.execute('Select Count(*) from raw_ticket_data')\\r\\n totalleft = c.fetchone()[0]\\r\\n print('{} total rows required'.format(totalleft))\\r\\n np.random.seed(1)\\r\\n df_total = pd.read_sql_query('Select Ticketnumber, TickIssueDate, TickIssueTime, ViolationDesc, '\\r\\n ' VehMake, TickRPPlate, TickStreetNo, TickMeter, Agency, TickBadgeIssued, '\\r\\n 'TickStreetName , TotalPaid, TotalAmtDue from raw_ticket_data ', conn)\\r\\n columnlist = df_total.columns.tolist()\\r\\n df_total.sort_values(by = 'TickIssueDate', inplace = True)\\r\\n n = 500000\\r\\n totalsize = df_total.shape[0]\\r\\n indexes = [i for i in range(0,totalsize, n)]\\r\\n columnlist = df_total.columns.tolist()\\r\\n columnlist.append('address')\\r\\n tqdm.pandas()\\r\\n j = 1\\r\\n for i in indexes:\\r\\n df = df_total[i:i+n]\\r\\n print('Iteration {} started at {}. {} records left'.format(j, dt.datetime.now().strftime(\\\"%H:%M\\\"), totalsize))\\r\\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\\r\\n df['ViolationDesc'] = df['ViolationDesc'].apply(lambda x: x.replace('METER DTN','MTR OUT DT'))\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\\r\\n df['TotalPaid'] = df['TotalPaid'].apply(return_cost)\\r\\n df['TotalAmtDue'] = df['TotalAmtDue'].apply(lambda x: re.sub('[^1-9]', '', str(x)))\\r\\n df['TickRPPlate'] = df['TickRPPlate'].apply(lambda x: 'None' if len(re.findall('[\\\\w+]', str(x))) == 0 else str(x).replace('[^\\\\w+]', ''))\\r\\n df['Tdelt'] = df['TickIssueTime'].apply(return_time_delta)\\r\\n\\r\\n\\r\\n df_1 = df.merge(single_address, left_on = ['TickStreetNo', 'TickStreetName'], right_on = ['number', 'streetname'])\\r\\n df_2 = df.merge(double_address, left_on = ['TickStreetNo', 'TickStreetName'], right_on = ['number', 'streetname'])\\r\\n\\r\\n df_2 = df_2.merge(df_1, how = 'left', left_on = ['TickIssueDate', 'TickBadgeIssued', 'nhood'], right_on = ['TickIssueDate', 'TickBadgeIssued', 'nhood'])\\r\\n df_3 = df_2[pd.isnull(df_2['Tdelt_y'])]\\r\\n df_2.dropna(subset = ['Tdelt_y'], inplace = True)\\r\\n df_2['timedelta'] = df_2.apply(lambda x: np.abs(x['Tdelt_y'] - x['Tdelt_x']), axis = 1)\\r\\n df_2.sort_values(by = 'timedelta', inplace = True)\\r\\n\\r\\n df_2.columns = [col.replace('_x', '') for col in df_2.columns]\\r\\n df_3.columns = [col.replace('_x', '') for col in df_3.columns]\\r\\n df_2.drop_duplicates(subset = 'TicketNumber', inplace = True)\\r\\n print(\\\"Searching for unmatchable addresses\\\")\\r\\n df_3['address'] = df_3.progress_apply(return_address, axis = 1)\\r\\n\\r\\n df = df_1.append(df_2)\\r\\n df = df.append(df_3)\\r\\n df['TickIssueDate'] = df.apply(Time, axis = 1)\\r\\n df = df[columnlist]\\r\\n\\r\\n if i == 0:\\r\\n df.to_sql('ticket_data', if_exists = 'replace',con = conn)\\r\\n else:\\r\\n df.to_sql('ticket_data', if_exists = 'append',con = conn)\\r\\n\\r\\n totalsize -= n\\r\\n j+=1\\r\\n\\r\\n del c\\r\\n\\r\\n return\",\n \"def setup_sample_data(no_of_records):\\n rows_in_database = [{'id': counter, 'name': get_random_string(string.ascii_lowercase, 20), 'dt': '2017-05-03'}\\n for counter in range(0, no_of_records)]\\n return rows_in_database\",\n \"def searchPT(self, vpn, PPN_new):\\n if vpn in self.PT:#Mapping exists in page table. \\n #vb = self.PT.get(vpn)[1] #\\n self.pagehits += 1\\n #Update access time for a hit.\\n #print(\\\"PAGE HIT!\\\")\\n for i in range(len(self.memory)):\\n page = self.memory[i]\\n if page[2] == vpn:\\n self.memory[i] = (page[0], self.accesses, vpn)\\n break\\n\\n #self.memory.append((ppn, self.accesses, vpn))\\n return self.PT.get(vpn)[0]\\n # else:\\n # self.pagefaults += 1\\n # ppn = self.next_available_PPN() #Get next available page number in memory to load from. \\n # self.PT[vpn] = (ppn, 1) #Set page table.\\n # self.TLB[vpn] = ppn\\n # if len(self.memory) < self.MaxMemPages:\\n # self.memory.append((ppn, self.accesses))\\n\\n else: #Mapping does not exist. \\n self.pagefaults += 1 #Not in memory. Must load.\\n ppn = self.next_available_PPN() #Get next available page number in memory to load from. \\n #LRU_ppn = self.getLRUPPN() #Get frame number to replace. \\n #Update memory, PT, and TLB\\n removed_memory = False\\n removed_ppn = 0\\n removed_vpn = 0\\n #Update memory FIRST \\n if len(self.memory) < self.MaxMemPages:\\n self.memory.append((ppn, self.accesses, vpn))\\n else: #Need to replace LRU frame number (PPN).\\n #print(\\\"Going to replace page\\\", ppn)\\n for PPN_s, access_num, VPN_S in self.memory:\\n if PPN_s == ppn:\\n removed_ppn = PPN_s\\n removed_vpn = VPN_S\\n self.memory.remove((PPN_s,access_num, VPN_S)) #Remove LRU PTE\\n self.memory.append((ppn, self.accesses, vpn)) #Replace it with new one. \\n break \\n removed_memory = True \\n #Update page table.\\n if len(self.PT) < self.MaxPTEntries:\\n self.PT[vpn] = (ppn, 1) #Set page table.\\n if len(self.TLB) < self.TLBEntries:\\n self.TLB[vpn] = ppn #Set page table.\\n\\n if removed_memory:\\n #Need to replace an entry in TLB AND Page table.\\n for VPN_s, PTE in self.PT.items():\\n if PTE[0] == removed_ppn:\\n self.PT.pop(VPN_s) #Remove LRU PTE\\n self.PT[vpn] = (ppn, 1) #Replace it with new one.\\n break\\n for VPN_S, PPN_S in self.TLB.items():\\n if PPN_S == removed_ppn:\\n self.TLB.pop(VPN_S) #Remove LRU PTE\\n self.TLB[vpn] = ppn #Replace it with new one. \\n break \\n return ppn\",\n \"def _prep_data( self, db_device_adapter, db_start, db_end, min_points ):\\n msg = f\\\"Preparing data for {db_device_adapter.name}\\\"\\n AppGlobal.gui.display_info_string( msg )\\n #self.logger.debug( f\\\"_prep_data {db_start}, {db_end}\\\" )\\n\\n# set_zero = self.parameters.graph_time_zero # \\\"max\\\" # min max\\n# units = self.parameters.graph_time_units # \\\"hour\\\" # day hour use my converter in future\\n\\n db_device_name = db_device_adapter.name\\n time_data = [] # raw data on time may be timestamp......\\n\\n inst_pw_data = [] #\\n total_power_data = [] #\\n\\n# ( plug_name, plug_time, measure_type, plug_state, voltage, current, inst_power, total_power )\\n\\n sql = ( \\\"SELECT plug_name, plug_time, measure_type, plug_state, voltage, current, inst_power, total_power \\\" +\\n \\\" FROM plug_measurements WHERE ( plug_time > ? ) AND ( plug_time < ? ) AND ( plug_name = ? ) order by plug_time asc\\\" )\\n\\n a_datetime_begin = datetime.datetime.fromtimestamp( db_start )\\n# print( f\\\"a_datetime_begin = { type(a_datetime_begin)} {a_datetime_begin} \\\" )\\n\\n a_datetime_end = datetime.datetime.fromtimestamp( db_end )\\n# print( f\\\"a_datetime_end = { type(a_datetime_end)} {a_datetime_end} \\\" )\\n\\n db_file_name = AppGlobal.gui.get_db_file_name()\\n if not( os.path.isfile( db_file_name )):\\n msg = f\\\"Error: db file does not exist: {db_file_name}\\\"\\n AppGlobal.gui.display_info_string( msg )\\n return( None, None, None )\\n\\n sql_con = lite.connect( db_file_name )\\n with sql_con:\\n cur = sql_con.cursor()\\n# print(f\\\"db_device_name{db_device_name}\\\")\\n cur.execute( sql , ( db_start, db_end, db_device_name ) )\\n\\n # get rows one at a time in loop\\n while True:\\n row = cur.fetchone()\\n\\n if row is None:\\n break\\n print( f\\\"{row} [1] {row[1]} {row[6]}\\\" )\\n\\n time_data.append( row[1] )\\n inst_pw_data.append( row[6] )\\n total_power_data.append( row[7] )\\n\\n msg = f\\\"For device {db_device_name}: data points fetched: {len( time_data )}\\\"\\n AppGlobal.gui.display_info_string( msg )\\n\\n if len( time_data ) < 10:\\n msg = f\\\"Not enough data to process for {db_device_name}\\\"\\n AppGlobal.gui.display_info_string( msg )\\n return( None, None, None )\\n\\n temp = [] # temporary to build new time data will put back ... !! list comp makes this not needed\\n\\n zero = self.parameters.graph_time_zero.lower()\\n if zero in [ \\\"db_sql_begin\\\", ]:\\n #convert_offset = time_data[0] # sec to minutes\\n convert_offset = db_start\\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\\n self.graph_time_zero = f\\\"sql select begin( {a_datetime} )\\\"\\n\\n elif zero in [ \\\"data_begin\\\" ]:\\n\\n convert_offset = time_data[0]\\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\\n self.graph_time_zero = f\\\"first data point( {a_datetime} )\\\"\\n else: # default or error ??\\n convert_offset = db_start\\n a_datetime = datetime.datetime.fromtimestamp( convert_offset )\\n self.graph_time_zero = f\\\"sql select begin( {a_datetime} )\\\"\\n\\n# print( f\\\"parameters say units {self.parameters.graph_time_units}\\\" )\\n units = self.parameters.graph_time_units.lower()\\n if units in [ \\\"min\\\", \\\"minutes\\\" ]:\\n convert_factor = 1./60. # sec to minutes\\n self.graph_time_units = \\\"minutes\\\"\\n elif units in [ \\\"hr\\\", \\\"hour\\\", \\\"hours\\\" ]:\\n convert_factor = 1./( 60. * 60 )\\n self.graph_time_units = \\\"hours\\\"\\n elif units in [ \\\"day\\\", \\\"days\\\", ]:\\n convert_factor = 1./( 60. * 60 * 24 )\\n self.graph_time_units = \\\"days\\\"\\n else: # seconds\\n convert_factor = 1.\\n self.graph_time_units = \\\"seconds\\\"\\n\\n temp = [ ( ( x - convert_offset ) * convert_factor ) for x in time_data ] # temp is new time_data\\n\\n # !! add this for energy zero self.graph_energy_zero = \\\"absolute\\\" # \\\"absolute\\\" \\\"first_value\\\"\\n # !! convert to named tuple\\n graph_data = ( temp, inst_pw_data, total_power_data )\\n\\n return graph_data\",\n \"def _put_reg_prep_in_rc_db(context: 'IconScoreContext', address: 'Address'):\\n\\n rc_tx_batch: list = context.rc_tx_batch\\n block_height: int = context.block.height\\n\\n tx: 'PRepRegisterTx' = RewardCalcDataCreator.create_tx_prep_reg()\\n iiss_tx_data: 'TxData' = RewardCalcDataCreator.create_tx(address, block_height, tx)\\n context.storage.rc.put(rc_tx_batch, iiss_tx_data)\",\n \"def populateNewFields(nadPoints):\\n with arcpy.da.UpdateCursor(nadPoints,\\n ['SHAPE@X', 'SHAPE@Y', 'longitude', 'latitude', 'Source'],\\n spatial_reference=arcpy.SpatialReference(4326)) as cursor:\\n for row in cursor:\\n row[2] = row[0]\\n row[3] = row[1]\\n row[4] = 'Utah AGRC'\\n cursor.updateRow(row)\",\n \"def test_ordered_amount(self):\\n self.app = self.make_app(argv = ['report', 'project_status', self.examples[\\\"project\\\"], '--debug', '-o', \\\"{'P001_101_index3':10, 'P001_102':20}\\\"],extensions=['scilifelab.pm.ext.ext_couchdb'])\\n handler.register(DeliveryReportController)\\n self._run_app()\\n data = ast.literal_eval(self.app._output_data['debug'].getvalue())\\n ordered = {x[0]:x[4] for x in data['table']}\\n self.assertEqual(ordered[\\\"P001_101_index3\\\"], 10)\\n self.assertEqual(ordered[\\\"P001_102\\\"], 20)\",\n \"def sequence_ingest(self,areacode):\\n\\t\\tdata=self.data[self.data['Area code']==areacode]\\n\\t\\tareaname=data['Area name'].unique().item()\\n\\t\\tlog.debug(f'Ingesting cases from {areacode}: {areaname}')\\n\\t\\t\\n\\t\\tcounter=0\\n\\t\\tfor day in data['Specimen date']:\\n\\t\\t\\tdate=fetchdate(day)\\n\\t\\t\\trow,created=DailyCases.objects.get_or_create(specimenDate=date,areacode=areacode)\\n\\t\\t\\tthis_day=data[data['Specimen date']==day]\\n\\t\\t\\trow.areaname=areaname \\n\\t\\t\\t#add head(1) (faster than unique() ) to deal with some areas returned twice as part of both UTLA AND LTLA sequences\\n\\t\\t\\trow.dailyLabConfirmedCases=this_day['Daily lab-confirmed cases'].head(1).item()\\n\\t\\t\\trow.totalLabConfirmedCases=this_day['Cumulative lab-confirmed cases'].head(1).item()\\n\\t\\t\\trow.save()\\n\\t\\t\\tcounter+=1\\n\\t\\tlog.debug(f'Processed: {counter} rows')\",\n \"def fill_priority_table(target_table, curs, conn, no_bins=5, no_obs=4):\\n tar_ids = list(target_table['TAR_ID'])\\n no_bins_1 = [no_bins]*len(target_table)\\n noobs_bin_1 = [no_obs]*len(target_table)\\n complete_1 = ['00'*no_bins]*len(target_table)\\n no_bins_2 = [no_bins]*len(target_table)\\n noobs_bin_2 = [no_obs]*len(target_table)\\n complete_2 = ['00'*no_bins]*len(target_table)\\n urgency = [0]*len(target_table)\\n for i in range(0,len(target_table)):\\n item = [tar_ids[i], no_bins_1[i], noobs_bin_1[i], complete_1[i], \\n no_bins_2[i], noobs_bin_2[i], complete_2[i], urgency[i]]\\n connect_database.add_priority_to_database(item, curs, conn)\",\n \"def _set_top(self, user_n, item_n):\\n self.user_n = user_n\\n self.item_n = item_n\",\n \"def reap():\\n\\n # This might be more efficient by paginating manually and do memcache.get_multi\\n for counter in get_all_counters():\\n value = memcache.get(counter.key.string_id(), namespace=NAMESPACE)\\n # if value is None:\\n # continue\\n _increment_db(counter, value)\\n memcache.decr(counter.key.string_id(), value, namespace=NAMESPACE)\\n print 'memcache: %s => %s' % (counter.key.string_id(), memcache.get(counter.key.string_id(), namespace=NAMESPACE))\",\n \"def getNBMGenerator():\\n limit = 100\\n basesearchurl = u'http://nbm-asp.adlibhosting.com/wwwopacx/wwwopac.ashx?database=collect&search=object_name=schilderij&output=json&limit=%s&startfrom=%s'\\n baseitemurl = u'http://nbm-asp.adlibhosting.com/wwwopacx/wwwopac.ashx?database=collect&search=priref=%s&output=json'\\n baseurl = u'http://collectie.hetnoordbrabantsmuseum.nl/Details/collect/%s'\\n\\n for i in range(0,11):\\n searchurl = basesearchurl % (limit, limit * i,)\\n searchPage = requests.get(searchurl)\\n searchJson = searchPage.json()\\n\\n for searchrecord in searchJson.get('adlibJSON').get('recordList').get('record'):\\n metadata = {}\\n priref = searchrecord.get('@attributes').get('priref')\\n itemurl = baseitemurl % (priref,)\\n url = baseurl % (priref,)\\n\\n metadata['url'] = url\\n\\n itempage = requests.get(itemurl)\\n itemjson = itempage.json()\\n record = itemjson.get('adlibJSON').get('recordList').get('record')[0]\\n\\n metadata['collectionqid'] = u'Q12013217'\\n metadata['collectionshort'] = u'NBM'\\n metadata['locationqid'] = u'Q12013217'\\n\\n #No need to check, I'm actually searching for paintings.\\n metadata['instanceofqid'] = u'Q3305213'\\n\\n # Get the ID. This needs to burn if it's not available\\n metadata['id'] = record['object_number'][0]\\n metadata['idpid'] = u'P217'\\n\\n if record.get('Title'):\\n metadata['title'] = { u'nl' : record.get('Title')[0].get('title')[0].get('value')[0],\\n }\\n\\n if record.get('Production') and record.get('Production')[0].get('creator')[0]:\\n name = record.get('Production')[0].get('creator')[0].get('value')[0]\\n if u',' in name:\\n (surname, sep, firstname) = name.partition(u',')\\n name = u'%s %s' % (firstname.strip(), surname.strip(),)\\n metadata['creatorname'] = name\\n\\n metadata['description'] = { u'nl' : u'%s van %s' % (u'schilderij', metadata.get('creatorname'),),\\n u'en' : u'%s by %s' % (u'painting', metadata.get('creatorname'),),\\n }\\n else:\\n metadata['creatorname'] = u'anonymous'\\n metadata['description'] = { u'nl' : u'schilderij van anonieme schilder',\\n u'en' : u'painting by anonymous painter',\\n }\\n metadata['creatorqid'] = u'Q4233718'\\n\\n # Dimensions are available!\\n # Material is available\\n\\n # Set the inception only if start and end is the same\\n if record.get('Production_date') and \\\\\\n record.get('Production_date')[0].get('production.date.start') and \\\\\\n record.get('Production_date')[0].get('production.date.end'):\\n proddate = record.get('Production_date')[0].get('production.date.start')[0]\\n if proddate == record.get('Production_date')[0].get('production.date.end')[0]:\\n metadata['inception']=proddate\\n\\n yield metadata\\n\\n return\",\n \"def test_can_lookup_postcode(self):\\n postcode_to_lookup = \\\"SW1A 1AA\\\"\\n os_places_key = self.app.config.get(\\\"OS_PLACES_API_KEY\\\")\\n addresses = AddressLookup(key=os_places_key).by_postcode(postcode_to_lookup)\\n self.assertGreater(len(addresses), 0)\\n result_postcode = addresses[0].get(\\\"DPA\\\", {}).get(\\\"POSTCODE\\\")\\n self.assertEqual(result_postcode, postcode_to_lookup)\",\n \"def get_potential_matches_from_address(self, address):\\n\\n def get_potential_matches(sub_tokens):\\n \\n #Create a FTS SQL query using all these tokens\\n\\n search_tokens = \\\" & \\\".join(sub_tokens)\\n \\n #logger.debug(\\\"before {}\\\".format(search_tokens))\\n SQL = self.token_SQL.format(search_tokens, limit)\\n # logger.debug(SQL)\\n try:\\n df = pd.read_sql(SQL,self.data_con)\\n except DatabaseError as e:\\n logger.debug(\\\"db error\\\")\\n df = pd.DataFrame()\\n\\n \\n return df\\n\\n return_list = []\\n\\n logger.debug(\\\"------------\\\")\\n logger.debug(\\\"looking for: \\\" + address.full_address)\\n\\n tokens = address.tokens_original_order_postcode\\n # Get rid of tokens which aren't in AddressBasePremium\\n\\n if address.tokens_specific_to_general_by_freq:\\n tokens_orig = [t for t in tokens if t in address.tokens_specific_to_general_by_freq]\\n else:\\n tokens_orig = tokens\\n tokens_ordered = address.tokens_specific_to_general_by_freq\\n limit = self.max_results\\n\\n #If the address has two token or less, don't even try to match\\n if len(tokens)<3:\\n return return_list\\n\\n #Start with full list of tokens \\n #and get more general by dropping the tokens left to right\\n #at a time until we find a match\\n\\n\\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\\n #CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\\n #LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\\n #TOTTERNHOE, DUNSTABLE LU6 2BZ\\n #etc\\n\\n for tokens in [tokens_orig, tokens_ordered]:\\n for i in range(len(tokens)):\\n\\n sub_tokens = tokens[i:]\\n if len(sub_tokens)<3:\\n df= pd.DataFrame()\\n break\\n\\n df = get_potential_matches(sub_tokens)\\n\\n # If there's a single match, then we've very likely found the right address. Return just the one\\n # if len(df) == 1:\\n # return self.df_to_address_objects(df)\\n\\n if len(df)>0 and len(df)<limit:\\n return_list.extend(self.df_to_address_objects(df))\\n break\\n\\n #Now try going in the opposite direction - i.e. getting rid of the latter\\n #parts of the address first\\n\\n #Do a specific to general search i.e. FTS\\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 2BZ\\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE LU6 \\n #1, CHAPEL LANE, TOTTERNHOE, DUNSTABLE\\n #1, CHAPEL LANE, TOTTERNHOE, \\n #etc\\n\\n\\n for tokens in [tokens_orig, tokens_ordered]:\\n for i in range(1,len(tokens)):\\n sub_tokens = tokens[:-i]\\n if len(sub_tokens)<3: #to make sure it ends with a postcode search\\n break\\n df = get_potential_matches(sub_tokens)\\n\\n # If there's a single match, then we've very likely found the right address. Return just the one\\n # if len(df) == 1:\\n # return self.df_to_address_objects(df)\\n\\n if len(df)>0 and len(df)<limit:\\n return_list.extend(self.df_to_address_objects(df))\\n break\\n\\n if len(df) == 1:\\n return self.df_to_address_objects(df)\\n\\n #If we still haven't found anything make a last ditch attempt by taking random selections\\n # of the tokens\\n num_tokens = len(tokens_ordered)\\n\\n if len(return_list) < 1 and num_tokens > 3:\\n\\n tried = []\\n num_tokens = len(tokens_ordered)\\n if num_tokens > 10:\\n take = num_tokens-5 #at least 6\\n elif num_tokens > 8:\\n take = num_tokens-4 #at least 5\\n elif num_tokens > 3:\\n take = num_tokens-1\\n\\n\\n for i in range(self.SEARCH_INTENSITY):\\n\\n sub_tokens = random.sample(tokens_ordered, take)\\n \\n # logger.debug(\\\", \\\".join(sub_tokens))\\n if tuple(sub_tokens) in tried: \\n continue\\n\\n df = get_potential_matches(sub_tokens)\\n \\n tried.append(tuple(sub_tokens))\\n\\n if len(df)>0 and len(df)<limit:\\n return_list.extend(self.df_to_address_objects(df))\\n break\\n\\n #Finally deduplicate based on text of address \\n\\n final_list = []\\n full_address_set = set()\\n for a in return_list:\\n if a.full_address not in full_address_set:\\n final_list.append(a)\\n full_address_set.add(a.full_address)\\n\\n\\n\\n\\n return final_list\",\n \"def main():\\n # Pull variables from pf\\n profileref = pfget('google_mapfeed.pf', profile)\\n dbname = profileref['dbname']\\n path = profileref['webbase']\\n finalfile = '%s/%s' % (path, profileref['file'])\\n bufferfile = '%s+' % finalfile\\n max_nquakes = 600\\n element_fields = ['lat', 'lon', 'depth', 'time', 'local_timestring', 'utc_timestring', 'magnitude', 'auth']\\n\\n if verbose:\\n print \\\"Start: Creating main JSON file '%s' for all stations at %s\\\" % (finalfile, time.strftime(\\\"%a, %d %b %Y %H:%M:%S +0000\\\", time.gmtime()))\\n\\n now = time.time()\\n # Set time zone\\n os.putenv('TZ','US/Pacific')\\n time.tzset()\\n if verbose:\\n print \\\"The time zone is: %s\\\" % (time.tzname)[0]\\n print \\\"The current time is: %s\\\" % now\\n\\n # Override defaults\\n if override_number:\\n if verbose:\\n print \\\"Overriding default number of events (%d) with %d\\\" % (max_nquakes, override_number)\\n nquakes = override_number\\n else:\\n nquakes = max_nquakes\\n if override_timerange:\\n if verbose:\\n print \\\"Overiding default number of events (%d) with time range %d seconds\\\" % (max_nquakes, override_timerange)\\n nquakes = False\\n\\n # Database processing\\n if verbose:\\n print \\\"Opening database\\\";\\n print \\\"Number of events requested: %s\\\" % nquakes\\n db = dbopen(dbname, 'r')\\n\\n '''\\n Occasionally there is more than one magnitude for a single orid\\n (such as provided by QED). We need the most recent magnitude for\\n a given orid, so sort on orid and lddate, then group on orid,\\n then get the most recent record number (greatest lddate) for each\\n group. Add that to a dictionary we will use later.\\n '''\\n netmag_dict = {}\\n db_netmag = dblookup(db, table='netmag')\\n db_netmag.sort(['orid', 'lddate'])\\n db_netmag_grp = dbgroup(db_netmag, 'orid')\\n if verbose:\\n print \\\"There are %s records\\\" % db_netmag_grp.query('dbRECORD_COUNT')\\n for i in range(db_netmag_grp.query('dbRECORD_COUNT')):\\n db_netmag_grp[3] = i\\n orid, [dbptr, view, end_record, start_record] = db_netmag_grp.getv('orid', 'bundle')\\n if verbose:\\n print \\\"\\\\t- Iteration: %s: Orid: %s, Start record: %s, End record: %s\\\"% (i, orid, start_record, end_record)\\n db_netmag[3] = end_record - 1\\n if verbose:\\n print \\\"\\\\t\\\\t- Magnitude: %s, Magtype: %s\\\" % (db_netmag.getv('magnitude')[0], db_netmag.getv('magtype')[0] )\\n magnitude, magtype = db_netmag.getv('magnitude', 'magtype')\\n netmag_dict[orid] = { 'rec':end_record, 'magnitude':magnitude, 'magtype':magtype }\\n\\n '''\\n if verbose:\\n for key in sorted(netmag_dict.iterkeys()):\\n print \\\"%s: %s\\\" % (key, netmag_dict[key])\\n '''\\n\\n '''\\n Now get the event information\\n '''\\n db.lookup(table='origin')\\n db.join('event')\\n if verbose:\\n print \\\"Number of joined records of event and origin tables: %s\\\" % db.query('dbRECORD_COUNT')\\n if override_timerange:\\n override_oldest = now - override_timerange\\n if verbose:\\n print \\\"Override time defined - get events in the last %s seconds - 'time >= %s'\\\" % (override_timerange, override_oldest)\\n db.subset('time >= %d' % override_oldest)\\n if verbose:\\n print \\\"Subset on time. Number of records: %s\\\" % db.query('dbRECORD_COUNT')\\n # Join views\\n # db_joined = dbjoin(db, db_netmag)\\n\\n if verbose:\\n print \\\"Subset orid == prefor\\\"\\n db.subset('orid == prefor')\\n if verbose:\\n print \\\"Number of subsetted records: %s\\\" % db.query('dbRECORD_COUNT')\\n print \\\"Subset for time != NULL\\\"\\n db.subset('time != NULL')\\n if verbose:\\n print \\\"Number of subsetted records: %s\\\" % db.query('dbRECORD_COUNT')\\n # We want the most recent first for the comparison with nquakes\\n db.sort(['time'], reverse=True)\\n if verbose:\\n print \\\"Number of sorted records: %s\\\" % db.query('dbRECORD_COUNT')\\n if nquakes:\\n if db.query('dbRECORD_COUNT') > nquakes:\\n db[3] = nquakes - 1\\n min_time = db.getv('time')[0]\\n db.subset(\\\"time >= %s\\\" % min_time)\\n else:\\n override_oldest = now - override_timerange\\n if verbose:\\n print \\\"Override time defined - get events in the last %s seconds - time > %s\\\" % (override_timerange, override_oldest)\\n db.subset(\\\"time >= %s\\\" % override_oldest)\\n # Sort in normal time - we want the most recent events plotted on top\\n db.sort(('time'))\\n if verbose:\\n print \\\"Number of records without subset on time: %s\\\" % db.query('dbRECORD_COUNT')\\n '''\\n Build event dictionary\\n '''\\n event_dict = {'metadata':{},'events':{}}\\n\\n '''\\n Build metadata dictionary\\n '''\\n if nquakes:\\n event_dict['metadata']['max_nquakes'] = nquakes\\n event_dict['metadata']['oldest_time_readable'] = epoch2str( int(min_time), \\\"%H:%M UTC %A %B %o, %Y\\\" )\\n event_dict['metadata']['oldest_time'] = int(min_time)\\n event_dict['metadata']['type'] = 'event_limited'\\n elif override_oldest:\\n event_dict['metadata']['time_range'] = int(override_timerange)\\n event_dict['metadata']['oldest_time_readable'] = epoch2str( int(override_oldest), \\\"%H:%M UTC %A %B %o, %Y\\\" )\\n event_dict['metadata']['oldest_time'] = int(override_oldest)\\n event_dict['metadata']['type'] = 'time_limited'\\n event_dict['metadata']['modification_time'] = int(time.time())\\n event_dict['metadata']['modification_time_readable'] = epoch2str( int(time.time()), \\\"%H:%M UTC %A %B %o, %Y\\\" )\\n\\n '''\\n Build event dictionary\\n '''\\n events = {}\\n for i in range(db.query('dbRECORD_COUNT')):\\n db[3] = i\\n if verbose:\\n epoch_time, orid = db.getv('time', 'orid')\\n print \\\"\\\\tRecord number is: %s Orid is: %d Time is: %s\\\" % (db[3], orid, epoch2str(epoch_time, '%Y-%m-%d %H:%M:%S'))\\n\\n orid = db.getv('orid')[0]\\n\\n if orid in netmag_dict:\\n events[i] = {}\\n for ef in element_fields:\\n # Parse values\\n if ef is 'local_timestring' or ef is 'utc_timestring' or ef is 'time':\\n value = dbgetv(db, 'time')[0]\\n difference = float(now) - float(value)\\n if difference < 6 * 3600:\\n color = 'red'\\n elif difference < 12 * 3600:\\n color = 'orange'\\n elif difference < 24 * 3600:\\n color = 'yellow'\\n elif difference < 72 * 3600:\\n color = 'chartreuse'\\n elif difference < 168 * 3600:\\n color = 'blue'\\n else:\\n color = 'grey'\\n events[i]['color'] = color\\n elif ef is 'depth':\\n value = dbgetv(db, 'depth')[0]\\n elif ef is 'auth':\\n value = dbgetv(db, 'auth')[0]\\n elif ef is 'magnitude':\\n # Magnitude\\n # mlval, mbval, msval, magnitudeval, magtypeval = db.getv('ml', 'mb', 'ms', 'magnitude', 'magtype')\\n # Null magnitude is -999.00\\n magnitudeval = netmag_dict[orid]['magnitude']\\n magtypeval = netmag_dict[orid]['magtype']\\n if int(magnitudeval) > 0:\\n scale = magtypeval\\n value = '%.1f' % magnitudeval\\n else:\\n scale = ''\\n value = 'N/A'\\n events[i]['scale'] = scale\\n else:\\n value = dbgetv(db, ef)\\n\\n # Override formatting for specific fields\\n if ef is 'lat' or ef is 'lon':\\n value = '%.4f' % value\\n elif ef is 'local_timestring':\\n value = epoch2str( value, \\\"%H:%M:%S %Z %A %B %o, %Y\\\", \\\"US/Pacific\\\" )\\n elif ef is 'utc_timestring':\\n value = epoch2str( value, \\\"%H:%M:%S UTC %A %B %o, %Y\\\" )\\n events[i][ef] = value\\n\\n full_lat, full_lon = db.getv('lat', 'lon')\\n events[i]['grname'] = (grname(full_lat,full_lon)).title()\\n events[i]['srname'] = (srname(full_lat,full_lon)).title()\\n\\n event_dict['events'] = events\\n\\n # Dump JSON file\\n f = open(bufferfile, 'w') \\n json.dump(event_dict, f, sort_keys=True, indent=2)\\n f.flush()\\n\\n # Move the file to replace the older one\\n try:\\n os.rename(bufferfile, finalfile)\\n except OSError:\\n print \\\"Cannot rename JSON file from %s to %s\\\" % (bufferfile,finalfile)\\n\\n if verbose:\\n print \\\"End: Creating main JSON file '%s' for all stations %s\\\" % (finalfile, time.strftime(\\\"%a, %d %b %Y %H:%M:%S +0000\\\", time.gmtime()))\\n\\n db.close()\\n return 0\",\n \"def ranking_by_address_in_ascending_order(filename):\\r\\n in_address = sort_by_address(filename) #[['201808',1744',희우정로길','5955','69941'],['201808','1743','휘경로길','10483',143839']]\\r\\n address_dict = {}\\r\\n for i in in_address:\\r\\n if i[2] not in address_dict:\\r\\n address_dict[i[2]] = int(i[-1])\\r\\n else:\\r\\n address_dict[i[2]] += int(i[-1]) #주소별로 데이터합산 후 딕셔너리 형태로 저장\\r\\n \\r\\n address_dict_items = sorted(address_dict.items()) #데이터정렬후 튜플 in 리스트로 저장\\r\\n y = []\\r\\n for i in address_dict_items:\\r\\n y.append(list(i)) #튜플 in 리스트 형태를 리스트 in 리스트 형태로 변환\\r\\n for i in range(len(y)):\\r\\n k = y[i][0]\\r\\n y[i][0] = y[i][1]\\r\\n y[i][1] = k #리스트 안에 있는 리스트의 순서를 바꿈 (ex. [행당로,3] -> [3,행당로])\\r\\n rank = []\\r\\n count = 0\\r\\n for i in range(len(y)):\\r\\n s = 0\\r\\n x = y[i][0]\\r\\n for j in range(len(y)):\\r\\n z = y[j][0]\\r\\n if x>z:\\r\\n s += 1\\r\\n rank.append([y[i][1],s+1])\\r\\n count += 1\\r\\n if count == len(y):\\r\\n break #같은 크기의 데이터에 대해 같은 순위를 부여한다\\r\\n result_list = []\\r\\n for i in range(len(rank)):\\r\\n result_list.append([str(rank[i][1])+'위',rank[i][0]])\\r\\n return result_list\",\n \"def query3() :\",\n \"def fetch(index, outfile):\\n populate_index(index, outfile=outfile)\",\n \"def _partial_dbscan(df, settings, sufix):\\n stack = []\\n cluster_label = 0\\n UNMARKED = -1\\n\\n df = df.reset_index(drop=True)\\n num_ids = len(df)\\n eps = settings['eps']\\n minPts = settings['minPts']\\n columns = settings['feature']\\n cluster_col = settings['predCol']\\n\\n # creating a new tmp_id\\n cols = df.columns\\n id_col = 'tmp_dbscan'\\n i = 0\\n while id_col in cols:\\n id_col = 'tmp_dbscan_{}'.format(i)\\n i += 1\\n df[id_col] = ['id{}{}'.format(sufix, j) for j in range(len(df))]\\n settings['idCol'] = id_col\\n\\n C_UNMARKED = \\\"{}{}\\\".format(sufix, UNMARKED)\\n C_NOISE = \\\"{}{}\\\".format(sufix, '-0')\\n df[cluster_col] = [C_UNMARKED for _ in range(num_ids)]\\n\\n df = df.reset_index(drop=True)\\n\\n for index in range(num_ids):\\n point = df.loc[index]\\n CLUSTER = point[cluster_col]\\n\\n if CLUSTER == C_UNMARKED:\\n X = _retrieve_neighbors(df, index, point, eps, columns)\\n\\n if len(X) < minPts:\\n df.loc[df.index[index], cluster_col] = C_NOISE\\n else: # found a core point and assign a label to this point\\n cluster_label += 1\\n df.loc[index, cluster_col] = sufix + str(cluster_label)\\n for new_index in X: # assign core's label to its neighborhood\\n label = sufix + str(cluster_label)\\n df.loc[df.index[new_index], cluster_col] = label\\n if new_index not in stack:\\n stack.append(new_index) # append neighborhood to stack\\n while len(stack) > 0:\\n # find new neighbors from core point neighborhood\\n newest_index = stack.pop()\\n new_point = df.loc[newest_index]\\n Y = _retrieve_neighbors(df, newest_index,\\n new_point, eps, columns)\\n\\n if len(Y) >= minPts:\\n # current_point is a new core\\n for new_index_neig in Y:\\n neig_cluster = \\\\\\n df.loc[new_index_neig][cluster_col]\\n if neig_cluster == C_UNMARKED:\\n df.loc[df.index[new_index_neig],\\n cluster_col] = \\\\\\n sufix + str(cluster_label)\\n if new_index_neig not in stack:\\n stack.append(new_index_neig)\\n\\n settings['clusters'] = df[cluster_col].unique()\\n return [df, settings]\",\n \"def main():\\n\\tresults = collections.OrderedDict()\\n\\n\\tdb = read_database()\\n\\tprint(db)\\n\\tfor name in db.keys():\\n\\t\\tresults[name] = []\\n\\n\\n\\tfor i in range(NUMBER_OF_RACES):\\n\\t\\tsimulation = simulate_performance(db)\\n\\t\\tpos = position(simulation)\\n\\n\\t\\tfor score, name in enumerate(pos,start = 1):\\n\\t\\t\\tresults[name].append(score)\\n\\t\\t\\n\\n\\tprint(results)\\n\\tresults = list(results.items()) # converts OrderedDict to the list\\n\\tprint(results)\\n\\tprint()\\n\\tprint(\\\"SORTED SCORES\\\")\\n\\tprint(sorted_scores(results))\\n\\tfor idx, sailor in enumerate(sorted_scores(results), start=1):\\n\\t\\tprint(\\\"{:>2} {:>10} {:>10}\\\".format(idx, sailor[0], total_score(sailor)))\\n\\tss = sorted_scores(results)\\n\\n\\tprint(\\\"\\\\n\\\\n*** PLACINGS ***\\\")\\n\\tprint(results)\\n\\treturn results\\n\\n\\tprint(\\\"\\\\n\\\\n*** THE ORDER ***\\\")\\n\\tprint([x[0] for x in sorted_scores(results)])\\n\\treturn [x[0] for x in sorted_scores(results)]\",\n \"def per_page():\\n return 100\",\n \"def SitesPredict(Chain, pdb_file, ppdb_ATOM, ProbMap, ScoreThreshold = 0.75, SearchRadius = 5.5, ChemicalElement = 'H'):\\n\\n ResStart = min(ppdb_ATOM['residue_number'][ppdb_ATOM['chain_id']==Chain]) #First residue number\\n ResStop = max(ppdb_ATOM['residue_number'][ppdb_ATOM['chain_id']==Chain]) #Last residue number\\n LOCAL_coord = []\\n Score = [[],[]]\\n\\n console_output = sys.stdout \\n if(pdb_file[-4:] == '.pdb'):\\n OutFile = open(pdb_file[:-4].replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\\n elif(pdb_file[-3:] == '.gz'):\\n OutFile = open(pdb_file[:-7].replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\\n else:\\n OutFile = open(pdb_file.replace('../','')+'_PredictedSites.xyz', 'a') #overwrite file if already present\\n OutFile.close()\\n\\n #Scan all protein structure assigning scores to each residue\\n for i in range(ResStart, ResStop+1):\\n # Scan one residue per time \\n # Missing residues present in the pdb structure are skipped\\n try: \\n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==i] # Atoms of residue considered\\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\\n RES = ppdb_RES['residue_name'].iloc[0]\\n REF = RefAtom(RES) # reference atoms(s) for residue considered \\n reference_coord = [0.0, 0.0, 0.0]\\n add_SearchRadius = 0.0 # For residues with more reference points\\n # SearchRadius augmented, adding distance from midpoint\\n if(len(REF)==1): \\n reference_coord = [ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0], ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0], ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[0])].iloc[0]] \\n else:\\n # if more than one atom is used as reference, the mean position is calculated as reference point\\n for r in range(0,len(REF)):\\n reference_coord[0] += (ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0])\\n reference_coord[1] += (ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0])\\n reference_coord[2] += (ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]) \\n reference_coord[0] /= len(REF)\\n reference_coord[1] /= len(REF)\\n reference_coord[2] /= len(REF)\\n dist = 0.0\\n for r in range(0,len(REF)):\\n dist += (reference_coord[0]-(ppdb_RES['x_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2+(reference_coord[1]-(ppdb_RES['y_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2+(reference_coord[2]-(ppdb_RES['z_coord'][ppdb_RES['atom_name']==str(REF[r])].iloc[0]))**2 \\n dist = np.sqrt(dist)\\n add_SearchRadius += dist\\n add_SearchRadius /= len(REF)\\n \\n # Distance from reference point to any other atom of the structure\\n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(reference_coord[0],reference_coord[1],reference_coord[2]))\\n ppdb_LOCAL = ppdb_ATOM[distances <= (SearchRadius + add_SearchRadius)]\\n ppdb_LOCAL = ppdb_LOCAL[ppdb_LOCAL['residue_number']!=i]\\t\\n \\n # Save local environment for residue considered\\n # Other residues in LOCAL if their reference point(s) distance from the reference_coord\\n # within SearchRadius+add_SearchRadius threshold\\n LOCAL = [[RES],[i]]\\n for l in ppdb_LOCAL['atom_number']:\\n l_index = int(ppdb_LOCAL[ppdb_LOCAL['atom_number']==l].index.to_numpy())\\n if(ppdb_LOCAL['atom_name'].loc[l_index] in RefAtom(ppdb_LOCAL['residue_name'].loc[l_index])):\\n LOCAL[0].append(ppdb_LOCAL['residue_name'].loc[l_index])\\n LOCAL[1].append(ppdb_LOCAL['residue_number'].loc[l_index])\\n\\n # Conversion to 1-letter format, alphabetically sorted\\n for l in range(0,len(LOCAL[0])):\\n LOCAL[0][l] = res_1Letter(LOCAL[0][l])\\n LOCAL_coord.append(''.join(sorted(LOCAL[0])))\\n # Score vector with score for each residue considered\\n # assigned from ProbMap\\n Score[0].append(i)\\n Score[1].append(ScoreLoc(LOCAL_coord[-1], ProbMap))\\n except:\\n continue\\n sortedlist = sorted(zip(Score[1][:],Score[0][:]), reverse=True)\\n \\n coeffScore = 1. - ScoreThreshold \\n highestscoredRES = [] # residue number, score, ref. point coord \\n for i in range(0,len(Score[0])):\\n if(sortedlist[[i][0]][0]>=coeffScore*sortedlist[[0][0]][0]):\\n x, y, z = 0.0, 0.0, 0.0\\n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==sortedlist[[i][0]][1]]\\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\\n for l in range(0,len(RefAtom(ppdb_RES['residue_name'].iloc[0]))):\\n # last iloc[0] to consider only first in case of alt_loc\\n x += float(ppdb_RES['x_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n y += float(ppdb_RES['y_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n z += float(ppdb_RES['z_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n x /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n y /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n z /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n highestscoredRES.append([sortedlist[[i][0]][1],sortedlist[[i][0]][0], x, y, z])\\n highestscoredRES_df = pd.DataFrame([row[2:5] for row in highestscoredRES], columns=['x','y','z'], index=[row[0] for row in highestscoredRES])\\n highestscoredRES_dmatrix = pd.DataFrame(distance_matrix(highestscoredRES_df.values,highestscoredRES_df.values), index=highestscoredRES_df.index, columns=highestscoredRES_df.index)\\n\\n # nearby (closer than 2*Searchradius) residues grouped in clusters\\n # producing 1 predicted site for each group\\n Clusters = []\\n possibleCluster = []\\n for rw in range(0,len(highestscoredRES_dmatrix.index.values)):\\n possibleCluster = []\\n for cl in range(0,len(highestscoredRES_dmatrix.index.values)):\\n if(any(highestscoredRES_dmatrix.index.values[cl] in row for row in Clusters)):\\n continue \\n else:\\n if(highestscoredRES_dmatrix.values[rw][cl]<2*SearchRadius): \\n if(any(highestscoredRES_dmatrix.index.values[rw] in row for row in Clusters)):\\n # residue added to group already existing\\n Clusters[[Clusters.index(row) for row in Clusters if (highestscoredRES_dmatrix.index.values[rw]) in row][0]].append(highestscoredRES_dmatrix.index.values[cl])\\n else:\\n possibleCluster.append(highestscoredRES_dmatrix.index.values[cl])\\n if(len(possibleCluster)>0):\\n Clusters.append(possibleCluster)\\n # highestscoredRES contains RES number, score, x_pos, y_pos, z_pos for each residue\\n # in case of residues with more than one reference atom, midpoint is calculated\\n for i in range(0,len(Clusters)):\\n if(len(Clusters[i][:])==1):\\n # append closest highest scored within threshold\\n for j in range(0,len(Score[0])): \\n if(sortedlist[[j][0]][1] != Clusters[i][0]):\\n x, y, z = 0.0, 0.0, 0.0\\n ppdb_RES = ppdb_ATOM[ppdb_ATOM['residue_number']==sortedlist[[j][0]][1]]\\n ppdb_RES = ppdb_RES[ppdb_RES['chain_id']==Chain]\\n for l in range(0,len(RefAtom(ppdb_RES['residue_name'].iloc[0]))):\\n #last iloc[0] to consider only first in case of alt_loc\\n x += float(ppdb_RES['x_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n y += float(ppdb_RES['y_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n z += float(ppdb_RES['z_coord'][ppdb_RES['atom_name']==RefAtom(ppdb_RES['residue_name'].iloc[0])[l]].iloc[0])\\n x /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n y /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n z /= len(RefAtom(ppdb_RES['residue_name'].iloc[0]))\\n x_c = ([row[2] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\\n y_c = ([row[3] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\\n z_c = ([row[4] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]\\n if(np.sqrt((x-x_c)**2+(y-y_c)**2+(z-z_c)**2)<2*(SearchRadius)):\\n Clusters[i].append(sortedlist[[j][0]][1])\\n if(sortedlist[[j][0]][0]>=coeffScore*([row[1] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])]):\\n highestscoredRES.append([sortedlist[[j][0]][1],sortedlist[[j][0]][0], x, y, z])\\n else:\\n highestscoredRES.append([sortedlist[[j][0]][1],coeffScore*([row[1] for row in highestscoredRES])[([row[0] for row in highestscoredRES]).index(Clusters[i][0])], x, y, z])\\n break \\n else:\\n continue\\n # For each cluster xyz coord for site predicted as weighted average\\n # between positions of RefAtom for each residue\\n # weight depending on the score of the residue\\n # Each predicted location is scored based on surrounding residues\\n # within 0.6*SearchRadius \\n # if the site is farther than SearchRadius from any protein atom the site is discarded\\n # (possible for sites predicted in bulk water)\\n for j in range(0,len(Clusters)):\\n x_avg, y_avg, z_avg = 0.0, 0.0, 0.0\\n sumWeights = 0.0\\n for k in range(0,len(Clusters[j])):\\n resindex = [row[0] for row in highestscoredRES].index(Clusters[j][k])\\n x_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][2]\\n y_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][3]\\n z_avg += highestscoredRES[resindex][1]*highestscoredRES[resindex][4]\\n sumWeights += highestscoredRES[resindex][1]\\n x_avg /= sumWeights \\n y_avg /= sumWeights \\n z_avg /= sumWeights\\n\\t# site discarded if farther than SearchRadius from any protein atom the site \\n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(x_avg,y_avg,z_avg))\\n if(min(distances)>SearchRadius):\\n break \\t\\n # during the loop coordinations temporary written in the output file\\n # edited at the end of the loop according to xyz files formatting\\n # and sorting predicted sites based on score\\n if(pdb_file[-4:] == '.pdb'):\\n sys.stdout = OutFile = open(pdb_file[:-4].replace('../','')+'_PredictedSites.xyz', 'a')\\n elif(pdb_file[-3:] == '.gz'):\\n sys.stdout = OutFile = open(pdb_file[:-7].replace('../','')+'_PredictedSites.xyz', 'a')\\n else:\\n sys.stdout = OutFile = open(pdb_file.replace('../','')+'_PredictedSites.xyz', 'a')\\n\\n sys.stdout.write('\\\\n'+ChemicalElement+'\\\\t'+str(x_avg)+'\\\\t'+str(y_avg)+'\\\\t'+str(z_avg))\\n # Score the predicted location based on surrounding residues\\n distances = PandasPdb.distance_df(ppdb_ATOM, xyz=(x_avg,y_avg,z_avg))\\n ppdb_LOCAL = ppdb_ATOM[distances <= 0.6*SearchRadius]\\n SITE_coord = ''\\n for l in ppdb_LOCAL.index.tolist():\\n if(ppdb_LOCAL['atom_name'].loc[l] in RefAtom(ppdb_LOCAL['residue_name'].loc[l])):\\n SITE_coord += str(res_1Letter(ppdb_LOCAL['residue_name'].loc[l])) \\n # site score added last column in the temporary output file\\n sys.stdout.write('\\\\t'+str(ScoreLoc(''.join(sorted(SITE_coord)), ProbMap)))\\n OutFile.close()\\n sys.stdout = console_output\",\n \"def set_top_unique_num(self, number):\\n self.top_unique_num = number\",\n \"def set_address_values(layer):\\n cursor = arcpy.SearchCursor(layer)\\n for row in cursor:\\n layer_fields = arcpy.ListFields(layer)\\n for x in range(len(layer_fields)):\\n layer_fields[x] = layer_fields[x].name\\n for key in address_dict:\\n if key in layer_fields and address_dict.get(key) is None:\\n address_dict[key] = row.getValue(key)\",\n \"def test1 (self, testStore, dbh, dbn, dbu, dbp):\",\n \"def __init__(self):\\n array = db.getDataFromString(\\\"execute [dbo].[ranking] '1/1/2016', 365\\\")\\n self.ranking = {}\\n for i in array:\\n if i[0] not in self.ranking:\\n self.ranking[i[0]] = {}\\n self.ranking[i[0]][i[1]] = i[2]\",\n \"def initalize():\\n global itemlist\\n global limit\\n global weightlimit\\n global indivcount\\n\\n \\n itemlist = []\\n \\n limit = 50000\\n print(\\\"Initializing with \\\",limit,\\\" Items to choose from\\\")\\n sack = generatesack(limit)\\n \\n weightlimit = 0\\n for i in sack:\\n weightlimit += i.weight\\n weightlimit = weightlimit//2\\n print(\\\"The napsack weightlimit is: \\\", weightlimit)\\n \\n indivcount = 200\\n print(\\\"Initializing with \\\",indivcount,\\\" Individuals per generation\\\")\\n takelist = geninitialpopulation(indivcount, sack)\\n final_output = evolution(takelist)\\n \\n generations = final_output[1]\\n final_output = final_output[0]\\n \\n print(\\\"\\\\n\\\")\\n print(\\\"Best individual:\\\")\\n bestindiv = prettytable.PrettyTable()\\n bestindiv.field_names = [\\\"weight\\\",\\\"total value\\\",\\\"fitness\\\"]\\n bestindiv.add_row([final_output.mass,final_output.value,final_output.fitness])\\n print(bestindiv)\\n print(\\\"Best solution acheived after \\\",generations, \\\" generations!\\\")\\n print(\\\"Distance to weightlimit: \\\",weightlimit - final_output.mass)\",\n \"def update_nypd_complaint_results():\\n start_datetime, end_datetime = get_start_end_datetimes()\\n\\n cols_to_keep = \\\"boro_nm,cmplnt_fr_dt,cmplnt_to_dt,juris_desc,law_cat_cd,ofns_desc,prem_typ_desc,longitude,latitude\\\"\\n results = SOCRATA_CLIENT.get(\\n NYPD_COMPLAINT_ID, \\n limit=10, \\n select=cols_to_keep,\\n where=f\\\"cmplnt_to_dt IS NULL and cmplnt_fr_dt between '{start_datetime.isoformat()}' and '{end_datetime.isoformat()}'\\\")\\n\\n df = pd.DataFrame.from_records(results)\\n cols = list(df)\\n for c in cols:\\n df[c].fillna(\\\"null\\\", inplace=True)\\n __upload_to_gcp_bucket(df, NYPD_COMPLAINT_FNAME)\\n return df\",\n \"def __init__(self):\\n self.capacity = 1000\\n self.data = [None]*self.capcity\",\n \"def __init__(self):\\n self.buckets = 1009\\n self.table = [[] for _ in range(self.buckets)]\",\n \"def sweetcoconut_databank(df_tax_id_fromCompleteDatabank, taxonomy_Double,sweetcoconut_database,port):\\n client2 = MongoClient(port)\\n db_s = client2[sweetcoconut_database]\\n collection2 = db_s.sweetNaturalProduct\\n sweetnp = pd.DataFrame(list(collection2.find({\\\"contains_sugar\\\": True})))\\n sweetnp_with_tax = pd.merge(sweetnp, df_tax_id_fromCompleteDatabank, how=\\\"left\\\", on=\\\"coconut_id\\\")\\n df_cutout_sweetnp_with_tax = pd.DataFrame({\\\"coconut_id\\\": sweetnp_with_tax.coconut_id,\\n \\\"taxonomy\\\": sweetnp_with_tax.taxonomy,\\n \\\"all_deglycosilated_smiles\\\": sweetnp_with_tax.all_deglycosilated_smiles\\n })\\n df_cutout_no_nan = df_cutout_sweetnp_with_tax.fillna('no')\\n df_cutout_explode = df_cutout_no_nan.explode(\\\"all_deglycosilated_smiles\\\",ignore_index=True)\\n #display(df_cutout_explode)\\n unique_deglycosilated_smiles = set(df_cutout_explode[\\\"all_deglycosilated_smiles\\\"])\\n unique_deglycosilated_smiles.pop()\\n df_NP = pd.DataFrame(unique_deglycosilated_smiles, columns=[\\\"deglycosilated_smiles\\\"])\\n df_NP[\\\"coconut_id\\\"] = \\\"\\\"\\n df_NP[\\\"taxonomy\\\"] = \\\"\\\"\\n index = 0\\n for mol in df_NP.deglycosilated_smiles:\\n all_rows = df_cutout_explode[df_cutout_explode[\\\"all_deglycosilated_smiles\\\"]==mol]\\n df_NP.coconut_id[index] = (all_rows.coconut_id.values)\\n df_NP.taxonomy[index] = (all_rows.taxonomy.values)\\n index += 1\\n #display(df_NP)\\n # **-----------------for tax prediction-------------------**\\n df_NP.to_pickle(\\\"output_data/for_predict_multiple_tax.pkl\\\")\\n # **----------------end tax prediction--------------------**\\n index = 0\\n for tax_list in df_NP.taxonomy:\\n df_NP.taxonomy[index] = set(tax_list)\\n if len(df_NP.taxonomy[index]) >= 2:\\n if 'no' in df_NP.taxonomy[index]:\\n df_NP.taxonomy[index].remove('no')\\n index += 1\\n #display(df_NP)\\n bar_plot(df_NP)\\n venn_diagram(df_NP,taxonomy_Double)\\n aglycon_single_tax(df_NP)\",\n \"def createQWord(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def hist_data(self):\\n # database address\\n jydb_address = \\\"117.122.223.35\\\"\\n jydb_user_id = \\\"zpy\\\"\\n jydb_user_pwd = \\\"Z1pe1y1@zpy\\\"\\n jydb_db_name = \\\"jydb02\\\"\\n # preallocate data set\\n back_testing_data = {}\\n \\n # on-line mode\\n conn = pymysql.connect(jydb_address, jydb_user_id, jydb_user_pwd, jydb_db_name)\\n # not using moving average\\n if not self.moving_average: \\n # iterate on all ism packages\\n for _i, ism_pack in enumerate(tqdm(self.ism_data)):\\n ismcode = ism_pack[0][0]\\n ProRunDate = ism_pack[0][5]\\n ProStopDate = ism_pack[0][6]\\n MaxStoreSum = ism_pack[0][7]\\n MinInvestShare = ism_pack[0][8]\\n InnerCode_ls = flatten(list(map(lambda x: [y[0] for y in x[1:]], ism_pack[1:])))\\n SecuCode_ls = flatten(list(map(lambda x: [y[1] for y in x[1:]], ism_pack[1:])))\\n PriorType_ls = flatten(list(map(lambda x: [y[2] for y in x[1:]], ism_pack[1:])))\\n # collect data from source conn\\n flag_run = \\\"SELECT InnerCode, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \\\" + \\\\\\n \\\"InnerCode IN (\\\" + \\\",\\\".join(InnerCode_ls) + \\\") AND \\\" + \\\\\\n \\\"TradingDay=\\\\'\\\" + ProRunDate + \\\"\\\\'\\\"\\n flag_stop = \\\"SELECT InnerCode, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \\\" + \\\\\\n \\\"InnerCode IN (\\\" + \\\",\\\".join(InnerCode_ls) + \\\") AND \\\" + \\\\\\n \\\"TradingDay=\\\\'\\\" + ProStopDate + \\\"\\\\'\\\"\\n run_price = pd.read_sql(flag_run, conn)\\n stop_price = pd.read_sql(flag_stop, conn)\\n back_testing_data[ismcode] = pd.merge(run_price, stop_price, on='InnerCode', \\n suffixes=('_run', '_stop'))\\n else: # using moving average \\n # iterate on all ism packages\\n for _i, ism_pack in enumerate(self.ism_data):\\n ismcode = ism_pack[0][0]\\n ProRunDate = ism_pack[0][5]\\n TradingDay_begin = former_market_date(ProRunDate, self.L_shift, conn)\\n TradingDay_end = future_market_date(ProRunDate, self.R_shift, conn)\\n InnerCode_ls = flatten(list(map(lambda x: [y[0] for y in x[1:]], ism_pack[1:])))\\n SecuCode_ls = flatten(list(map(lambda x: [y[1] for y in x[1:]], ism_pack[1:])))\\n PriorType_ls = flatten(list(map(lambda x: [y[2] for y in x[1:]], ism_pack[1:])))\\n flag = \\\"SELECT InnerCode, TradingDay, OpenPrice, ClosePrice FROM QT_DailyQuote WHERE \\\" + \\\\\\n \\\"InnerCode IN (\\\" + \\\",\\\".join(InnerCode_ls) + \\\") AND \\\" + \\\\\\n \\\"TradingDay BETWEEN \\\\'\\\" + TradingDay_begin + \\\"\\\\' AND \\\\'\\\" + TradingDay_end + \\\"\\\\'\\\"\\n back_testing_data[ismcode] = pd.read_sql(flag, conn)\\n \\n # close sql connection\\n conn.close()\\n \\n return back_testing_data\",\n \"def populate_db_command():\\n print(\\\"Populating DB with sample data.\\\")\\n populate_db()\\n print \\\"Done\\\"\",\n \"def insert_domains_into_onprogress(db, domains):\\r\\n cursor = db.cursor()\\r\\n print 'domain-----------------------------------------------------------------------------'\\r\\n print domains[0]\\r\\n print 'domain-----------------------------------------------------------------------------'\\r\\n sql_string = \\\"INSERT INTO on_progress_domains(url, max_pages) VALUES(%s, %s)\\\"\\r\\n try:\\r\\n cursor.execute(sql_string, domains[0])\\r\\n db.commit()\\r\\n except:\\r\\n cursor.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n cursor.close()\",\n \"def fill_db(self, data):\\n check_input_params(data, self.DB)\\n self.db = data[self.DB]\",\n \"def stake_associated_addresses(self, stake_address: str, data_order: str='asc', nb_of_results: int=None, pandas: bool=False) -> Union[pd.DataFrame, dict]:\\n \\n stake_associated_addresses_url = \\\"{}{}{}\\\".format(bf_stake_url,\\n stake_address,\\n bf_associated_addresses_url)\\n \\n response, count_api_calls = query_on_several_pages(self.network, self.api_key, data_order, nb_of_results, stake_associated_addresses_url, self.proxies)\\n \\n #print('[INFO] Function stake_associated_addresses, {} API calls.'.format(count_api_calls))\\n \\n return pd.DataFrame.from_dict(response) if pandas else response\",\n \"def array_update(self, table_list):\\r\\n for tbl in table_list:\\r\\n x = kit.SQL_pull('name, subject_id', tbl)\\r\\n r = {i[0]: i[1] for i in x}\\r\\n h = {i[1]: tbl for i in x}\\r\\n \\r\\n self.refference.update(r)\\r\\n self.home_table.update(h)\\r\\n \\r\\n self.counts[tbl] = len(x)\",\n \"def step070() -> None:\\n logger.logMessage('Begin: elasticsearch bulk update')\\n client = es.Elasticsearch(hostlist)\\n\\n def generate():\\n with open(renumFile,'r') as f:\\n line = f.readline().rstrip()\\n while line != '':\\n fields = line.split(';')\\n oper = { '_index': fields[3], \\n '_op_type': 'update',\\n '_id': fields[2].rstrip(),\\n '_type': 'doc',\\n '_source:': {'doc': {'tsa': fields[0]}}}\\n \\n yield oper\\n line = f.readline().rstrip()\\n result = eshelp.bulk(client,generate())\\n logger.logMessage('Bulk result: {0}'.format(result))\\n logger.logMessage('End : elasticsearch bulk update')\",\n \"def resAlloc(self,band):\\n schd = self.schType[0:2]\\n if schd=='PF' and len(list(self.ues.keys()))>0:\\n exp_num = float(self.schType[2])\\n exp_den = float(self.schType[3])\\n self.setUEfactor(exp_num, exp_den)\\n maxInd = self.findMaxFactor()\\n for ue in list(self.ues.keys()):\\n if ue == maxInd:\\n self.ues[ue].prbs = band\\n else:\\n self.ues[ue].prbs = 0\\n if len(self.ues[ue].pastTbsz)>self.promLen:\\n self.ues[ue].pastTbsz.popleft()\\n self.ues[ue].pastTbsz.append(self.ues[ue].tbsz)\\n self.ues[ue].tbsz = 1\\n # Print Resource Allocation\\n self.printResAlloc()\",\n \"def save_pages_to_onprogress_pages(db, pages, domain):\\r\\n cursor = db.cursor()\\r\\n #get domain id\\r\\n try:\\r\\n cursor.execute(\\\"SELECT domain_id, max_pages FROM on_progress_domains WHERE url = %(d)s\\\", {'d':domain})\\r\\n domain_id = cursor.fetchone()\\r\\n if domain_id == None:\\r\\n print \\\"foriegn key not found\\\"\\r\\n return\\r\\n except:\\r\\n cursor.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n\\r\\n for page in pages:\\r\\n #if max pages reached\\r\\n if domain_id[1] < 0:\\r\\n print \\\"max pages reached zero, Terminating crawler for the domain:\\\", domain, \\\"after waiting pages are done processing\\\"\\r\\n return\\r\\n max_pages_updated = int(domain_id[1]) - 1\\r\\n sql_string1 = \\\"INSERT INTO on_progress_pages(domain_id, page_url) VALUES(%s, %s)\\\"\\r\\n sql_string2 = \\\"UPDATE on_progress_domains SET max_pages = %s WHERE domain_id = %s\\\"\\r\\n try:\\r\\n\\r\\n cursor.execute(sql_string1, (int(domain_id[0]), page))\\r\\n cursor.execute(sql_string2, (max_pages_updated, domain_id[0]))\\r\\n db.commit()\\r\\n except:\\r\\n cursor.close()\\r\\n raise RuntimeError(\\\"An Exception happened with the Database, make sure you are connected\\\")\\r\\n cursor.close()\",\n \"def main():\\r\\n windows_driver = '/mnt/c/Users/kurtrm/Documents/bin/chromedriver.exe'\\r\\n browser = Chrome(executable_path=windows_driver)\\r\\n\\r\\n url = 'https://www.pcta.org/discover-the-trail/' \\\\\\r\\n 'thru-hiking-long-distance-hiking/2600-miler-list/'\\r\\n\\r\\n browser.get(url)\\r\\n year_range = range(1952, 2018) # Range of years of recorded thru-hikes\\r\\n\\r\\n for year in year_range:\\r\\n select = Select(browser.find_element_by_id('year'))\\r\\n select.select_by_value(str(year))\\r\\n time.sleep(1.5)\\r\\n miler_list = browser.find_elements_by_css_selector('td')\\r\\n if miler_list[0].text != 'No records found for the selected year.':\\r\\n people = extract_names(miler_list, year)\\r\\n load_mongo_db('pct', 'completions', people)\",\n \"def connected_devices_arp(self, run_test):\\n\\n\\n if not run_test:\\n return\\n\\n res = {}\\n\\n ts = int(time.time())\\n\\n route_cmd = \\\"ip r | grep /24 | awk '{print $1;}'\\\"\\n subnet = Popen(route_cmd, shell=True,\\n stdout=PIPE).stdout.read().decode('utf-8')\\n\\n nmap_cmd = f'nmap -sn {subnet}'\\n Popen(nmap_cmd, shell=True, stdout=PIPE)\\n\\n arp_cmd = (\\\"/usr/sbin/arp -i eth0 -n | grep : |\\\"\\n \\\"grep -v '_gateway' | tr -s ' ' | \\\"\\n \\\"cut -f3 -d' ' | sort | uniq\\\")\\n\\n arp_res = Popen(arp_cmd, shell=True,\\n stdout=PIPE).stdout.read().decode('utf-8')\\n res['arp'] = arp_res\\n\\n devices = set(arp_res.strip().split(\\\"\\\\n\\\"))\\n active_devices = [[dev, ts, 1] for dev in devices]\\n\\n for device in active_devices:\\n if self.dev_db.contains(where('mac_addr') == device[0]):\\n self.dev_db.update(increment(\\\"n\\\"),\\n where('mac_addr') == device[0])\\n self.dev_db.update(tdb_set('last_seen', device[1]),\\n where('mac_addr') == device[0])\\n else:\\n self.dev_db.insert({'mac_addr': device[0],\\n 'last_seen': device[1],\\n 'n': device[2]})\\n\\n print(self.dev_db.all())\\n ndev_past_day = len(self.dev_db.search(\\n where('last_seen') > (ts - 86400)))\\n ndev_past_week = len(self.dev_db.search(\\n where('last_seen') > (ts - 86400*7)))\\n\\n print(ndev_past_day)\\n self.results[\\\"devices_active\\\"] = len(active_devices)\\n self.results[\\\"devices_total\\\"] = self.dev_db.count(where('n') >= 1)\\n self.results[\\\"devices_1day\\\"] = ndev_past_day\\n self.results[\\\"devices_1week\\\"] = ndev_past_week\\n\\n if not self.quiet:\\n print('\\\\n --- Number of Devices ---')\\n print(f'Number of active devices: '\\n f'{self.results[\\\"devices_active\\\"]}')\\n print(f'Number of total devices: '\\n f'{self.results[\\\"devices_total\\\"]}')\\n print(f'Number of devices in last 1 day:'\\n f' {self.results[\\\"devices_1day\\\"]}')\\n print(f'Number of devices in last week:'\\n f' {self.results[\\\"devices_1week\\\"]}')\\n return res\",\n \"def test_place(self):\\n places = self.geographies.find({ 'geoid': '1562600' })\\n\\n self.assertEqual(places.count(), 1)\\n\\n place = places[0]\\n\\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\\n self.assertEqual(place['metadata']['STATE'], '15')\\n self.assertEqual(place['metadata']['PLACE'], '62600')\\n\\n pop_2000 = 30976\\n pop_2010 = 47698 \\n self._test_totalpop(place, pop_2000, pop_2010)\",\n \"def restart_index(ips, server):\\r\\n\\ticepaps = []\\r\\n\\r\\n#CREATING ICEPAP PARSERS FOR EVERY ADRESS IN ips\\r\\n\\tfor ip in ips:\\r\\n\\t\\ticepaps.append(ElasticClient(ip))\\r\\n\\t\\r\\n\\tfor icepap in icepaps:\\r\\n\\t\\ticepap.setup_cards(server)\\r\\n\\r\\n\\tprint \\\"- - - - - \\\" + datetime.now().strftime(\\\"%d-%b-%Y (%H:%M:%S)\\\") + \\\" - - - - -\\\"\\r\\n\\treturn icepaps\",\n \"def query_ptr_records_for_all_ips(self):\\n\\n log.debug(\\\"Starting to look up PTR records for IP addresses\\\")\\n\\n # store IP addresses to look them up in bulk\\n ip_lookup_dict = dict()\\n\\n # iterate over all IP addresses and try to match them to a prefix\\n for ip in self.get_all_items(NBIPAddress):\\n\\n # ignore IPs which are not handled by any source\\n if ip.source is None:\\n continue\\n\\n # get IP and prefix length\\n ip_a = grab(ip, \\\"data.address\\\", fallback=\\\"\\\").split(\\\"/\\\")[0]\\n\\n # check if we meant to look up DNS host name for this IP\\n if grab(ip, \\\"source.dns_name_lookup\\\", fallback=False) is True:\\n\\n if ip_lookup_dict.get(ip.source) is None:\\n\\n ip_lookup_dict[ip.source] = {\\n \\\"ips\\\": list(),\\n \\\"servers\\\": grab(ip, \\\"source.custom_dns_servers\\\")\\n }\\n\\n ip_lookup_dict[ip.source].get(\\\"ips\\\").append(ip_a)\\n\\n # now perform DNS requests to look up DNS names for IP addresses\\n for source, data in ip_lookup_dict.items():\\n\\n if len(data.get(\\\"ips\\\")) == 0:\\n continue\\n\\n # get DNS names for IP addresses:\\n records = perform_ptr_lookups(data.get(\\\"ips\\\"), data.get(\\\"servers\\\"))\\n\\n for ip in self.get_all_items(NBIPAddress):\\n\\n if ip.source != source:\\n continue\\n\\n ip_a = grab(ip, \\\"data.address\\\", fallback=\\\"\\\").split(\\\"/\\\")[0]\\n\\n dns_name = records.get(ip_a)\\n\\n if dns_name is not None:\\n\\n ip.update(data={\\\"dns_name\\\": dns_name})\\n\\n log.debug(\\\"Finished to look up PTR records for IP addresses\\\")\",\n \"def getDataBefore(self, address: ghidra.program.model.address.Address) -> ghidra.program.model.listing.Data:\\n ...\",\n \"def load_absolute_case_numbers():\\n client = MongoClient(f'mongodb://{os.getenv(\\\"USR_\\\")}:{os.getenv(\\\"PWD_\\\")}@{os.getenv(\\\"REMOTE_HOST\\\")}:{os.getenv(\\\"REMOTE_PORT\\\")}/{os.getenv(\\\"AUTH_DB\\\")}')\\n db = client[os.getenv(\\\"MAIN_DB\\\")]\\n rki_collection = db[\\\"rkidata\\\"]\\n data = pd.DataFrame(list(rki_collection.find()))\\n data[\\\"IdLandkreis\\\"] = pd.to_numeric(data[\\\"IdLandkreis\\\"])\\n return data\",\n \"def set_bibs(self, number):\",\n \"def main():\\r\\n print(\\\"Initializing Database\\\")\\r\\n global conn\\r\\n conn = create_db()\\r\\n\\r\\n print(\\\"Inserting Raw Ticket Data\\\")\\r\\n create_raw_data()\\r\\n print(\\\"Creating Block Limits DataFrame\\\")\\r\\n\\r\\n global streetnamedict\\r\\n global streetintersections\\r\\n streetintersections, streetnamedict = create_block_limits()\\r\\n\\r\\n print(\\\"Starting Address Creation\\\")\\r\\n global single_address\\r\\n global double_address\\r\\n global addresses\\r\\n single_address, double_address, addresses = create_address_data()\\r\\n print(\\\"Finished Creating addresses\\\")\\r\\n\\r\\n global nhoodtype\\r\\n nhoodtype = pd.read_sql_query('Select nhood, violationdesc, count(*) tickets from raw_ticket_data t1 join single_address t2 '\\r\\n ' on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname group by nhood, violationdesc', conn)\\r\\n\\r\\n print(\\\"Processing Ticket Data\\\")\\r\\n process_ticket_data()\\r\\n print('Finished processing Ticket Data!')\\r\\n print('Starting Street Data Creation')\\r\\n streetsweeping, streetvolume = process_volume()\\r\\n print(' Finished Street Data Creation')\\r\\n\\r\\n print('Pairing Addresses with Street Data')\\r\\n pair_address(streetsweeping, streetvolume)\\r\\n print('Finished Pairing Addresses')\\r\\n\\r\\n print('Pairing Parking')\\r\\n pair_parking(streetvolume)\\r\\n print('Finished Pairing Parking')\\r\\n\\r\\n conn.close()\\r\\n\\r\\n print('Finished Creating Entire Database and updated Shapefiles at {}'.format( dt.datetime.now().strftime(\\\"%H:%M\\\")))\",\n \"def test_query_train_jobs_with_lower_offset(self, client):\\n params = dict(offset=-1, limit=10)\\n url = get_url(BASE_URL, params)\\n response = client.get(url)\\n result = response.get_json()\\n assert result.get('error_code') == '50540002'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.511866","0.50577724","0.504898","0.5036274","0.49281853","0.48955876","0.48717105","0.48107842","0.47876543","0.47528073","0.47337833","0.4712964","0.47108823","0.46957618","0.46719283","0.4665297","0.4657939","0.46463177","0.46462315","0.4643902","0.46433464","0.4620374","0.4603046","0.45975342","0.45972395","0.45940942","0.4590909","0.45563665","0.4543294","0.45430577","0.45384166","0.4530126","0.45254034","0.45096675","0.45036396","0.44968918","0.44915673","0.44690755","0.44649354","0.44496727","0.44462013","0.4405684","0.44012308","0.4400969","0.4400767","0.4397982","0.43908983","0.4390372","0.43891314","0.43850794","0.43840092","0.43818823","0.4368111","0.43636653","0.43616453","0.4360614","0.435877","0.43554965","0.4342302","0.43408012","0.43341768","0.4330829","0.43300733","0.43185782","0.43149424","0.43126884","0.4304396","0.43043828","0.42980692","0.42979726","0.42964178","0.42958754","0.42944676","0.42917687","0.42828083","0.4280178","0.42781425","0.4278066","0.42753667","0.42711812","0.4268213","0.42650473","0.42640594","0.42632812","0.42604876","0.42602655","0.42595318","0.42593664","0.42590398","0.42580172","0.42566085","0.4254648","0.42519248","0.42470822","0.42469493","0.42447123","0.42416686","0.42388743","0.4235159","0.42302752"],"string":"[\n \"0.511866\",\n \"0.50577724\",\n \"0.504898\",\n \"0.5036274\",\n \"0.49281853\",\n \"0.48955876\",\n \"0.48717105\",\n \"0.48107842\",\n \"0.47876543\",\n \"0.47528073\",\n \"0.47337833\",\n \"0.4712964\",\n \"0.47108823\",\n \"0.46957618\",\n \"0.46719283\",\n \"0.4665297\",\n \"0.4657939\",\n \"0.46463177\",\n \"0.46462315\",\n \"0.4643902\",\n \"0.46433464\",\n \"0.4620374\",\n \"0.4603046\",\n \"0.45975342\",\n \"0.45972395\",\n \"0.45940942\",\n \"0.4590909\",\n \"0.45563665\",\n \"0.4543294\",\n \"0.45430577\",\n \"0.45384166\",\n \"0.4530126\",\n \"0.45254034\",\n \"0.45096675\",\n \"0.45036396\",\n \"0.44968918\",\n \"0.44915673\",\n \"0.44690755\",\n \"0.44649354\",\n \"0.44496727\",\n \"0.44462013\",\n \"0.4405684\",\n \"0.44012308\",\n \"0.4400969\",\n \"0.4400767\",\n \"0.4397982\",\n \"0.43908983\",\n \"0.4390372\",\n \"0.43891314\",\n \"0.43850794\",\n \"0.43840092\",\n \"0.43818823\",\n \"0.4368111\",\n \"0.43636653\",\n \"0.43616453\",\n \"0.4360614\",\n \"0.435877\",\n \"0.43554965\",\n \"0.4342302\",\n \"0.43408012\",\n \"0.43341768\",\n \"0.4330829\",\n \"0.43300733\",\n \"0.43185782\",\n \"0.43149424\",\n \"0.43126884\",\n \"0.4304396\",\n \"0.43043828\",\n \"0.42980692\",\n \"0.42979726\",\n \"0.42964178\",\n \"0.42958754\",\n \"0.42944676\",\n \"0.42917687\",\n \"0.42828083\",\n \"0.4280178\",\n \"0.42781425\",\n \"0.4278066\",\n \"0.42753667\",\n \"0.42711812\",\n \"0.4268213\",\n \"0.42650473\",\n \"0.42640594\",\n \"0.42632812\",\n \"0.42604876\",\n \"0.42602655\",\n \"0.42595318\",\n \"0.42593664\",\n \"0.42590398\",\n \"0.42580172\",\n \"0.42566085\",\n \"0.4254648\",\n \"0.42519248\",\n \"0.42470822\",\n \"0.42469493\",\n \"0.42447123\",\n \"0.42416686\",\n \"0.42388743\",\n \"0.4235159\",\n \"0.42302752\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6340167"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84698,"cells":{"query":{"kind":"string","value":"Returns the amount to be minted to a address"},"document":{"kind":"string","value":"def _get_amount_to_mint(self) -> int:\n supply = self._sICX_supply.get()\n balance = self.getTotalStake()\n if balance == self.msg.value:\n amount = self.msg.value\n else:\n amount = supply * self.msg.value // (balance - self.msg.value)\n return amount"},"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 mint(amount: int) -> int:\n global total_supply\n\n _assert_is_bank(context.sender)\n total_supply = base.mint(balance_of, total_supply, context.sender, amount)\n return total_supply","def get_address_balance(litecoinaddress):\n total_balance = 0\n unspent = list_unspent(litecoinaddress)\n for block in unspent:\n total_balance += float(block[\"amount\"])\n\n return total_balance","def grant(to_address: str, amount: int) -> int:\n _assert_is_bank(context.sender)\n\n mint(amount)\n transfer(to_address, amount)\n return total_supply","def getBtcInWallet(address):\n btc = 'https://blockchain.info/q/addressbalance/' + address\n check = requests.get(btc)\n value = int((check.content)) / 100000000.0\n return value","def get_balance(address: str) -> int:\n return base.Balances(balance_of).get(address)","def get_balance(self, address):\n balance = 0\n for block in self.chain:\n for t in block['transactions']:\n if t['recipient'] == address:\n balance += t['amount']\n elif t['sender'] == address:\n balance -= t['amount']\n return balance","def balance_of_address(self, address):\n balance = 0\n for block in self.chain:\n for transaction in block.transactions:\n if transaction.walletoffrom == address:\n balance -= transaction.amount\n\n if transaction.walletofto == address:\n balance += transaction.amount\n return balance","def getAddress(self) -> int:\n ...","def q_addressbalance(abe, page, chain):\n addr = wsgiref.util.shift_path_info(page['env'])\n if chain is None or addr is None:\n return 'returns amount of money at the given address\\n' \\\n '/chain/CHAIN/q/addressbalance/ADDRESS\\n'\n\n if not util.possible_address(addr):\n return 'ERROR: address invalid'\n\n version, hash = util.decode_address(addr)\n total = abe.store.get_balance(chain.id, hash)\n\n return (\"ERROR: please try again\" if total is None else\n format_satoshis(total, chain))","def get_new_address(account):\n try:\n new_address = subprocess.check_output([\"litecoin-cli\", \"getnewaddress\", account])\n except:\n sys.exit(1)\n\n return new_address.decode().strip()","def get_balance(self, address):\n\n raise NotImplementedError('coming soon...')\n\n return sum(o.value for o in self.get_unspent_outputs(address)) / 100000000.0","def do_getaddress(self,args):\n ppdict(bitstamp.get_depositaddress())","def getInt(self, address: ghidra.program.model.address.Address) -> int:\n ...","def fund_transaction(address, role):\n amount = 0\n message_text = ''\n error_text = ''\n if encoding.is_valid_address(address):\n if check_optin(address):\n if role == 'player':\n amount = 1500\n message_text = 'Your account has been funded with 1,500 Monopoly Money'\n\n elif role == 'banker':\n amount = 20000\n message_text = 'Your account has been funded with 20,000 Monopoly Money'\n\n asset_transfer(SENDER_ADDRESS, SENDER_PRIVATE_KEY, address, amount, ASSET_ID)\n else:\n error_text = \"Your account not opt-in to Monopoly Money asset\"\n else:\n error_text = \"Enter correct Algorand address\"\n return message_text, error_text","def deposit_address(self):\n response = self.query('deposit_address')\n return response","def get_address():\r\n address = input(\"What is the customer's address?: \")\r\n\r\n return address","def mint(_to: address, _amount: uint256) -> bool:\n\n assert msg.sender == self.owner, \"Access is denied.\"\n assert self.totalSupply + _amount <= self.maximumSupply, \"You cannot print those many tokens.\"\n assert not self.mintingFinished, \"Minting cannot be performed anymore.\"\n\n self.totalSupply += _amount\n self.balances[_to] += _amount\n\n log.Mint(_to, _amount)\n log.Transfer(ZERO_ADDRESS, _to, _amount)\n\n return True","def generate_deposit_address(self, currency):\n return self.__call__('balance', \"generatedepositaddress\", \n {\"currencyname\": currency})","def get_deposit_address(self, currency):\n return self.__call__('balance', \"getdepositaddress\", \n {\"currencyname\": currency})","def withdraw_from_address(amount, network_fee, from_address, to_address):\n tx_total = amount + network_fee\n address_balance = get_address_balance(from_address)\n\n if tx_total > address_balance:\n # return not enough funds error\n print(\"Error: Not enough funds\")\n else:\n tx_hex_string = create_raw_transaction(amount, network_fee, from_address, to_address)\n signed_tx = sign_raw_transaction(tx_hex_string)\n hex_signed_tx = signed_tx[\"hex\"]\n txid = send_raw_transaction(hex_signed_tx)\n\n return txid.decode()","def get_tx_amount():\n return float(input(\"Enter Transaction Amount: \"))","def getLong(self, address: ghidra.program.model.address.Address) -> long:\n ...","def get_balance_response(address):\n call = Address(address=address)\n response = call.get_address_info()\n if response:\n return response\n else:\n return None","def transaction():\n data = jsonpickle.decode(request.get_data())\n address = data[\"address\"]\n amount = int(data[\"amount\"])\n keyname = data[\"keyname\"]\n\n pkplus, pkminus = wallet.keys(keyname)\n\n my_balance = p2p.query(\"/balance\", address=pkplus)[\"balance\"]\n if my_balance < amount:\n abort(404, description=\"Not enough funds.\")\n\n my_utxo = p2p.query(\"/find-utxos\", address=pkplus, amount=amount)[\"utxos\"]\n rem = sum(utxo.amount for utxo in my_utxo) - amount\n address_amount = [(address, amount)]\n\n assert rem >= 0\n\n if rem > 0:\n address_amount.append((pkplus, rem))\n\n tx = build_transaction(my_utxo, address_amount, pkminus)\n try:\n p2p.broadcast(\"/transaction-pool\", transaction=tx)\n return SUCCESSFUL_PATCH\n except UnsuccessfulPatch:\n payload = jsonpickle.encode(\n {\"message\": \"Transaction wasn't accepted by the network.\"})\n return payload, 420, {\"ContentType\": \"application/json\"}","def q_getreceivedbyaddress(abe, page, chain):\n addr = wsgiref.util.shift_path_info(page['env'])\n if chain is None or addr is None:\n return 'returns amount of money received by given address (not balance, sends are not subtracted)\\n' \\\n '/chain/CHAIN/q/getreceivedbyaddress/ADDRESS\\n'\n\n if not util.possible_address(addr):\n return 'ERROR: address invalid'\n\n version, hash = util.decode_address(addr)\n return format_satoshis(abe.store.get_received(chain.id, hash), chain)","def getNewAddress(self):\n a = self.selectedAccount.getNextPaymentAddress()\n if self.blockchain:\n self.blockchain.subscribeAddresses(a)\n self.save()\n return a","def getAddressOfgoods(account_address):\n\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\n function_selector = 'getAddressOfGoodFromWallet(address)',\n fee_limit=1000000000,\n call_value=0,\n parameters=[{'type': 'address', 'value':account_address}],\n issuer_address=account_address\n )\n addresses = addresses['constant_result']\n decodeH = decode_hex(addresses[0])\n decodeA= decode_abi(('uint256[]',),decodeH)\n print(\"----------------------------------------------------\")\n print(decodeA)\n return decodeA[0]","def getInt(self, addr: ghidra.program.model.address.Address) -> int:\n ...","def q_getsentbyaddress(abe, page, chain):\n addr = wsgiref.util.shift_path_info(page['env'])\n if chain is None or addr is None:\n return 'returns amount of money sent from given address\\n' \\\n '/chain/CHAIN/q/getsentbyaddress/ADDRESS\\n'\n\n if not util.possible_address(addr):\n return 'ERROR: address invalid'\n\n version, hash = util.decode_address(addr)\n return format_satoshis(abe.store.get_sent(chain.id, hash), chain)","def getTransactionAmount(self,message):\n amount = re.findall(Analyzer.rgxAmount,message.lower())\n return amount[0].capitalize()","def amount(self):\n return(self.order_master.amount)","def getamount(self):\n return self.__amount","def get_amount(self):\n\t\tif self.amount is not None:\n\t\t\treturn self.amount\n\t\treturn abort(400, {\"message\" : \"please provide the amount to process\"})","async def fetch_deposit_address(self, code: str, params={}):\n await self.load_markets()\n currency = self.currency(code)\n # if not provided explicitly we will try to match using the currency name\n network = self.safe_string(params, 'network', code)\n currencyNetworks = self.safe_value(currency, 'networks', {})\n currencyNetwork = self.safe_value(currencyNetworks, network)\n networkId = self.safe_string(currencyNetwork, 'id')\n if networkId is None:\n raise ArgumentsRequired(self.id + \" fetchDepositAddress() could not find a network for '\" + code + \"'. You can specify it by providing the 'network' value inside params\")\n wallet = self.safe_string(params, 'wallet', 'exchange') # 'exchange', 'margin', 'funding' and also old labels 'exchange', 'trading', 'deposit', respectively\n params = self.omit(params, 'network', 'wallet')\n request = {\n 'method': networkId,\n 'wallet': wallet,\n 'op_renew': 0, # a value of 1 will generate a new address\n }\n response = await self.privatePostAuthWDepositAddress(self.extend(request, params))\n #\n # [\n # 1582269616687, # MTS Millisecond Time Stamp of the update\n # 'acc_dep', # TYPE Purpose of notification 'acc_dep' for account deposit\n # null, # MESSAGE_ID unique ID of the message\n # null, # not documented\n # [\n # null, # PLACEHOLDER\n # 'BITCOIN', # METHOD Method of deposit\n # 'BTC', # CURRENCY_CODE Currency code of new address\n # null, # PLACEHOLDER\n # '1BC9PZqpUmjyEB54uggn8TFKj49zSDYzqG', # ADDRESS\n # null, # POOL_ADDRESS\n # ],\n # null, # CODE null or integer work in progress\n # 'SUCCESS', # STATUS Status of the notification, SUCCESS, ERROR, FAILURE\n # 'success', # TEXT Text of the notification\n # ]\n #\n result = self.safe_value(response, 4, [])\n poolAddress = self.safe_string(result, 5)\n address = self.safe_string(result, 4) if (poolAddress is None) else poolAddress\n tag = None if (poolAddress is None) else self.safe_string(result, 4)\n self.check_address(address)\n return {\n 'currency': code,\n 'address': address,\n 'tag': tag,\n 'network': None,\n 'info': response,\n }","def get_balance(address, endpoint=_default_endpoint, timeout=_default_timeout) -> int:\n method = 'hmy_getBalance'\n params = [\n address,\n 'latest'\n ]\n balance = rpc_request(method, params=params, endpoint=endpoint, timeout=timeout)['result']\n try:\n return int(balance, 16)\n except TypeError as e:\n raise InvalidRPCReplyError(method, endpoint) from e","def get_balance(self, address: str, erc20_address: str) -> int:\n return get_erc20_contract(self.w3, erc20_address).functions.balanceOf(address).call()","def get_nonce(self, address):\n nonce = self.web3_object.eth.getTransactionCount(address)\n return nonce","def getAddress(user):","def amount_for(idx):\n vout = tx.tx.vin[idx].vout\n outp = tx.inputs[idx].non_witness_utxo.vout[vout]\n return outp.value","async def get_balance(sochain_url:str, network:str, address:str):\n try:\n balance = await sochain_api.get_balance(sochain_url, network, address)\n if balance == None:\n raise Exception(\"Invalid Address\")\n return balance\n except Exception as err:\n raise Exception(str(err))","def amount(self):\n return self.subtotal + self.tax_subtotal + self.shipping","def get_addr_value(tx):\n\t# initialize lists\n\tin_addr, in_value, out_addr, out_value = [], [], [], []\n\t# for each input transaction\n\tfor input in tx[\"inputs\"]:\n\t\t# if sending address exists\n\t\t# (otherwise coin base or empty value)\n\t\tif \"prev_out\" in input.keys() and \"addr\" in input[\"prev_out\"].keys():\n\t\t\t# record address and value\n\t\t\tin_addr.append(input[\"prev_out\"][\"addr\"])\n\t\t\tin_value.append(input[\"prev_out\"][\"value\"])\n\t# for each output transaction\n\tfor output in tx[\"out\"]:\n\t\t# if receiving address exists\n\t\t# (otherwise empty value)\n\t\tif \"addr\" in output.keys():\n\t\t\t# record address and value\n\t\t\tout_addr.append(output[\"addr\"])\n\t\t\tout_value.append(output[\"value\"])\n\t# handle duplicate addresses\n\tin_addr, in_value = handle_duplicates(in_addr, in_value)\n\tout_addr, out_value = handle_duplicates(out_addr, out_value)\n\treturn in_addr, in_value, out_addr, out_value","def address_transactions(self, address):\n res = r.get(self.url + self.address_tx + str(address))\n return self.execute(res)","def sendToAddress(self, value, address, feeRate=None):\n acct = self.openAccount\n keysource = KeySource(\n priv = self.getKey,\n change = acct.getChangeAddress,\n )\n tx, spentUTXOs, newUTXOs = self.blockchain.sendToAddress(value, address, keysource, self.getUTXOs, feeRate)\n acct.addMempoolTx(tx)\n acct.spendUTXOs(spentUTXOs)\n for utxo in newUTXOs:\n acct.addUTXO(utxo)\n self.signals.balance(acct.calcBalance(self.blockchain.tip[\"height\"]))\n self.save()\n return tx","def getAmount(self):\n return self.amount","def address(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"address\")","def get_address(self, ):\n return self.get_parameter('address')","def earnCoin(self, amount):\n self.coins += amount","async def fetch_deposit_address(self, code: str, params={}):\n await self.load_markets()\n currency = self.currency(code)\n request = {\n 'asset': currency['id'],\n }\n response = await self.privateGetUserWithdrawalAccount(self.extend(request, params))\n data = self.safe_value(response, 'data', {})\n # Not sure about self if there could be more than one account...\n accounts = self.safe_value(data, 'accounts', [])\n firstAccount = self.safe_value(accounts, 0, {})\n address = self.safe_string(firstAccount, 'address')\n return {\n 'currency': currency,\n 'address': address,\n 'tag': None,\n 'network': None,\n 'info': response,\n }","def getnewaddress(self):\n passphrase = self._getnewaddress_passphrase_template.format(self._getnewaddress_offset)\n address = make_address_from_passphrase(bytes(passphrase, \"utf-8\"))\n self._getnewaddress_offset += 1\n return CBitcoinAddress(address)","def _get_num_transactions(self, address):\n params = [f\"0x{address}\", __class__.DEFAULT_BLOCK_LATEST]\n nonce = self._json_call(\"eth_getTransactionCount\", params)\n return nonce","def get_bill_amt():\n\n return float(input(\"How much was your total bill: \"))","def update_approve(to_address: str, delta_amount: int) -> int:\n raise NotImplementedError()","def mk_contract_address(sender: str, nonce: int) -> str:\n sender_bytes = to_bytes(hexstr=sender)\n raw = rlp.encode([sender_bytes, nonce])\n h = keccak(raw)\n address_bytes = h[12:]\n return to_checksum_address(address_bytes)","def generateNewAddress(self, currency):\n pass","def account_deposit_address(self, currency_symbol):\n return self.get(f'addresses/{currency_symbol}', auth=True)","def _get_address(self):\n return self.__address","async def fetch_deposit_address(self, code: str, params={}):\n await self.load_markets()\n networkCode = None\n networkCode, params = self.handle_network_code_and_params(params)\n if networkCode is None:\n raise ArgumentsRequired(self.id + ' fetchDepositAddress requires params[\"network\"]')\n currency = self.currency(code)\n currencyId = currency['id']\n idLength = len(currencyId)\n currencyId = currencyId[0:idLength - 1] + currencyId[idLength - 1:idLength].lower() # make the last letter lowercase\n params = self.omit(params, 'network')\n request = {\n 'currency': currencyId,\n 'network': self.network_code_to_id(networkCode, currency['code']),\n }\n response = await self.privateGetUserDepositAddress(self.extend(request, params))\n #\n # '\"bc1qmex3puyrzn2gduqcnlu70c2uscpyaa9nm2l2j9le2lt2wkgmw33sy7ndjg\"'\n #\n return {\n 'currency': code,\n 'address': response.replace('\"', '').replace('\"', ''), # Done twice because some languages only replace the first instance\n 'tag': None,\n 'network': networkCode,\n 'info': response,\n }","def getLong(self, addr: ghidra.program.model.address.Address) -> long:\n ...","def getAmount2(*args):","def get_address(self):\n if self.address:\n return self.address","def address_transactions_unspent(self, address):\n res = r.get(self.url + self.address_unspent + str(address))\n return self.execute(res)","def address(self) -> int:\n return self._address","def deposit(self, amount):\n self.balance += amount\n return self.balance","def deposit(self, amount):\n self.balance += amount\n return self.balance","def deposit(self, amount):\n self.balance += amount\n return self.balance","def balance():\n address = request.args.get(\"address\")\n balance = p2p.query(\"/balance\", address=address)[\"balance\"]\n payload = jsonpickle.encode({\"balance\": balance})\n return payload, 200, {\"Content-Type\": \"application/json\"}","def prepare_raw_tx(self, mn_address, change_address, inputs, total, fee=0.00001):\n raw_tx = {mn_address: self.send_amount, change_address: total - self.send_amount - fee}\n return self.rpc.createrawtransaction(inputs, raw_tx)","def address_balance(self, address, confirmations=0):\n address = utils.request_type(address)\n\n confs = {'confirmations': confirmations}\n if confs['confirmations'] > 0:\n res = r.get(self.url + self.balance + str(address), params=confs)\n else:\n res = r.get(self.url + self.balance + str(address))\n return self.execute(res)","def total_money(self) -> LocationInitialMoneyModel:\n return self._total_money","def amount(self):\r\n return self._data['amount']","def buildTxOut (self, addr, amount):\n\n addrData = self.nodes[0].validateaddress (addr)\n addrScript = bytes.fromhex (addrData[\"scriptPubKey\"])\n\n return CTxOut (int (amount * COIN), addrScript)","def get_address(self, address=None):\n return self.__get_addr_grp('address', address)","def amount(self):\n return self.__amount","def amount(self):\n return self.__amount","async def create_deposit_address(self, code: str, params={}):\n await self.load_markets()\n request = {\n 'op_renew': 1,\n }\n return await self.fetch_deposit_address(code, self.extend(request, params))","def mint(self, **kwargs) -> PrivateKey:\n pass","def deposit(self, amount):\r\n self.balance = self.balance + amount\r\n amount = abs(amount)\r\n self.transactions.append(+amount)\r\n return amount","def getFloat(self, address: ghidra.program.model.address.Address) -> float:\n ...","def do_balance(self, args):\n if not self._check_args(args):\n return\n else:\n self.wallet.update_balances()\n balance = self.wallet.addresses.get(args, -1)['balance']\n if balance == -1:\n print(\"Address not found.\")\n else:\n print(balance)","def fetch_deposit_address(self, code: str, params={}):\n self.load_markets()\n currency = self.currency(code)\n if self.is_fiat(code):\n raise NotSupported(self.id + ' fetchDepositAddress() does not support fiat currencies')\n request = {\n 'Coin': currency['id'],\n }\n response = self.privatePostFundsAddCoinFundsRequest(self.extend(request, params))\n #\n # {\n # 'address': '0xf14b94518d74aff2b1a6d3429471bcfcd3881d42',\n # 'hasTx': False\n # }\n #\n return self.parse_deposit_address(response, currency)","def deposit(self, amount):\r\n new_balance = self['get']('balance') + amount\r\n self['set']('balance', new_balance)\r\n return self['get']('balance')","def get_amount_for_razorpay(amount: Decimal) -> int:\n return int(amount * 100)","def _collab_mint(self, sender, amount=0):\n\n self.result = self.collab.mint_OBJKT(\n self.default_params['mint_OBJKT']).interpret(\n storage=self.collab_storage, sender=sender, amount=amount)\n\n self.assertTrue(len(self.result.operations) == 1)\n operation = self.result.operations[0]\n\n self.assertEqual(operation['parameters']['entrypoint'], 'mint_OBJKT')\n op_bytes = operation['parameters']['value']['args'][1]['bytes']\n\n metadata = self.default_params['mint_OBJKT']['metadata']\n self.assertEqual(op_bytes, metadata)\n\n self.assertEqual(operation['destination'],\n self.addresses['hicMinterAddress'])\n self.assertEqual(operation['amount'], '0')","def __get_account(self, address):\n\t\tfor acct in self.wallet:\n\t\t\tif acct[\"address\"] == address:\n\t\t\t\treturn acct\n\t\traise ValueError(\"The given address does not exist in the bunkr-wallet\")","def amount(self):\n return self._amount","def taxicab(a, b):\n \"*** YOUR CODE HERE ***\"\n return abs(street(a)-street(b))+abs(avenue(a)-avenue(b))","def deposit(self, amount):\n self.balance = self.balance + amount\n return self.balance","def get_total_balance(address, endpoint=_default_endpoint, timeout=_default_timeout) -> int:\n try:\n balances = get_balance_on_all_shards(address, skip_error=False, endpoint=endpoint, timeout=timeout)\n return sum(b['balance'] for b in balances)\n except TypeError as e:\n raise RuntimeError from e","def deposit(self, amount):\n self.__balance += amount\n return self.__balance","def execute_get_balance(arg):\n blockchain = Blockchain()\n blockchain.read_blockchain()\n\n address = arg['address']\n\n if address is None:\n print('You have to give you account address!!!')\n\n elif not blockchain._wallet_pool.has_address(address):\n print(f'The address {address} does not exist!!!')\n\n else:\n balance = blockchain.get_balance(address)\n print(f'Address: {address}')\n print(f'Balance = {balance}')\n\n return","def address(self, name):\n return self.query(name).response.answer[0].items[0].address","def nomad_address():\n\n print(nomad.get_address())","def geo(address):\n API_PRIVATE = os.environ.get(\"TOM_TOM_PRIVATE\")\n encoded = urllib.parse.quote(address)\n query ='https://api.tomtom.com/search/2/geocode/' + str(encoded) + \\\n '.json?limit=1&countrySet=US&lat=42&lon=-72&topLeft=42.886%2C%20-73.508&btmRight=41.237%2C-69.928&key=' \\\n + API_PRIVATE\n\n response = requests.get(query)\n while True:\n try:\n jsonResponse = response.json()\n break\n except:\n response = requests.get(query)\n\n latit = 0\n longit = 0\n\n for address in jsonResponse['results']:\n latit = address['position']['lat']\n longit = address['position']['lon']\n return latit, longit","def getAmount1(*args):","def get_coin_address(self, coin, idx=0):\n return self.coins[coin][idx]","def taxicab(a, b):\n \"*** YOUR CODE HERE ***\"\n return abs (street(a)-street(b))+(abs(avenue(a)-avenue(b)))","def get_address(address, registers):\n \n try:\n address, offset = address.split('+')\n offset = int(offset)\n except ValueError:\n try:\n address, offset = address.split('-')\n offset = -int(offset)\n except ValueError:\n offset = 0\n\n if address.isdigit():\n return int(address)\n\n return int(registers[address]) + offset","def get_value(self, address):\n\n return self.data[address]","def address(self):\n\n\t\telement = Element(driver=self.driver,\n\t\t explicit_wait_time=self.explicit_wait_time,\n\t\t locator=BillPayPageLocator.ADDRESS_INPUT)\n\t\treturn element.element_value"],"string":"[\n \"def mint(amount: int) -> int:\\n global total_supply\\n\\n _assert_is_bank(context.sender)\\n total_supply = base.mint(balance_of, total_supply, context.sender, amount)\\n return total_supply\",\n \"def get_address_balance(litecoinaddress):\\n total_balance = 0\\n unspent = list_unspent(litecoinaddress)\\n for block in unspent:\\n total_balance += float(block[\\\"amount\\\"])\\n\\n return total_balance\",\n \"def grant(to_address: str, amount: int) -> int:\\n _assert_is_bank(context.sender)\\n\\n mint(amount)\\n transfer(to_address, amount)\\n return total_supply\",\n \"def getBtcInWallet(address):\\n btc = 'https://blockchain.info/q/addressbalance/' + address\\n check = requests.get(btc)\\n value = int((check.content)) / 100000000.0\\n return value\",\n \"def get_balance(address: str) -> int:\\n return base.Balances(balance_of).get(address)\",\n \"def get_balance(self, address):\\n balance = 0\\n for block in self.chain:\\n for t in block['transactions']:\\n if t['recipient'] == address:\\n balance += t['amount']\\n elif t['sender'] == address:\\n balance -= t['amount']\\n return balance\",\n \"def balance_of_address(self, address):\\n balance = 0\\n for block in self.chain:\\n for transaction in block.transactions:\\n if transaction.walletoffrom == address:\\n balance -= transaction.amount\\n\\n if transaction.walletofto == address:\\n balance += transaction.amount\\n return balance\",\n \"def getAddress(self) -> int:\\n ...\",\n \"def q_addressbalance(abe, page, chain):\\n addr = wsgiref.util.shift_path_info(page['env'])\\n if chain is None or addr is None:\\n return 'returns amount of money at the given address\\\\n' \\\\\\n '/chain/CHAIN/q/addressbalance/ADDRESS\\\\n'\\n\\n if not util.possible_address(addr):\\n return 'ERROR: address invalid'\\n\\n version, hash = util.decode_address(addr)\\n total = abe.store.get_balance(chain.id, hash)\\n\\n return (\\\"ERROR: please try again\\\" if total is None else\\n format_satoshis(total, chain))\",\n \"def get_new_address(account):\\n try:\\n new_address = subprocess.check_output([\\\"litecoin-cli\\\", \\\"getnewaddress\\\", account])\\n except:\\n sys.exit(1)\\n\\n return new_address.decode().strip()\",\n \"def get_balance(self, address):\\n\\n raise NotImplementedError('coming soon...')\\n\\n return sum(o.value for o in self.get_unspent_outputs(address)) / 100000000.0\",\n \"def do_getaddress(self,args):\\n ppdict(bitstamp.get_depositaddress())\",\n \"def getInt(self, address: ghidra.program.model.address.Address) -> int:\\n ...\",\n \"def fund_transaction(address, role):\\n amount = 0\\n message_text = ''\\n error_text = ''\\n if encoding.is_valid_address(address):\\n if check_optin(address):\\n if role == 'player':\\n amount = 1500\\n message_text = 'Your account has been funded with 1,500 Monopoly Money'\\n\\n elif role == 'banker':\\n amount = 20000\\n message_text = 'Your account has been funded with 20,000 Monopoly Money'\\n\\n asset_transfer(SENDER_ADDRESS, SENDER_PRIVATE_KEY, address, amount, ASSET_ID)\\n else:\\n error_text = \\\"Your account not opt-in to Monopoly Money asset\\\"\\n else:\\n error_text = \\\"Enter correct Algorand address\\\"\\n return message_text, error_text\",\n \"def deposit_address(self):\\n response = self.query('deposit_address')\\n return response\",\n \"def get_address():\\r\\n address = input(\\\"What is the customer's address?: \\\")\\r\\n\\r\\n return address\",\n \"def mint(_to: address, _amount: uint256) -> bool:\\n\\n assert msg.sender == self.owner, \\\"Access is denied.\\\"\\n assert self.totalSupply + _amount <= self.maximumSupply, \\\"You cannot print those many tokens.\\\"\\n assert not self.mintingFinished, \\\"Minting cannot be performed anymore.\\\"\\n\\n self.totalSupply += _amount\\n self.balances[_to] += _amount\\n\\n log.Mint(_to, _amount)\\n log.Transfer(ZERO_ADDRESS, _to, _amount)\\n\\n return True\",\n \"def generate_deposit_address(self, currency):\\n return self.__call__('balance', \\\"generatedepositaddress\\\", \\n {\\\"currencyname\\\": currency})\",\n \"def get_deposit_address(self, currency):\\n return self.__call__('balance', \\\"getdepositaddress\\\", \\n {\\\"currencyname\\\": currency})\",\n \"def withdraw_from_address(amount, network_fee, from_address, to_address):\\n tx_total = amount + network_fee\\n address_balance = get_address_balance(from_address)\\n\\n if tx_total > address_balance:\\n # return not enough funds error\\n print(\\\"Error: Not enough funds\\\")\\n else:\\n tx_hex_string = create_raw_transaction(amount, network_fee, from_address, to_address)\\n signed_tx = sign_raw_transaction(tx_hex_string)\\n hex_signed_tx = signed_tx[\\\"hex\\\"]\\n txid = send_raw_transaction(hex_signed_tx)\\n\\n return txid.decode()\",\n \"def get_tx_amount():\\n return float(input(\\\"Enter Transaction Amount: \\\"))\",\n \"def getLong(self, address: ghidra.program.model.address.Address) -> long:\\n ...\",\n \"def get_balance_response(address):\\n call = Address(address=address)\\n response = call.get_address_info()\\n if response:\\n return response\\n else:\\n return None\",\n \"def transaction():\\n data = jsonpickle.decode(request.get_data())\\n address = data[\\\"address\\\"]\\n amount = int(data[\\\"amount\\\"])\\n keyname = data[\\\"keyname\\\"]\\n\\n pkplus, pkminus = wallet.keys(keyname)\\n\\n my_balance = p2p.query(\\\"/balance\\\", address=pkplus)[\\\"balance\\\"]\\n if my_balance < amount:\\n abort(404, description=\\\"Not enough funds.\\\")\\n\\n my_utxo = p2p.query(\\\"/find-utxos\\\", address=pkplus, amount=amount)[\\\"utxos\\\"]\\n rem = sum(utxo.amount for utxo in my_utxo) - amount\\n address_amount = [(address, amount)]\\n\\n assert rem >= 0\\n\\n if rem > 0:\\n address_amount.append((pkplus, rem))\\n\\n tx = build_transaction(my_utxo, address_amount, pkminus)\\n try:\\n p2p.broadcast(\\\"/transaction-pool\\\", transaction=tx)\\n return SUCCESSFUL_PATCH\\n except UnsuccessfulPatch:\\n payload = jsonpickle.encode(\\n {\\\"message\\\": \\\"Transaction wasn't accepted by the network.\\\"})\\n return payload, 420, {\\\"ContentType\\\": \\\"application/json\\\"}\",\n \"def q_getreceivedbyaddress(abe, page, chain):\\n addr = wsgiref.util.shift_path_info(page['env'])\\n if chain is None or addr is None:\\n return 'returns amount of money received by given address (not balance, sends are not subtracted)\\\\n' \\\\\\n '/chain/CHAIN/q/getreceivedbyaddress/ADDRESS\\\\n'\\n\\n if not util.possible_address(addr):\\n return 'ERROR: address invalid'\\n\\n version, hash = util.decode_address(addr)\\n return format_satoshis(abe.store.get_received(chain.id, hash), chain)\",\n \"def getNewAddress(self):\\n a = self.selectedAccount.getNextPaymentAddress()\\n if self.blockchain:\\n self.blockchain.subscribeAddresses(a)\\n self.save()\\n return a\",\n \"def getAddressOfgoods(account_address):\\n\\n addresses = tron.transaction_builder.trigger_smart_contract(contract_address = SMART_CONTRACT_ADDRESS,\\n function_selector = 'getAddressOfGoodFromWallet(address)',\\n fee_limit=1000000000,\\n call_value=0,\\n parameters=[{'type': 'address', 'value':account_address}],\\n issuer_address=account_address\\n )\\n addresses = addresses['constant_result']\\n decodeH = decode_hex(addresses[0])\\n decodeA= decode_abi(('uint256[]',),decodeH)\\n print(\\\"----------------------------------------------------\\\")\\n print(decodeA)\\n return decodeA[0]\",\n \"def getInt(self, addr: ghidra.program.model.address.Address) -> int:\\n ...\",\n \"def q_getsentbyaddress(abe, page, chain):\\n addr = wsgiref.util.shift_path_info(page['env'])\\n if chain is None or addr is None:\\n return 'returns amount of money sent from given address\\\\n' \\\\\\n '/chain/CHAIN/q/getsentbyaddress/ADDRESS\\\\n'\\n\\n if not util.possible_address(addr):\\n return 'ERROR: address invalid'\\n\\n version, hash = util.decode_address(addr)\\n return format_satoshis(abe.store.get_sent(chain.id, hash), chain)\",\n \"def getTransactionAmount(self,message):\\n amount = re.findall(Analyzer.rgxAmount,message.lower())\\n return amount[0].capitalize()\",\n \"def amount(self):\\n return(self.order_master.amount)\",\n \"def getamount(self):\\n return self.__amount\",\n \"def get_amount(self):\\n\\t\\tif self.amount is not None:\\n\\t\\t\\treturn self.amount\\n\\t\\treturn abort(400, {\\\"message\\\" : \\\"please provide the amount to process\\\"})\",\n \"async def fetch_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n currency = self.currency(code)\\n # if not provided explicitly we will try to match using the currency name\\n network = self.safe_string(params, 'network', code)\\n currencyNetworks = self.safe_value(currency, 'networks', {})\\n currencyNetwork = self.safe_value(currencyNetworks, network)\\n networkId = self.safe_string(currencyNetwork, 'id')\\n if networkId is None:\\n raise ArgumentsRequired(self.id + \\\" fetchDepositAddress() could not find a network for '\\\" + code + \\\"'. You can specify it by providing the 'network' value inside params\\\")\\n wallet = self.safe_string(params, 'wallet', 'exchange') # 'exchange', 'margin', 'funding' and also old labels 'exchange', 'trading', 'deposit', respectively\\n params = self.omit(params, 'network', 'wallet')\\n request = {\\n 'method': networkId,\\n 'wallet': wallet,\\n 'op_renew': 0, # a value of 1 will generate a new address\\n }\\n response = await self.privatePostAuthWDepositAddress(self.extend(request, params))\\n #\\n # [\\n # 1582269616687, # MTS Millisecond Time Stamp of the update\\n # 'acc_dep', # TYPE Purpose of notification 'acc_dep' for account deposit\\n # null, # MESSAGE_ID unique ID of the message\\n # null, # not documented\\n # [\\n # null, # PLACEHOLDER\\n # 'BITCOIN', # METHOD Method of deposit\\n # 'BTC', # CURRENCY_CODE Currency code of new address\\n # null, # PLACEHOLDER\\n # '1BC9PZqpUmjyEB54uggn8TFKj49zSDYzqG', # ADDRESS\\n # null, # POOL_ADDRESS\\n # ],\\n # null, # CODE null or integer work in progress\\n # 'SUCCESS', # STATUS Status of the notification, SUCCESS, ERROR, FAILURE\\n # 'success', # TEXT Text of the notification\\n # ]\\n #\\n result = self.safe_value(response, 4, [])\\n poolAddress = self.safe_string(result, 5)\\n address = self.safe_string(result, 4) if (poolAddress is None) else poolAddress\\n tag = None if (poolAddress is None) else self.safe_string(result, 4)\\n self.check_address(address)\\n return {\\n 'currency': code,\\n 'address': address,\\n 'tag': tag,\\n 'network': None,\\n 'info': response,\\n }\",\n \"def get_balance(address, endpoint=_default_endpoint, timeout=_default_timeout) -> int:\\n method = 'hmy_getBalance'\\n params = [\\n address,\\n 'latest'\\n ]\\n balance = rpc_request(method, params=params, endpoint=endpoint, timeout=timeout)['result']\\n try:\\n return int(balance, 16)\\n except TypeError as e:\\n raise InvalidRPCReplyError(method, endpoint) from e\",\n \"def get_balance(self, address: str, erc20_address: str) -> int:\\n return get_erc20_contract(self.w3, erc20_address).functions.balanceOf(address).call()\",\n \"def get_nonce(self, address):\\n nonce = self.web3_object.eth.getTransactionCount(address)\\n return nonce\",\n \"def getAddress(user):\",\n \"def amount_for(idx):\\n vout = tx.tx.vin[idx].vout\\n outp = tx.inputs[idx].non_witness_utxo.vout[vout]\\n return outp.value\",\n \"async def get_balance(sochain_url:str, network:str, address:str):\\n try:\\n balance = await sochain_api.get_balance(sochain_url, network, address)\\n if balance == None:\\n raise Exception(\\\"Invalid Address\\\")\\n return balance\\n except Exception as err:\\n raise Exception(str(err))\",\n \"def amount(self):\\n return self.subtotal + self.tax_subtotal + self.shipping\",\n \"def get_addr_value(tx):\\n\\t# initialize lists\\n\\tin_addr, in_value, out_addr, out_value = [], [], [], []\\n\\t# for each input transaction\\n\\tfor input in tx[\\\"inputs\\\"]:\\n\\t\\t# if sending address exists\\n\\t\\t# (otherwise coin base or empty value)\\n\\t\\tif \\\"prev_out\\\" in input.keys() and \\\"addr\\\" in input[\\\"prev_out\\\"].keys():\\n\\t\\t\\t# record address and value\\n\\t\\t\\tin_addr.append(input[\\\"prev_out\\\"][\\\"addr\\\"])\\n\\t\\t\\tin_value.append(input[\\\"prev_out\\\"][\\\"value\\\"])\\n\\t# for each output transaction\\n\\tfor output in tx[\\\"out\\\"]:\\n\\t\\t# if receiving address exists\\n\\t\\t# (otherwise empty value)\\n\\t\\tif \\\"addr\\\" in output.keys():\\n\\t\\t\\t# record address and value\\n\\t\\t\\tout_addr.append(output[\\\"addr\\\"])\\n\\t\\t\\tout_value.append(output[\\\"value\\\"])\\n\\t# handle duplicate addresses\\n\\tin_addr, in_value = handle_duplicates(in_addr, in_value)\\n\\tout_addr, out_value = handle_duplicates(out_addr, out_value)\\n\\treturn in_addr, in_value, out_addr, out_value\",\n \"def address_transactions(self, address):\\n res = r.get(self.url + self.address_tx + str(address))\\n return self.execute(res)\",\n \"def sendToAddress(self, value, address, feeRate=None):\\n acct = self.openAccount\\n keysource = KeySource(\\n priv = self.getKey,\\n change = acct.getChangeAddress,\\n )\\n tx, spentUTXOs, newUTXOs = self.blockchain.sendToAddress(value, address, keysource, self.getUTXOs, feeRate)\\n acct.addMempoolTx(tx)\\n acct.spendUTXOs(spentUTXOs)\\n for utxo in newUTXOs:\\n acct.addUTXO(utxo)\\n self.signals.balance(acct.calcBalance(self.blockchain.tip[\\\"height\\\"]))\\n self.save()\\n return tx\",\n \"def getAmount(self):\\n return self.amount\",\n \"def address(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"address\\\")\",\n \"def get_address(self, ):\\n return self.get_parameter('address')\",\n \"def earnCoin(self, amount):\\n self.coins += amount\",\n \"async def fetch_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n currency = self.currency(code)\\n request = {\\n 'asset': currency['id'],\\n }\\n response = await self.privateGetUserWithdrawalAccount(self.extend(request, params))\\n data = self.safe_value(response, 'data', {})\\n # Not sure about self if there could be more than one account...\\n accounts = self.safe_value(data, 'accounts', [])\\n firstAccount = self.safe_value(accounts, 0, {})\\n address = self.safe_string(firstAccount, 'address')\\n return {\\n 'currency': currency,\\n 'address': address,\\n 'tag': None,\\n 'network': None,\\n 'info': response,\\n }\",\n \"def getnewaddress(self):\\n passphrase = self._getnewaddress_passphrase_template.format(self._getnewaddress_offset)\\n address = make_address_from_passphrase(bytes(passphrase, \\\"utf-8\\\"))\\n self._getnewaddress_offset += 1\\n return CBitcoinAddress(address)\",\n \"def _get_num_transactions(self, address):\\n params = [f\\\"0x{address}\\\", __class__.DEFAULT_BLOCK_LATEST]\\n nonce = self._json_call(\\\"eth_getTransactionCount\\\", params)\\n return nonce\",\n \"def get_bill_amt():\\n\\n return float(input(\\\"How much was your total bill: \\\"))\",\n \"def update_approve(to_address: str, delta_amount: int) -> int:\\n raise NotImplementedError()\",\n \"def mk_contract_address(sender: str, nonce: int) -> str:\\n sender_bytes = to_bytes(hexstr=sender)\\n raw = rlp.encode([sender_bytes, nonce])\\n h = keccak(raw)\\n address_bytes = h[12:]\\n return to_checksum_address(address_bytes)\",\n \"def generateNewAddress(self, currency):\\n pass\",\n \"def account_deposit_address(self, currency_symbol):\\n return self.get(f'addresses/{currency_symbol}', auth=True)\",\n \"def _get_address(self):\\n return self.__address\",\n \"async def fetch_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n networkCode = None\\n networkCode, params = self.handle_network_code_and_params(params)\\n if networkCode is None:\\n raise ArgumentsRequired(self.id + ' fetchDepositAddress requires params[\\\"network\\\"]')\\n currency = self.currency(code)\\n currencyId = currency['id']\\n idLength = len(currencyId)\\n currencyId = currencyId[0:idLength - 1] + currencyId[idLength - 1:idLength].lower() # make the last letter lowercase\\n params = self.omit(params, 'network')\\n request = {\\n 'currency': currencyId,\\n 'network': self.network_code_to_id(networkCode, currency['code']),\\n }\\n response = await self.privateGetUserDepositAddress(self.extend(request, params))\\n #\\n # '\\\"bc1qmex3puyrzn2gduqcnlu70c2uscpyaa9nm2l2j9le2lt2wkgmw33sy7ndjg\\\"'\\n #\\n return {\\n 'currency': code,\\n 'address': response.replace('\\\"', '').replace('\\\"', ''), # Done twice because some languages only replace the first instance\\n 'tag': None,\\n 'network': networkCode,\\n 'info': response,\\n }\",\n \"def getLong(self, addr: ghidra.program.model.address.Address) -> long:\\n ...\",\n \"def getAmount2(*args):\",\n \"def get_address(self):\\n if self.address:\\n return self.address\",\n \"def address_transactions_unspent(self, address):\\n res = r.get(self.url + self.address_unspent + str(address))\\n return self.execute(res)\",\n \"def address(self) -> int:\\n return self._address\",\n \"def deposit(self, amount):\\n self.balance += amount\\n return self.balance\",\n \"def deposit(self, amount):\\n self.balance += amount\\n return self.balance\",\n \"def deposit(self, amount):\\n self.balance += amount\\n return self.balance\",\n \"def balance():\\n address = request.args.get(\\\"address\\\")\\n balance = p2p.query(\\\"/balance\\\", address=address)[\\\"balance\\\"]\\n payload = jsonpickle.encode({\\\"balance\\\": balance})\\n return payload, 200, {\\\"Content-Type\\\": \\\"application/json\\\"}\",\n \"def prepare_raw_tx(self, mn_address, change_address, inputs, total, fee=0.00001):\\n raw_tx = {mn_address: self.send_amount, change_address: total - self.send_amount - fee}\\n return self.rpc.createrawtransaction(inputs, raw_tx)\",\n \"def address_balance(self, address, confirmations=0):\\n address = utils.request_type(address)\\n\\n confs = {'confirmations': confirmations}\\n if confs['confirmations'] > 0:\\n res = r.get(self.url + self.balance + str(address), params=confs)\\n else:\\n res = r.get(self.url + self.balance + str(address))\\n return self.execute(res)\",\n \"def total_money(self) -> LocationInitialMoneyModel:\\n return self._total_money\",\n \"def amount(self):\\r\\n return self._data['amount']\",\n \"def buildTxOut (self, addr, amount):\\n\\n addrData = self.nodes[0].validateaddress (addr)\\n addrScript = bytes.fromhex (addrData[\\\"scriptPubKey\\\"])\\n\\n return CTxOut (int (amount * COIN), addrScript)\",\n \"def get_address(self, address=None):\\n return self.__get_addr_grp('address', address)\",\n \"def amount(self):\\n return self.__amount\",\n \"def amount(self):\\n return self.__amount\",\n \"async def create_deposit_address(self, code: str, params={}):\\n await self.load_markets()\\n request = {\\n 'op_renew': 1,\\n }\\n return await self.fetch_deposit_address(code, self.extend(request, params))\",\n \"def mint(self, **kwargs) -> PrivateKey:\\n pass\",\n \"def deposit(self, amount):\\r\\n self.balance = self.balance + amount\\r\\n amount = abs(amount)\\r\\n self.transactions.append(+amount)\\r\\n return amount\",\n \"def getFloat(self, address: ghidra.program.model.address.Address) -> float:\\n ...\",\n \"def do_balance(self, args):\\n if not self._check_args(args):\\n return\\n else:\\n self.wallet.update_balances()\\n balance = self.wallet.addresses.get(args, -1)['balance']\\n if balance == -1:\\n print(\\\"Address not found.\\\")\\n else:\\n print(balance)\",\n \"def fetch_deposit_address(self, code: str, params={}):\\n self.load_markets()\\n currency = self.currency(code)\\n if self.is_fiat(code):\\n raise NotSupported(self.id + ' fetchDepositAddress() does not support fiat currencies')\\n request = {\\n 'Coin': currency['id'],\\n }\\n response = self.privatePostFundsAddCoinFundsRequest(self.extend(request, params))\\n #\\n # {\\n # 'address': '0xf14b94518d74aff2b1a6d3429471bcfcd3881d42',\\n # 'hasTx': False\\n # }\\n #\\n return self.parse_deposit_address(response, currency)\",\n \"def deposit(self, amount):\\r\\n new_balance = self['get']('balance') + amount\\r\\n self['set']('balance', new_balance)\\r\\n return self['get']('balance')\",\n \"def get_amount_for_razorpay(amount: Decimal) -> int:\\n return int(amount * 100)\",\n \"def _collab_mint(self, sender, amount=0):\\n\\n self.result = self.collab.mint_OBJKT(\\n self.default_params['mint_OBJKT']).interpret(\\n storage=self.collab_storage, sender=sender, amount=amount)\\n\\n self.assertTrue(len(self.result.operations) == 1)\\n operation = self.result.operations[0]\\n\\n self.assertEqual(operation['parameters']['entrypoint'], 'mint_OBJKT')\\n op_bytes = operation['parameters']['value']['args'][1]['bytes']\\n\\n metadata = self.default_params['mint_OBJKT']['metadata']\\n self.assertEqual(op_bytes, metadata)\\n\\n self.assertEqual(operation['destination'],\\n self.addresses['hicMinterAddress'])\\n self.assertEqual(operation['amount'], '0')\",\n \"def __get_account(self, address):\\n\\t\\tfor acct in self.wallet:\\n\\t\\t\\tif acct[\\\"address\\\"] == address:\\n\\t\\t\\t\\treturn acct\\n\\t\\traise ValueError(\\\"The given address does not exist in the bunkr-wallet\\\")\",\n \"def amount(self):\\n return self._amount\",\n \"def taxicab(a, b):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return abs(street(a)-street(b))+abs(avenue(a)-avenue(b))\",\n \"def deposit(self, amount):\\n self.balance = self.balance + amount\\n return self.balance\",\n \"def get_total_balance(address, endpoint=_default_endpoint, timeout=_default_timeout) -> int:\\n try:\\n balances = get_balance_on_all_shards(address, skip_error=False, endpoint=endpoint, timeout=timeout)\\n return sum(b['balance'] for b in balances)\\n except TypeError as e:\\n raise RuntimeError from e\",\n \"def deposit(self, amount):\\n self.__balance += amount\\n return self.__balance\",\n \"def execute_get_balance(arg):\\n blockchain = Blockchain()\\n blockchain.read_blockchain()\\n\\n address = arg['address']\\n\\n if address is None:\\n print('You have to give you account address!!!')\\n\\n elif not blockchain._wallet_pool.has_address(address):\\n print(f'The address {address} does not exist!!!')\\n\\n else:\\n balance = blockchain.get_balance(address)\\n print(f'Address: {address}')\\n print(f'Balance = {balance}')\\n\\n return\",\n \"def address(self, name):\\n return self.query(name).response.answer[0].items[0].address\",\n \"def nomad_address():\\n\\n print(nomad.get_address())\",\n \"def geo(address):\\n API_PRIVATE = os.environ.get(\\\"TOM_TOM_PRIVATE\\\")\\n encoded = urllib.parse.quote(address)\\n query ='https://api.tomtom.com/search/2/geocode/' + str(encoded) + \\\\\\n '.json?limit=1&countrySet=US&lat=42&lon=-72&topLeft=42.886%2C%20-73.508&btmRight=41.237%2C-69.928&key=' \\\\\\n + API_PRIVATE\\n\\n response = requests.get(query)\\n while True:\\n try:\\n jsonResponse = response.json()\\n break\\n except:\\n response = requests.get(query)\\n\\n latit = 0\\n longit = 0\\n\\n for address in jsonResponse['results']:\\n latit = address['position']['lat']\\n longit = address['position']['lon']\\n return latit, longit\",\n \"def getAmount1(*args):\",\n \"def get_coin_address(self, coin, idx=0):\\n return self.coins[coin][idx]\",\n \"def taxicab(a, b):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return abs (street(a)-street(b))+(abs(avenue(a)-avenue(b)))\",\n \"def get_address(address, registers):\\n \\n try:\\n address, offset = address.split('+')\\n offset = int(offset)\\n except ValueError:\\n try:\\n address, offset = address.split('-')\\n offset = -int(offset)\\n except ValueError:\\n offset = 0\\n\\n if address.isdigit():\\n return int(address)\\n\\n return int(registers[address]) + offset\",\n \"def get_value(self, address):\\n\\n return self.data[address]\",\n \"def address(self):\\n\\n\\t\\telement = Element(driver=self.driver,\\n\\t\\t explicit_wait_time=self.explicit_wait_time,\\n\\t\\t locator=BillPayPageLocator.ADDRESS_INPUT)\\n\\t\\treturn element.element_value\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69586235","0.6636571","0.64191425","0.6284753","0.62760067","0.62711406","0.6152331","0.6129017","0.6064553","0.58940786","0.58726585","0.5836371","0.5781485","0.5695222","0.5656765","0.5585638","0.55727005","0.5548005","0.5546406","0.55363196","0.5511669","0.55063653","0.5504442","0.5503079","0.550109","0.5488971","0.5480726","0.5471381","0.54523623","0.5433407","0.54227054","0.5413748","0.5406603","0.54005057","0.53678983","0.5354898","0.5347638","0.5345127","0.53446984","0.5336213","0.5284505","0.52818584","0.52812374","0.52790624","0.5275264","0.5266924","0.5254962","0.5253257","0.52439314","0.5243056","0.52377415","0.5231505","0.522824","0.5206453","0.5195696","0.5191734","0.5190105","0.5180755","0.5178465","0.51690185","0.5168392","0.51535845","0.5149652","0.5141992","0.5141992","0.5141992","0.5138821","0.51373696","0.5135771","0.51348317","0.51323473","0.5128702","0.5121474","0.51203007","0.51203007","0.51186866","0.5110439","0.5107148","0.5104004","0.5093913","0.50907004","0.5082822","0.507899","0.5078694","0.5070213","0.5069695","0.5069243","0.5066576","0.5066471","0.50652605","0.5063894","0.5061105","0.505845","0.5051838","0.5041215","0.5037766","0.50205445","0.5019594","0.50195116","0.50188696"],"string":"[\n \"0.69586235\",\n \"0.6636571\",\n \"0.64191425\",\n \"0.6284753\",\n \"0.62760067\",\n \"0.62711406\",\n \"0.6152331\",\n \"0.6129017\",\n \"0.6064553\",\n \"0.58940786\",\n \"0.58726585\",\n \"0.5836371\",\n \"0.5781485\",\n \"0.5695222\",\n \"0.5656765\",\n \"0.5585638\",\n \"0.55727005\",\n \"0.5548005\",\n \"0.5546406\",\n \"0.55363196\",\n \"0.5511669\",\n \"0.55063653\",\n \"0.5504442\",\n \"0.5503079\",\n \"0.550109\",\n \"0.5488971\",\n \"0.5480726\",\n \"0.5471381\",\n \"0.54523623\",\n \"0.5433407\",\n \"0.54227054\",\n \"0.5413748\",\n \"0.5406603\",\n \"0.54005057\",\n \"0.53678983\",\n \"0.5354898\",\n \"0.5347638\",\n \"0.5345127\",\n \"0.53446984\",\n \"0.5336213\",\n \"0.5284505\",\n \"0.52818584\",\n \"0.52812374\",\n \"0.52790624\",\n \"0.5275264\",\n \"0.5266924\",\n \"0.5254962\",\n \"0.5253257\",\n \"0.52439314\",\n \"0.5243056\",\n \"0.52377415\",\n \"0.5231505\",\n \"0.522824\",\n \"0.5206453\",\n \"0.5195696\",\n \"0.5191734\",\n \"0.5190105\",\n \"0.5180755\",\n \"0.5178465\",\n \"0.51690185\",\n \"0.5168392\",\n \"0.51535845\",\n \"0.5149652\",\n \"0.5141992\",\n \"0.5141992\",\n \"0.5141992\",\n \"0.5138821\",\n \"0.51373696\",\n \"0.5135771\",\n \"0.51348317\",\n \"0.51323473\",\n \"0.5128702\",\n \"0.5121474\",\n \"0.51203007\",\n \"0.51203007\",\n \"0.51186866\",\n \"0.5110439\",\n \"0.5107148\",\n \"0.5104004\",\n \"0.5093913\",\n \"0.50907004\",\n \"0.5082822\",\n \"0.507899\",\n \"0.5078694\",\n \"0.5070213\",\n \"0.5069695\",\n \"0.5069243\",\n \"0.5066576\",\n \"0.5066471\",\n \"0.50652605\",\n \"0.5063894\",\n \"0.5061105\",\n \"0.505845\",\n \"0.5051838\",\n \"0.5041215\",\n \"0.5037766\",\n \"0.50205445\",\n \"0.5019594\",\n \"0.50195116\",\n \"0.50188696\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6663697"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84699,"cells":{"query":{"kind":"string","value":"Sets the new top 100 prep address in an array db weekly after checking the specific conditions."},"document":{"kind":"string","value":"def _reset_top_preps(self) -> None:\n if self._system.getIISSInfo()[\"nextPRepTerm\"] > self._block_height_week.get() + (7 * 43200):\n self._block_height_week.set(self._system.getIISSInfo()[\"nextPRepTerm\"])\n for i in range(len(self._top_preps)):\n self._top_preps.pop()\n self._set_top_preps()"},"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 _set_top_preps(self) -> None :\n prep_dict = self._system.getPReps(1, 20)\n prep_address_list = prep_dict['preps']\n for each_prep in prep_address_list:\n self._top_preps.put(each_prep['address'])","def update_weekly_total(areacode=AREACODE,areaname=AREA):\n start,stop=model_calcs.RANGE_WEEK\n log.debug(f'Processing {areaname}')\n for week in range(start,stop+1):\n end_day=ons_week.week(week)\n \n week_total=weekly_total(end_day,areacode=areacode,areaname=areaname)\n #print(f'{areaname}: Weektotal for week number {week} ending {end_day}: {week_total}')\n \n if week_total is not None:\n try:\n stored,created=CovidWeek.objects.get_or_create(areacode=areacode,week=week)\n #print(stored.weeklycases)\n if stored.weeklycases != week_total:\n log.debug(f'{areaname}: updating week {week} from {stored.weeklycases} to {week_total}')\n stored.weeklycases=week_total\n stored.areaname=areaname\n stored.save()\n if created:\n stored.nation=ons_week.nation[areacode]\n stored.areaname=areaname\n log.debug(f'Created new entry for week {week} for {areaname}')\n stored.week=week\n stored.save()\n except Exception as e:\n log.error(e)\n log.error(f'No data stored for {areaname} week {week}')\n else:\n log.error(f'Bypassing {areaname} - no data')","def update_take_x_ip_requests(limit):\n global ip_report\n\n for remote_host, record in ip_report.items():\n ip_report[remote_host]['requests'] = {k: ip_report[remote_host]['requests'][k] for k in list(ip_report[remote_host]['requests'])[:limit]}","def _set_addresses(self):\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT) and \\\n self._report_data['totalResultsSize'] > 0:\n self._set_search_addresses()\n elif self._report_key in (ReportTypes.MHR_REGISTRATION, ReportTypes.MHR_TRANSFER,\n ReportTypes.MHR_EXEMPTION, ReportTypes.MHR_TRANSPORT_PERMIT, ReportTypes.MHR_NOTE):\n self._set_registration_addresses()","def populate(self):\n\n NUM_COUNTRIES = 2 # random.randint(1, 4)\n\n # find a suitable hex\n with Timer(\"Creating initial data\", debug=self.debug):\n\n for i in range(NUM_COUNTRIES):\n country, provinces, pops = create_country(self, self.map)\n country.determine_tax_policy()\n self.countries.append(country)","def assignNurses(solution, hini, data):\n\n demand = data[\"demand\"]\n pending = solution[\"pending\"]\n hours = data[\"hours\"]\n sumW = [0] * data[\"nNurses\"]\n\n\n checkers = initCheckers(data)\n\n z = solution[\"z\"]\n w = solution[\"w\"]\n\n\n for h in range(hours):\n\n #print(\" for loop h=\"+str(h))\n\n solution[\"mustWork_count\"] = 0\n \n mustWork, canWork = computeAssignments(solution, h, data, checkers=checkers, sumW=sumW )\n\n # print(\"h=\" + str(h))\n # print(\"mustWork\")\n # print(mustWork)\n # print(\"canWork\")\n # print(canWork)\n # print(\"hini:\")\n # print(hini)\n # print(\"demand\")\n # print(data[\"demand\"])\n # print(\"pending\")\n # print(solution[\"pending\"])\n\n\n \n # try to assign if pending[h] > 0 and h >= hini[n]\n for n in mustWork:\n # print(\"nurse :\" + str(n) + \" h: \" + str(h) + \" pending: \")\n # print(pending)\n update_checkers(solution, data, n, h, 1,checkers)\n w[n][h] = 1\n sumW[n] += 1\n pending[h] -= 1\n if z[n] == 0:\n z[n] = 1\n solution[\"cost\"] += 1\n \n #print(\"w[\" + str(n) + \",\" + str(h) + \"] = 1\")\n # pp.pprint(solution[\"w\"])\n\n for n in canWork:\n\n # print(\"nurse :\" + str(n) + \" h: \" + str(h) + \" pending: \")\n # print(pending)\n if pending[h] + hini[h] > 0:\n update_checkers(solution, data, n, h, 1,checkers) \n w[n][h] = 1\n sumW[n] += 1\n pending[h] -= 1\n if z[n] == 0:\n z[n] = 1\n solution[\"cost\"] += 1\n \n #print(\"w[\" + str(n) + \",\" + str(h) + \"] = 1\")\n # print(\"w[\" + str(n) + \"]\")\n # pp.pprint(solution[\"w\"]) \n\n # pp.pprint(data)\n # pp.pprint(solution[\"cost\"])\n # print(\"\")\n\n # compute feasibility: if unfeasible -> fitness should be inf\n if not isFeasible(solution, data):\n # assign the max cost\n #solution[\"cost\"] = 200000 * data[\"nNurses\"]\n solution[\"cost\"] = 100 * solution[\"cost\"]\n # print(data[\"demand\"])\n # print(solution[\"pending\"])\n # print(\"\")","def Process_address(self):\n\n self.data = np.load(self.cache_path, allow_pickle=True)[()]\n\n ID = self.data.keys()\n\n cnt = 0\n for id in tqdm(ID):\n if not 'address' in self.data[id] and 'post' in self.data[id]:\n self.data[id]['address'] = ''\n self.data[id]['location'] = ''\n Q = self.Query_baidu(self.data[id]['post'])\n self.data[id]['address'] = Q['address']\n self.data[id]['location'] = Q['location']\n cnt += 1\n\n print(\"Query %d info\" % cnt)\n\n np.save(self.cache_path, self.data)","def placement_fix():\r\n def func(place):\r\n if place in ['3', '4']:\r\n return '3-4'\r\n elif place in ['5', '6', '7', '8']:\r\n return '5-8'\r\n else:\r\n return place\r\n \r\n for place in decks_coll.find({}):\r\n record_id = place['_id']\r\n decks_coll.update_one({'_id': record_id}, {'$set': {'placement': func(place['placement'])}})","def populate_homes(self, breakdown):\n #check!#\n\n ###your code here###\n tot=self.nx*self.ny\n for n in range(len(breakdown)):\n breakdown[n]=int(round(tot*breakdown[n]))\n for i in range(breakdown[n]):\n new_home=self.empty_homes.pop(random.randrange(len(self.empty_homes)))\n home_address=(new_home.x,new_home.y)\n x=Person(group=n,home=self.homes[home_address])\n self.homes[home_address].occupant=x\n self.people.append(x)","def build_addresses(self):\n \n from ambry.geo.geocoders import DstkGeocoder\n\n facilities = self.partitions.find(table='facilities')\n\n def address_gen():\n for row in facilities.query(\"SELECT * FROM facilities\"):\n address = \"{}, {}, {} {}\".format(row['dba_address1'], row['dba_city'], 'CA', row['dba_zip_code'])\n yield (address, row)\n\n dstk_service = self.config.service('dstk')\n \n dstk_gc = DstkGeocoder(dstk_service, address_gen())\n \n p = self.partitions.find_or_new(table='facilities_addresses')\n p.clean()\n \n lr = self.init_log_rate(500)\n \n with p.inserter() as ins:\n for i, (k, r, inp_row) in enumerate(dstk_gc.geocode()):\n lr(\"Addresses \"+str(i))\n r['facilities_id'] = inp_row['id']\n ins.insert(r)","def ingest(self,check=True):\n\t\tdata=self.data_all\n\t\tpubdate=time_utils.parseISO(self.api.last_update).date()\n\t\t\n\t\tcounter=0\n\t\tfor item in data:\n\t\t\tareacode=item['areaCode']\n\t\t\tdatestring=item['specimenDate']\n\t\t\t_date=fetchdate(datestring)\n\t\t\trow,created=DailyCases.objects.get_or_create(specimenDate=_date,areacode=areacode)\n\t\t\trow.areaname=item['areaName']\n\t\t\tdaily=item['newCasesBySpecimenDate']\n\t\t\ttotal=item['cumCasesBySpecimenDate']\n\t\t\t\n\t\t\t#log.debug(f'{row.areaname}: {datestring}')\t\t\t\n\t\t\tif created:\n\t\t\t\trow.dailyLabConfirmedCases=daily\n\t\t\t\trow.totalLabConfirmedCases=total\n\t\t\t\trow.save()\n\t\t\t\t\n\t\t\t\tif daily:\n\t\t\t\t\tlag=(pubdate-_date.date()).days\n\t\t\t\t\tlog.debug(f'date:{_date} lag: {lag} daily:{daily}')\n\t\t\t\t\tdrow,dcreated=DailyReport.objects.get_or_create(specimenDate=_date,areacode=areacode,publag=lag)\n\t\t\t\t\tdrow.dailycases=daily\n\t\t\t\t\tdrow.add_cases=daily #if a new daily case, assume no prior report\n\t\t\t\t\tdrow.save()\n\t\t\t\n\t\t\tif not created:\n\t\t\t\texisting_daily=row.dailyLabConfirmedCases\n\t\t\t\texisting_total=row.totalLabConfirmedCases\n\t\t\t\tif daily is not None:\n\t\t\t\t\tif existing_daily !=daily or existing_total!=total:\n\t\t\t\t\t\trow.dailyLabConfirmedCases=daily\n\t\t\t\t\t\trow.totalLabConfirmedCases=total\n\t\t\t\t\t\trow.save()\n\t\t\t\t\t\tif existing_daily !=daily:\n\t\t\t\t\t\t\tlog.debug(f'Updating {row.areaname} on {datestring}: Daily: {existing_daily} to {daily} Total: {existing_total} to {total}')\n\t\t\t\t\t\t\tif existing_daily:\n\t\t\t\t\t\t\t\t_increase=daily-existing_daily\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t_increase=daily\n\t\t\t\t\t\t\tlag=(pubdate-_date.date()).days\n\t\t\t\t\t\t\tdrow,dcreated=DailyReport.objects.get_or_create(specimenDate=_date,areacode=areacode,publag=lag)\n\t\t\t\t\t\t\tdrow.dailycases=daily\n\t\t\t\t\t\t\tdrow.add_cases=_increase\n\t\t\t\t\t\t\tdrow.save()\n\t\t\t\t\t\n\t\t\tcounter+=1\n\t\t\tif counter%1000==0:\n\t\t\t\tlog.info(f'Processing row {counter}')\n\t\tlog.info(f'Processed: {counter} rows')\n\n\t\tif self.edition:\n\t\t\tconfigs.userconfig.update('PHE','latest_update',self.edition)\n\t\telse:\n\t\t\tlog.info('Latest update not updated')","def update_historical_data():\n print('updating historical data')\n for sp in SupplyPoint.objects.filter(supplypointwarehouserecord__isnull=True).exclude(type__code=SupplyPointCodes.ZONE):\n update_historical_data_for_supply_point(sp)","def create_address_data():\r\n print(\"Reading address data file\")\r\n addresses = pd.read_csv(raw_loc + 'san_francisco_addresses.csv')\r\n addresses.columns = map(str.lower, addresses.columns)\r\n\r\n keepcolumns = ['lon', 'lat', 'number', 'street']\r\n addresses = addresses[keepcolumns]\r\n addresses['number'] = addresses['number'].apply(lambda x: re.findall( '\\d+', x)[0]).astype(int)\r\n addresses['address'] = addresses.apply(lambda x: str(x['number']) + \" \" + str(x['street']), axis = 1)\r\n addresses['streetname'] = addresses['street'].apply(return_street)\r\n addresses.drop_duplicates(subset = 'address', inplace = True)\r\n addresses['type'] = 'known'\r\n addresses.to_sql('raw_address_data', if_exists = 'replace', con = conn)\r\n\r\n\r\n print(\"Finding similar addresses\")\r\n df = pd.read_sql_query('Select distinct tickstreetno , tickstreetname , count(*) total_tickets from raw_ticket_data t1'\r\n ' left join raw_address_data t2 on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname '\r\n \" where t2.address is null group by tickstreetno, tickstreetname \", conn)\r\n\r\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\r\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\r\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\r\n df['blocknum'] = df['TickStreetNo'].apply(lambda x: math.ceil(x/100))\r\n df.drop_duplicates(inplace = True)\r\n\r\n df2 = addresses\r\n df2['blocknum'] = df2['number'].apply(lambda x: math.ceil(x/100))\r\n newdf = df.merge(df2, how = 'left', left_on = ['TickStreetName', 'blocknum'], \\\r\n right_on = ['streetname', 'blocknum'])\r\n\r\n\r\n unfound = newdf[pd.isnull(newdf.number)]\r\n unfound['type'] == \"unknown\"\r\n newdf = newdf[pd.isnull(newdf.number) == False]\r\n newdf['delta'] = np.abs(newdf['number'] - newdf['TickStreetNo'])\r\n newdf.sort_values(by = 'delta', inplace = True)\r\n newdf.drop_duplicates(subset = ['TickStreetName', 'TickStreetNo'], keep = 'first', inplace = True)\r\n\r\n newdf = newdf[[ 'lon', 'lat', 'TickStreetNo', 'street', 'address','streetname' ]]\r\n newdf.columns = ['lon', 'lat', 'number', 'street', 'address','streetname' ]\r\n newdf['address'] = newdf['number'].map(str) + ' ' + newdf['street']\r\n newdf.drop_duplicates(inplace = True)\r\n newdf['type'] = 'similar'\r\n newdf.to_sql('raw_address_data', conn, if_exists = 'append')\r\n unfound = unfound[unfound.TickStreetNo < 10000]\r\n\r\n\r\n print(\"Searching for Intersection Addresses\")\r\n #unfound = unfound[(unfound.TickStreetNo < 10000) & (unfound.TickStreetNo > 0)]\r\n isection = unfound[['TickStreetNo','TickStreetName', 'total_tickets']]\r\n isection['address'] = isection['TickStreetName'].apply(return_intersections)\r\n unfound = isection[pd.isnull(isection.address) == True]\r\n isection = isection[pd.isnull(isection.address) == False]\r\n isection = isection.merge(addresses, left_on = 'address', right_on = 'address')\r\n isection = isection[['number', 'streetname', 'street', 'address', 'lat', 'lon']]\r\n isection.to_sql('raw_address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n\r\n print(\"Searching for Unknown Addresses\")\r\n unfound.drop_duplicates(inplace = True)\r\n tqdm.pandas()\r\n unfound['street'] = unfound.apply(lambda x: return_streetname_unknown(x['TickStreetNo'], x['TickStreetName']), axis = 1)\r\n unfound['address'] = unfound.apply(lambda x: str(x['TickStreetNo']) + \" \" + str(x['street']), axis = 1)\r\n numlookup = 5000\r\n print(\"There are \" + str(unfound.shape[0]) + \" addresses we couldn't find, we're goin to lookup \" + str(numlookup))\r\n lookup = unfound.sort_values(by = 'total_tickets', ascending = False)[:numlookup] #CHANGE TO 5000\r\n lookup['coordinates'] = lookup['address'].progress_apply(lambda x: create_locs(x + ' SAN FRANCISCO CA'))\r\n lookup.dropna(subset = ['coordinates'], inplace = True)\r\n lookup['lat'] = lookup['coordinates'].apply(lambda x: x[0])\r\n lookup['lon'] = lookup['coordinates'].apply(lambda x: x[1])\r\n lookup.rename(columns = {'TickStreetNo':'number', 'TickStreetName':'streetname'}, inplace = True)\r\n lookup = lookup[['lat', 'lon', 'street', 'number', 'streetname', 'address']]\r\n unfound = unfound[unfound['address'].isin(lookup['address']) == False]\r\n unfound['type'] = 'unfound'\r\n lookup['type'] = 'searched'\r\n lookup.to_sql('raw_address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n print(\"associating neighborhoods\")\r\n addresses = pd.read_sql_query('Select * from raw_address_data', conn)\r\n addresses['geometry'] = addresses.apply(lambda x: Point(x['lon'], x['lat']), axis = 1)\r\n point = gpd.GeoDataFrame(addresses['geometry'])\r\n point.crs = {'init': 'epsg:4326'}\r\n poly = gpd.GeoDataFrame.from_file(raw_loc+ 'AnalysisNeighborhoods.geojson')\r\n pointInPolys = gpd.tools.sjoin(point, poly, how='left')\r\n addresses['geometry'] = addresses['geometry'].astype(str)\r\n pointInPolys['geometry'] = pointInPolys['geometry'].astype(str)\r\n addresses = addresses.merge(pointInPolys, left_on = 'geometry', right_on = 'geometry')\r\n addresses.drop(columns = ['geometry', 'index', 'index_right'], inplace = True)\r\n addresses.drop_duplicates(subset = 'address', inplace = True)\r\n addresses['number'] = addresses['number'].astype(int)\r\n addresses.to_sql('address_data', conn, if_exists = 'replace')\r\n\r\n\r\n unfound.rename(columns = {'TickStreetNo':'number', 'TickStreetName': 'streetname'}, inplace = True)\r\n unfound.drop(columns = 'total_tickets', inplace = True)\r\n unfound['number'] = unfound['number'].astype(int)\r\n unfound.to_sql('address_data', if_exists = 'append', con = conn)\r\n\r\n\r\n\r\n \"\"\"Function is to separate addresses into those that may have have more than one address associated with a ticket and street name combo. \"\"\"\r\n grouped = addresses.groupby(by = ['number', 'streetname'], as_index = False)['address'].agg('count')\r\n grouped.sort_values(by = 'address', ascending = False)\r\n grouped.columns = ['number', 'streetname', 'count_ad']\r\n single_address = grouped[grouped.count_ad ==1]\r\n single_address = single_address.merge(addresses, left_on = ['number', 'streetname'], right_on = ['number', 'streetname'])\r\n double_address = addresses[addresses.address.isin(single_address['address']) == False]\r\n single_address.to_sql('single_address', conn, if_exists = 'replace')\r\n\r\n return single_address, double_address, addresses","def test_ipam_ip_addresses_update(self):\n pass","def test_pre_fill_and_assign(self):\n users = []\n for i in range(1, 50):\n users.append(User.objects.create_user(username=\"u{0}\".format(i)))\n pre_fill.main([\"--managers\", \"--workshift\"])\n utils.make_workshift_pool_hours(semester=self.semester)\n # Assign manager shifts beforehand\n for user, manager in zip(users, Manager.objects.all()):\n manager.incumbent = UserProfile.objects.get(user=user)\n manager.save()\n unfinished = utils.auto_assign_shifts(self.semester)\n self.assertEqual([], unfinished)","def _prefit(self,costfunc,sample):\n # Here we obtain 10 initial candidates to best fitting\n #opt=100.\n if self.long_fitting[sample]:\n l1=np.linspace(-20,0,16)\n l2=np.linspace(-10,-0.3,16)\n l3=np.linspace(-0.5,0.5,16)\n l4=np.linspace(-0.015,0.015,16)\n else:\n l1=np.linspace(-20,0,5)\n l2=np.linspace(-10,-0.3,5)\n l3=np.linspace(-0.5,0.5,5)\n l4=np.linspace(-0.015,0.015,5)\n l1,l2,l3,l4=np.meshgrid(l1,l2,l3,l4)\n l1,l2,l3,l4=l1.ravel(),l2.ravel(),l3.ravel(),l4.ravel()\n #self._message(\"(%s) Prefitting data (grid search) - %d tests.\"%(sample,l1.size))\n costs=np.ones_like(l1)\n #optpar=np.array((l1[8],l2[8],l3[8],l4[8]))\n for j in range(l1.size):\n ll=np.array((l1[j],l2[j],l3[j],l4[j]))\n costs[j]=costfunc(ll)\n idx=np.argsort(costs)\n opt=costs[idx]\n optpars=np.column_stack((l1[idx],l2[idx],l3[idx],l4[idx]))\n #self._message(str(optpars.shape))\n #self._message(\"(%s) Prefitting done. Error achieved after prefitting: %s.\"%(sample,str(opt)))\n #self._message(\"(%s) Prefitting done. Error achieved after prefitting: %g.\"%(sample,opt[0]))\n if opt[0]>=1:\n self._message(\"Warning: (%s) Prefitting did not find a good initial condition (%g).\"%(sample,opt[0]))\n return optpars,opt","def test_ipam_ip_addresses_partial_update(self):\n pass","def test_do_apogee_science_500s_after_1000s_cart7(self):\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 1000)\n self.assertEqual(cmdState.keywords['expTime'], 1000)\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 500)\n self.assertEqual(cmdState.keywords['expTime'], 500)","def check_setpoints(self):\n # TODO: Can possibly put this in the CCBC Brains\n for heater in self.ard_data['heaters'].keys():\n current_temp = float(self.ard_data['tempsensors'][self.ard_data['heaters'][heater]['tsensor_name']]['value'])\n\n # Assign the pin_status the previous value from the previous iteration\n pin_status = self.ard_data['heaters'][heater]['status']\n\n if current_temp > self.ard_data['heaters'][heater]['upper limit']:\n pin_status = 'OFF'\n\n if current_temp < self.ard_data['heaters'][heater]['lower limit']:\n pin_status = 'ON'\n\n if current_temp >= self.ard_data['heaters'][heater]['maxtemp']:\n pin_status = 'OFF'\n\n self.ard_data['heaters'][heater]['status'] = pin_status\n\n for pump in self.ard_data['pumps'].keys():\n pressure = float(self.ard_data['presssensors'][self.ard_data['pumps'][pump]['psensor_name']]['pressure'])\n gallons = float(pressure * self.ard_data['pumps'][pump]['psi_to_gal_slope'] +\n self.ard_data['pumps'][pump]['psi_to_gal_intercept'])\n self.ard_data['pumps'][pump]['gallons'] = gallons\n\n # Assign the pin status the previous value from the previous cycle\n pin_status = self.ard_data['pumps'][pump]['status']\n\n if gallons > self.ard_data['pumps'][pump]['upper limit']:\n # Turn the pump off when the setpoint is above the setpoint\n pin_status = 'OFF'\n # TODO: Account for solenoid valve control when available\n\n if gallons < self.ard_data['pumps'][pump]['lower limit']:\n pin_status = 'ON'\n\n self.ard_data['pumps'][pump]['status'] = pin_status","def test_auto_assign_one_overflow(self):\n shift1 = RegularWorkshift.objects.create(\n workshift_type=self.wtype1,\n pool=self.p1,\n hours=6,\n )\n unfinished = utils.auto_assign_shifts(self.semester)\n self.assertEqual([self.profile], unfinished)\n self.assertNotIn(self.profile, shift1.current_assignees.all())\n\n instances = WorkshiftInstance.objects.filter(weekly_workshift=shift1)\n self.assertGreater(instances.count(), 0)\n self.assertTrue(all(\n instance.workshifter is None\n for instance in instances\n ))\n\n pool_hours = self.profile.pool_hours.get(pool=self.p1)\n self.assertEqual(\n pool_hours.assigned_hours,\n 0,\n )","def readdata(self, prefix, date, county):\n print('F30A: prefix and date', prefix, date)\n\n filetoread = open(prefix + 'EL30A')\n\n lines = []\n for line in filetoread:\n lines.append(line)\n\n linelimit = len(lines)\n# print('LINELIMIT', linelimit)\n linesub = 0\n while linesub < linelimit:\n line = lines[linesub]\n\n if len(line) < 4:\n linesub += 1\n continue\n if len(line.split()) < 2:\n linesub += 1\n continue\n possiblepctnumber = line[0:4]\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\n self._pctnumber = possiblepctnumber\n self._pctname = line[4:].strip()\n if self._pctnumber not in globalpcts:\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\n else:\n onepct = globalpcts[self._pctnumber]\n\n # here's the new 12 June 2018 kluge to get the numbers\n if 'BALLOTS CAST - TOTAL' in line:\n line = line.replace('.', ' ')\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\n line = line.replace(',', '') # commas in numbers\n\n# linesplit = line.split()\n self._ballots = []\n for item in line.split():\n self._ballots.append(int(item))\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\n onepct.updatefrom30a(self._registered, self._ballots, county)\n globalpcts[self._pctnumber] = onepct\n linesub += 1","def partition_geocode(con: sqlite3.Connection, cur: sqlite3.Cursor, quarter: str, county_cht: str):\n cur.execute('''SELECT 土地區段位置或建物區門牌 FROM \"{0}/TRX\"\n WHERE 縣市 = ?\n GROUP BY 土地區段位置或建物區門牌;'''.format(quarter), (county_cht,))\n for address, in cur.fetchall():\n cur.execute('''SELECT GEO.編號\n FROM \"{0}/TRX\" AS TRX, \"{0}/GEO\" AS GEO\n WHERE TRX.編號 = GEO.編號\n AND TRX.土地區段位置或建物區門牌 = ?\n AND GEO.LAT_Avg ISNULL;'''.format(quarter), (address,))\n identities = cur.fetchall()\n if not identities:\n continue\n print(\"[%d] \"%(len(identities)) + address)\n try:\n results = selective_geocode(address)\n except geo.AddressError:\n continue\n if len(results[\"lat\"]) != 5 or len(results[\"lon\"]) != 5:\n continue\n results[\"lat\"].append(sum(results[\"lat\"]) / len(results[\"lat\"]))\n results[\"lon\"].append(sum(results[\"lon\"]) / len(results[\"lon\"]))\n combined = [num for zipped in zip(results[\"lat\"], results[\"lon\"]) for num in zipped]\n values = [(tuple(combined) + identity) for identity in identities]\n cur.executemany('''UPDATE \"{0}/GEO\" SET\n LAT_1 = ?, LON_1 = ?,\n LAT_2 = ?, LON_2 = ?,\n LAT_3 = ?, LON_3 = ?,\n LAT_4 = ?, LON_4 = ?,\n LAT_5 = ?, LON_5 = ?,\n LAT_Avg = ?, LON_Avg = ?\n WHERE 編號 = ?;'''.format(quarter), values)\n con.commit()","def _set_search_addresses(self):\n if self._report_data and self._report_data['details']:\n for detail in self._report_data['details']:\n if detail.get('ownerGroups'):\n for group in detail['ownerGroups']:\n for owner in group['owners']:\n Report._format_address(owner['address'])\n if detail.get('location') and 'address' in detail['location']:\n Report._format_address(detail['location']['address'])\n if detail.get('notes'):\n for note in detail['notes']:\n if note.get('contactAddress'):\n Report._format_address(note['contactAddress'])\n elif note.get('givingNoticeParty') and note['givingNoticeParty'].get('address'):\n Report._format_address(note['givingNoticeParty']['address'])","def addresses_per_kvk_to_sql(self):\n\n self.logger.info(\"Start writing the addressees to the sql Addresses table\")\n if self.address_df.index.size == 0:\n self.logger.debug(\"Empty address data frame. Nothing to write\")\n return\n\n # create selection of data columns\n self.address_df[COMPANY_KEY] = None\n columns = [KVK_KEY, NAME_KEY, ADDRESS_KEY, POSTAL_CODE_KEY, CITY_KEY, COMPANY_KEY]\n df = self.address_df[columns].copy()\n df.sort_values([KVK_KEY], inplace=True)\n # count the number of urls per kvk\n\n n_postcode_per_kvk = df.groupby(KVK_KEY)[KVK_KEY].count()\n self.logger.info(f\"Found: {self.n_company} companies\")\n wdg = PB_WIDGETS\n if self.progressbar:\n wdg[-1] = progress_bar_message(0, self.n_company)\n progress = pb.ProgressBar(widgets=wdg, maxval=self.n_company, fd=sys.stdout).start()\n else:\n progress = None\n\n company_list = list()\n for counter, company in enumerate(self.company_vs_kvk):\n kvk_nr = int(company.kvk_nummer)\n # we need to check if this kvk is in de address list still\n\n try:\n n_postcode = n_postcode_per_kvk.loc[kvk_nr]\n except KeyError:\n continue\n\n # add the company number of url time to the list\n company_list.extend([company] * n_postcode)\n\n if progress:\n wdg[-1] = progress_bar_message(counter, self.n_company, kvk_nr, company.naam)\n progress.update(counter)\n if counter % MAX_SQL_CHUNK == 0:\n self.logger.info(\" Added {} / {}\".format(counter, self.n_company))\n if progress:\n progress.finish()\n\n df[COMPANY_KEY] = company_list\n\n self.logger.info(\"Converting addresses to dict. This make take some time...\")\n address_list = list(df.to_dict(orient=\"index\").values())\n\n # turn the list of dictionaries into a sql table\n self.logger.info(\"Start writing table addresses\")\n n_batch = int(len(address_list) / MAX_SQL_CHUNK) + 1\n if self.progressbar:\n wdg = PB_WIDGETS\n wdg[-1] = progress_bar_message(0, self.n_company)\n progress = pb.ProgressBar(widgets=wdg, maxval=n_batch, fd=sys.stdout).start()\n else:\n progress = None\n with self.database.atomic():\n for cnt, batch in enumerate(pw.chunked(address_list, MAX_SQL_CHUNK)):\n self.logger.info(\"Address chunk nr {}/{}\".format(cnt + 1, n_batch))\n self.AddressTbl.insert_many(batch).execute()\n if progress:\n wdg[-1] = progress_bar_message(cnt, n_batch)\n progress.update(cnt)\n if progress:\n progress.finish()","def _update_cust_table(self, add, i, pred):\n self.cust_table.set_value(add, 'period{}_forc_shrink_value_per_day_per_item'.format(i), pred)\n days_i = self.cust_table.columns.get_loc('days_between_visits')\n days = self.cust_table.loc[add][days_i]\n last_visit_i = self.cust_table.columns.get_loc('last_visit')\n last_visit = self.cust_table.loc[add][last_visit_i]\n next_visit = last_visit.to_datetime() + pd.to_timedelta(i * days, unit='D')\n self.cust_table.set_value(add, 'period{}_pred_date'.format(i), next_visit)","def test_do_apogee_science_1000s_after_500s_cart7(self):\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 500)\n self.assertEqual(cmdState.keywords['expTime'], 500)\n\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\n self._update_cart(7, 'APOGEE')\n cmdState = self.actorState.doApogeeScience\n cmdState.reinitialize(self.cmd)\n self.assertEqual(cmdState.expTime, 1000)\n self.assertEqual(cmdState.keywords['expTime'], 1000)","def load_presn_search(search, start, end, offset, limit):\n now_local = datetime.now()\n timelimit = timedelta(hours=100)\n server = couchdb.Server(\"http://snoplus:\"+app.config[\"COUCHDB_PASSWORD\"]+\"@\"+app.config[\"COUCHDB_HOSTNAME\"])\n db = server[\"pre-supernova\"]\n \n results = []\n skip = offset\n\n if search == \"run\":\n startkey = [int(start)]\n endkey = [int(end)]\n view = '_design/presn/_view/presn_by_run_date'\n\n elif search == \"date\":\n start_year = start[0:4]\n start_month = start[5:7]\n start_day = start[8:10]\n end_year = end[0:4]\n end_month = end[5:7]\n end_day = end[8:10]\n if start_month[0] == \"0\":\n start_month = start_month[1]\n if end_month[0] == \"0\":\n end_month = end_month[1]\n if start_day[0] == \"0\":\n start_day = start_day[1]\n if end_day[0] == \"0\":\n end_day = end_day[1]\n startkey = [int(start_year), int(start_month), int(start_day)]\n endkey = [int(end_year), int(end_month), int(end_day)]\n view = '_design/presn/_view/presn_by_date_run'\n \n if search == \"run\":\n try:\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\n total = len(all.rows)\n print \"OK, run gives us\", total\n print all\n except:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB.\")\n\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\n try:\n year = row.value[0]\n mon = row.value[1]\n day = row.value[2]\n hour = row.value[3]\n minute = row.value[4]\n sec = row.value[5]\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n run = row.key\n run_id = row.id\n if timediff<timelimit:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n\n elif search == \"date\":\n try:\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\n total = len(all.rows)\n except:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB.\")\n\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\n try:\n year = row.key[0]\n mon = row.key[1]\n day = row.key[2]\n hour = row.key[3]\n minute = row.key[4]\n sec = row.key[5]\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n run = row.value\n run_id = row.id\n if timediff<timelimit:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n return results, total, offset, limit","def set_address(self, new_address, ):\n self.address.append(new_address)\n self.save()","def cleanup(self):\n all_aps_info = self.zd.get_all_ap_info()\n all_aps_ins = self.testbed.components['AP']\n for ap_ins in all_aps_ins:\n for ap_info in all_aps_info:\n if ap_ins.base_mac_addr.upper() == ap_info.get('mac').upper() and ap_info.get('ip_addr') != '':\n ap_ins.ip_addr = ap_info.get('ip_addr')","def set_addresses(cls, records, name, value=None):\n Party = Pool().get('party.party')\n\n for record in records:\n Party.write([record.party], {'addresses': value})","def firstPass(self, priorityBondList=[]):\r\n self.lastRefreshTime = datetime.datetime.now()\r\n if priorityBondList == []:\r\n emptyLines = list(self.df.index)\r\n isins = self.embondsisins + BBGHand + ' Corp'\r\n else:\r\n emptyLines = priorityBondList\r\n isins = self.df.loc[priorityBondList, 'ISIN'] + BBGHand + ' Corp'\r\n isins = list(isins.astype(str))\r\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceLongQuery)\r\n blptsStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\r\n blpts.register(blptsStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n isins = self.rfbondsisins + ' @CBBT Corp'\r\n isins = list(isins.astype(str))\r\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceRFQuery)\r\n blptsStream = StreamWatcher(self, BloombergQuery.FIRSTPASS)\r\n blpts.register(blptsStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n specialBondList = list(set(emptyLines) & set(SPECIALBONDS))\r\n specialIsins = map(lambda x:self.df.at[x,'ISIN'] + BBGHand + ' Corp',specialBondList)\r\n blpts = blpapiwrapper.BLPTS(specialIsins, self.bbgPriceLongSpecialQuery)\r\n specialbondStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\r\n blpts.register(specialbondStream)\r\n blpts.get()\r\n blpts.closeSession()\r\n\r\n for bond in emptyLines:\r\n self.updateStaticAnalytics(bond) # This will update benchmarks and fill grid. Has to be done here so all data for benchmarks is ready.\r","def change_map501_pswap_trades(status):\n print(\"Processing pswaps for MAP501\")\n portfolio = acm.FPhysicalPortfolio[\"PB_PSWAP_MAP_501_CR\"]\n graveyard = acm.FPhysicalPortfolio[\"GRAVEYARD\"]\n trades = [t for t in portfolio.Trades()\n if is_child_portf(t.Instrument().FundPortfolio(), graveyard)]\n set_status(trades, status)","def UpdatePlacements(WeeklyResultsfile, oldPlacementsfile:str, Placementsfile:str, week:int):\r\n WR = pd.read_csv(WeeklyResultsfile, encoding = \"ISO-8859-1\")\r\n if week != 1:\r\n Placement = pd.read_csv(oldPlacementsfile, encoding = \"ISO-8859-1\")\r\n Placement[f'PWeek{week}'] = -2\r\n for index, row in WR.iterrows():\r\n oldPlayer = Placement[Placement['SmasherID'].isin([row['SmasherID']])]\r\n if len(oldPlayer) > 0: # Have they entered before?\r\n index = oldPlayer.index[0]\r\n Placement.at[index, 'SmashTag'] = row['SmashTag'] # If someone changes their tag\r\n Placement.at[index, f'PWeek{week}'] = row['Placement']\r\n else:\r\n new_row = {'SmasherID': row['SmasherID'], # New TMT Entrant\r\n 'SmashTag': row['SmashTag'],\r\n f'PWeek{week}': row['Placement']}\r\n for i in range(1, week):\r\n new_row[f'PWeek{i}'] = -2\r\n Placement = Placement.append(new_row, ignore_index = True)\r\n else:\r\n WR['NumTMTEntered'] = 0\r\n WR['NumInBracket'] = 0\r\n Placement = WR[['SmasherID', 'SmashTag', 'NumTMTEntered',\r\n 'NumInBracket', 'Placement']]\r\n Placement = Placement.rename(columns={'Placement': 'PWeek1'})\r\n \r\n FindTournamentEntrants(Placement, week)\r\n Placement = Placement.sort_values(by = 'SmasherID')\r\n Placement.to_csv(Placementsfile, index=False, encoding = \"ISO-8859-1\")","def _set_ppr_search(self): # pylint: disable=too-many-branches, too-many-statements\n for detail in self._report_data['details']:\n if detail.get('pprRegistrations'):\n for registration in detail['pprRegistrations']:\n current_app.logger.debug('Setting up ppr registration for ' +\n registration['financingStatement']['baseRegistrationNumber'])\n if 'registrationAct' in registration['financingStatement']:\n act: str = registration['financingStatement']['registrationAct']\n registration['financingStatement']['registrationAct'] = act.title()\n ppr_report_utils.set_ppr_template_data(registration['financingStatement'])","def reap_recent_assignments():\n from anubis.config import config\n\n recent_assignments = Assignment.query.filter(\n Assignment.release_date > datetime.now(),\n Assignment.due_date > datetime.now() - config.STATS_REAP_DURATION,\n ).all()\n\n print(json.dumps({\n 'reaping assignments:': [assignment.data for assignment in recent_assignments]\n }, indent=2))\n\n for assignment in recent_assignments:\n for submission in Submission.query.filter(\n Submission.assignment_id == assignment.id,\n Submission.build == None,\n ).all():\n if submission.build is None:\n init_submission(submission)\n enqueue_autograde_pipeline(submission.id)\n\n for assignment in recent_assignments:\n bulk_autograde(assignment.id)","def update_db(df, db, app=None):\n db = db\n\n print_or_log(\"Formatting data...\", app=app)\n\n # list to keep track of filtered data\n # keys are the date with the code concatenated\n entries = {}\n i = 1\n for key, sheet in df.items():\n\n # print progress\n print_or_log(\"{}/{}\".format(i, len(df.items())), end=\"\\r\", app=app)\n i += 1\n\n # prepare exam results from sheet period\n for index, row in sheet.iterrows():\n\n # skip if not exam\n if row[\"Provnamn\"] != \"Tentamen\":\n continue\n\n # retrieve course code\n code = row[\"Kurs\"]\n\n # retrieve course name\n name = row[\"Kursnamn\"]\n\n # retrieve grade\n grade = row[\"Betyg\"]\n\n # retrieve amount of results\n amount = row[\"Antal\"]\n\n # retrieve exam date\n date = row[\"Provdatum\"]\n if type(date) is pd.Timestamp:\n date = str(date.date())\n\n # necessary because of different date formats in sheets\n elif type(date) is str:\n date = str(parse(date).date())\n\n # if exam occasion hasn't been encountered yet, add it\n key = code + date\n if key not in entries:\n entries[key] = {\n \"taken\": date,\n \"code\": code,\n \"name\": name,\n \"failures\": 0,\n \"threes\": 0,\n \"fours\": 0,\n \"fives\": 0,\n }\n\n # now modify grade that this iteration concerns in occasion\n if grade == \"U\":\n entries[key][\"failures\"] = amount\n elif grade == \"3\":\n entries[key][\"threes\"] = amount\n elif grade == \"4\":\n entries[key][\"fours\"] = amount\n elif grade == \"5\":\n entries[key][\"fives\"] = amount\n\n print_or_log(\"\\nInserting data...\", app=app)\n insertions = 0\n i = 1\n\n # go through entries and add them if they're not already present in the database\n for key, entry in entries.items():\n\n # print progress\n print_or_log(\"{}/{}\".format(i, len(entries.items())), end=\"\\r\", app=app)\n i += 1\n\n # see if there is an entry matching the course code and exam date\n db_entry = db.query(\n \"SELECT * FROM results WHERE code=%s AND taken=%s\", (entry[\"code\"], entry[\"taken\"]))\n\n # if there isn't, we can insert the new result in the database\n if len(db_entry) == 0:\n insertions += 1\n\n db.query(\"INSERT INTO results (taken, code, name, failures, threes, fours, fives) \"\n \"VALUES (%s,%s,%s,%s,%s,%s,%s)\", (entry[\"taken\"], entry[\"code\"], entry[\"name\"], entry[\"failures\"],\n entry[\"threes\"], entry[\"fours\"], entry[\"fives\"]))\n\n print_or_log(\"\\nInserted \" + str(insertions) + \" entries in database\", app=app)","def _put_reg_prep_in_rc_db(context: 'IconScoreContext', address: 'Address'):\n\n rc_tx_batch: list = context.rc_tx_batch\n block_height: int = context.block.height\n\n tx: 'PRepRegisterTx' = RewardCalcDataCreator.create_tx_prep_reg()\n iiss_tx_data: 'TxData' = RewardCalcDataCreator.create_tx(address, block_height, tx)\n context.storage.rc.put(rc_tx_batch, iiss_tx_data)","def collect_web_sites(self):\n min_distance = None\n max_sequence_match = None\n index_string_match = index_distance = None\n self.collection = collections.OrderedDict()\n for i_web, web_row in self.company_urls_df.iterrows():\n # get the url first from the websites table which list all the urls belonging to\n # one kvk search\n url = web_row[URL_KEY]\n\n # skip all none uls and also the filtered urls\n if url is None or url == \"\":\n logger.debug(\"Skipping url because it is None or empty\")\n continue\n if self.filter_urls and url not in self.filter_urls:\n logger.debug(f\"filter urls is given so skip {url}\")\n continue\n\n # store a list of UrlInfo object with a minimum info the url which was tested\n url_info = UrlInfo(index=i_web, url=url)\n self.collection[url] = url_info\n\n print_banner(f\"Processing {url}\")\n\n # quick check if we can processes this url based on the country code\n suffix = url_info.url_extract.suffix\n if suffix in self.exclude_extensions.index:\n url_info.outside_nl = True\n logger.info(f\"Web site {url} has suffix '.{suffix}' Continue \")\n\n # get the processing time of the last time you did this url from the table\n try:\n processing_time = self.urls_df.loc[url, DATETIME_KEY]\n except KeyError:\n processing_time = None\n\n if self.force_process or self.rescan_missing_urls:\n url_info.needs_update = True\n else:\n url_info.needs_update = check_if_url_needs_update(processing_time=processing_time,\n current_time=self.current_time,\n older_time=self.older_time)\n if url_info.needs_update:\n # if the url needs update, store the current time\n url_info.processing_time = self.current_time\n else:\n url_info.processing_time = processing_time\n\n url_analyse = self.scrape_url_and_store_in_dataframes(url, url_info)\n\n url_info.url_analyse = url_analyse\n\n if url_analyse and not url_analyse.exists:\n self.logger.debug(f\"url '{url}'' does not exist\")\n continue\n\n # based on the company postcodes and kvknummer and web contents, make a ranking how\n # good the web sides matches the company\n match = UrlCompanyRanking(url, self.company_name_small,\n url_extract=url_info.url_extract,\n url_analyse=url_analyse,\n company_kvk_nummer=self.kvk_nr,\n company_postcodes=self.postcodes,\n threshold_string_match=self.threshold_string_match,\n threshold_distance=self.threshold_distance,\n logger=self.logger)\n\n url_info.match = match\n\n # update the min max\n if min_distance is None or match.distance < min_distance:\n index_distance = i_web\n min_distance = match.distance\n\n if max_sequence_match is None or match.string_match > max_sequence_match:\n index_string_match = i_web\n max_sequence_match = match.string_match\n\n self.logger.debug(\" * {} - {} - {}\".format(url, match.ext.domain,\n match.distance))\n\n if min_distance is None:\n self.company_urls_df = None\n elif index_string_match != index_distance:\n self.logger.warning(\n \"Found minimal distance for {}: {}\\nwhich differs from \"\n \"best string match {}: {}\".format(index_distance,\n self.collection[url].url,\n index_string_match,\n self.collection[url].url))","def district_check(self):\n\t\t\n\t\tplaces_2_fetch=list(ons_week.stored_names.values())+ons_week.extra_places\n\t\tself.edition=None\n\t\tfor place in places_2_fetch:\n\t\t\t_filters=self.district_filter(place)\n\t\t\tif _filters:\n\t\t\t\tself.api.filters=_filters\n\t\t\telse:\n\t\t\t\tlog.info(f'Not fetching {place} - not in PHE API')\n\t\t\t\tcontinue\n\t\t\ttries=0\n\t\t\twhile tries < 5:\n\t\t\t\ttry:\n\t\t\t\t\tlog.debug(f'Fetching {place}')\n\t\t\t\t\tself.data=self.api.get_json() # Returns a dictionary\n\t\t\t\t\tnew_data=self.data.get('data')\n\t\t\t\t\t#log.info(self.latest_update)\n\t\t\t\t\tif not self.edition:\n\t\t\t\t\t\tself.edition=self.latest_update\n\t\t\t\t\tbreak\n\t\t\t\texcept Exception as e:\n\t\t\t\t\tlog.error(e)\n\t\t\t\t\tlog.error('Retrying after 8 secs')\n\t\t\t\t\ttime.sleep(8)\n\t\t\t\t\ttries +=1\n\t\t\t\t\tnew_data=[]\n\t\t\tif not new_data:\n\t\t\t\tlog.error(f'No data found for {place}')\n\t\t\telse:\n\t\t\t\tself.data_all +=new_data\n\t\t\ttime.sleep(0.1)","def _compute_adress(self):\r\n\t\tfor leads in self:\r\n\t\t\tleads.address = leads.street + \" \" + leads.street2","def update_address(cls, address_data):\n address_instance = cls.objects.get(email=address_data['customer']['email'])\n address_data = address_data.get('addresses')\n for field_name, values in address_data:\n setattr(address_instance, field_name, values)\n address_instance.save()\n return address_instance.save()","def decideWorkers(availableWorkers,today,num=4,mopping=False):\n secondary = 0 # count for how many secondaries are working today\n\n availableWorkers.sort(key=lambda worker: worker.getCleanCount())\n for minion in availableWorkers[:num]: # take the first four lowest\n if minion.getWorkEnd() != 9.0: # find the number of secondaries\n secondary += 1\n\n for minion in availableWorkers[:num+secondary]: # take the first four lowest and additionals to replace secondaries\n if mopping and (minion.getWorkEnd() == 9.0): #only people who will be at the end of lab to mop gets mopping counted\n minion.mopped()\n else: #if they aren't mopping or cannot mop, they only clean\n minion.cleaned()\n # Add this assignment to the schedule\n working = (minion.getName(),minion.getCleanCount()) #make the name and clean count a tuple\n \n \n \n today.append(working)\n return today","def test_can_lookup_postcode(self):\n postcode_to_lookup = \"SW1A 1AA\"\n os_places_key = self.app.config.get(\"OS_PLACES_API_KEY\")\n addresses = AddressLookup(key=os_places_key).by_postcode(postcode_to_lookup)\n self.assertGreater(len(addresses), 0)\n result_postcode = addresses[0].get(\"DPA\", {}).get(\"POSTCODE\")\n self.assertEqual(result_postcode, postcode_to_lookup)","def test_pre_assigned(self):\n shift1 = RegularWorkshift.objects.create(\n workshift_type=self.wtype1,\n pool=self.p1,\n hours=5,\n )\n shift2 = RegularWorkshift.objects.create(\n workshift_type=self.wtype3,\n pool=self.p1,\n hours=1,\n )\n shift2.current_assignees = [self.profile]\n\n unfinished = utils.auto_assign_shifts(self.semester)\n self.assertEqual([self.profile], unfinished)\n self.assertNotIn(self.profile, shift1.current_assignees.all())\n\n pool_hours = self.profile.pool_hours.get(pool=self.p1)\n self.assertEqual(\n pool_hours.assigned_hours,\n 1,\n )","def _set_rules_pxeboot(self, gnp_config, network, host):\n\n addr_pool = self.dbapi.address_pool_get(network.pool_uuid)\n ip_version = IPAddress(f\"{addr_pool.network}\").version\n self._add_source_net_filter(gnp_config[\"spec\"][\"ingress\"],\n f\"{addr_pool.network}/{addr_pool.prefix}\")\n if (ip_version == 6):\n self._add_source_net_filter(gnp_config[\"spec\"][\"ingress\"], LINK_LOCAL)\n if (ip_version == 4):\n # add rule to allow DHCP requests (dhcp-offer have src addr == 0.0.0.0)\n rule = self._get_dhcp_rule(host.personality, \"UDP\", ip_version)\n gnp_config[\"spec\"][\"ingress\"].append(rule)","def populate_town(self, people=50):\n \n #1.5 acres farm needed per person\n #farmer could farm 20-40 (30) acres\n #30/1.5 = 20 people per farm\n people_to_assign = people\n farms_needed = (self.population + people)/20 + 1\n if people_to_assign >= farms_needed:\n self.occupations['farmer'] += farms_needed\n people_to_assign -= farms_needed\n else:\n self.occupations['farmer'] += people_to_assign\n shuffle(sites['object list'])\n while people_to_assign > 0:\n for site in [\n x for x in sites['object list'] if ref.structure_type_dct[x.structure.structure_type]['site type'] == 'resource'\n ]:\n if site.structure.worker_capacity > 0:\n self.occupations[ref.structure_type_dct[\n site.structure.structure_type]['worker type']] += 1\n site.structure.add_worker()\n people_to_assign -= 1\n continue\n self.occupations[choice(\n ['artisan']*2 + \n ['homekeeper']*5 + \n ['government'] +\n ['retail']*2)] += 1\n people_to_assign -= 1 \n \n self.population += people\n return self","def set_primary_ips(self):\n for nb_obj_type in (\"devices\", \"virtual_machines\"):\n log.info(\n \"Collecting NetBox %s objects to set Primary IPs.\",\n nb_obj_type[:-1].replace(\"_\", \" \")\n )\n obj_key = self.obj_map[nb_obj_type][\"key\"]\n # Collect all parent objects that support Primary IPs\n parents = self.request(\n req_type=\"get\", nb_obj_type=nb_obj_type,\n query=\"?tag={}\".format(format_slug(self.vc_tag))\n )\n log.info(\"Collected %s NetBox objects.\", parents[\"count\"])\n for nb_obj in parents[\"results\"]:\n update_object = False\n parent_id = nb_obj[\"id\"]\n nb_obj_name = nb_obj[obj_key]\n new_pri_ip = self.get_primary_ip(nb_obj_type, parent_id)\n # Skip the rest if we don't have a usable IP\n if new_pri_ip is None:\n log.info(\n \"No usable IPs were found for NetBox '%s' object. \"\n \"Moving on.\",\n nb_obj_name\n )\n continue\n if nb_obj[\"primary_ip\"] is None:\n log.info(\n \"No existing Primary IP found for NetBox '%s' object.\",\n nb_obj_name\n )\n update_object = True\n else:\n log.info(\n \"Primary IP already set for NetBox '%s' object. \"\n \"Comparing.\",\n nb_obj_name\n )\n old_pri_ip = nb_obj[\"primary_ip\"][\"id\"]\n if old_pri_ip != new_pri_ip[\"id\"]:\n log.info(\n \"Existing Primary IP does not match latest check. \"\n \"Requesting update.\"\n )\n update_object = True\n else:\n log.info(\n \"Existing Primary IP matches latest check. Moving \"\n \"on.\"\n )\n if update_object:\n log.info(\n \"Setting NetBox '%s' object primary IP to %s.\",\n nb_obj_name, new_pri_ip[\"address\"]\n )\n ip_version = str(\n \"primary_ip{}\".format(\n ip_network(\n new_pri_ip[\"address\"], strict=False\n ).version\n ))\n data = {ip_version: new_pri_ip[\"id\"]}\n self.request(\n req_type=\"patch\", nb_obj_type=nb_obj_type,\n nb_id=parent_id, data=data\n )","def assign_zone_veh(self, t, warmup_phase, penalty, operator):\n for z in self.zones:\n z.assign(self.zones, t, warmup_phase, penalty, operator)","def adjust_fitness_scores(self):\n\n for species in self.species:\n species.adjust_fitness()","def test_update__endtoend__4(\n address_book, FieldFactory, UpdateablePersonFactory,\n PostalAddressFactory, browser):\n field_name = FieldFactory(\n address_book, IPostalAddress, 'Choice', u'distance',\n values=[u'< 50 km', u'>= 50 km']).__name__\n PostalAddressFactory(UpdateablePersonFactory(address_book),\n **{field_name: '>= 50 km', 'set_as_default': True})\n\n browser.login('mgr')\n browser.keyword_search(KEYWORD, apply='Update')\n browser.getControl('field').displayValue = ['postal address -- distance']\n browser.getControl('Next').click()\n assert ['No value', '< 50 km', '>= 50 km'] == browser.getControl(\n 'new value').displayOptions\n browser.getControl('new value').displayValue = ['< 50 km']\n browser.getControl('operation').displayValue = [\n 'replace existing value with new one']\n browser.getControl('Next').click()\n # Update sets the value to '< 50 km':\n assert ('<td>Tester</td><td><50km</td>' in\n browser.contents_without_whitespace)","def add_vars(self, dump=False) -> None:\n self.logger.info('add_vars')\n\n # delete finance and insurance companies\n self.uber_data = self.uber_data.loc[\n (self.uber_data.loc[:, 'industry'] != 'banki')\n & (self.uber_data.loc[:, 'industry'] != 'ubezpieczenia'), :]\n\n self.uber_data.loc[:, 'D_BZ_date'] = self.uber_data.loc[:, 'D_BZ'].map(\n lambda m: datetime.datetime.strptime(m, \"%Y-%m-%d\").date())\n self.uber_data.loc[:, 'year'] = self.uber_data.loc[:, 'D_BZ_date'].map(lambda n: n.year)\n\n for i, x in self.uber_data.iterrows():\n statement_date = x.at['D_BZ_date']\n reference_date = statement_date\n if x.at['isin'] not in self.prices.keys():\n self.logger.warning('isin in data not in prices: {}'.format(x.at['isin']))\n continue\n # I don't trust Notoria, so I will check on my own in GPWinfostrefa for prices for debug\n before_ipo_date_check = False\n if reference_date <= self.ipo_dates[x.at['isin']]:\n before_ipo_date_check = True\n\n # add market price for balance sheet date\n while True:\n try:\n self.uber_data.loc[i, 'market_price'] = self.prices[x.at['isin']].loc[reference_date, 'eod_price']\n self.uber_data.loc[i, 'market_price_date'] = reference_date\n break\n except KeyError:\n reference_date = reference_date - datetime.timedelta(days=1)\n distance = statement_date - reference_date\n if distance >= datetime.timedelta(days=10):\n if before_ipo_date_check is False:\n self.logger.warning('achtung! no price in last {}, isin: {}, {}.'.format(\n distance, x.at['isin'], statement_date\n ))\n break\n\n # find price at the end of year for market cap calc\n # d = 31\n # while d > 25:\n # date = datetime.date(year=x.at['year'], month=12, day=d)\n # try:\n # self.uber_data.loc[i, 'price_end_of_year'] = self.prices[x.at['isin']].loc[date, 'eod_price']\n # except KeyError:\n # d = d - 1\n\n for i, x in self.uber_data.iterrows():\n self.uber_data.at[i, 'better_num_of_shares'] = self.get_number_of_shares(\n isin=x['isin'],\n date=x['D_BZ_date']\n )\n\n self.uber_data.loc[:, 'better_num_of_shares'] = pd.to_numeric(self.uber_data.loc[:, 'better_num_of_shares'])\n self.uber_data.loc[:, 'combined_num_of_shares'] = self.uber_data.loc[:, 'better_num_of_shares'] / 1000\n\n self.uber_data.loc[:, 'A_0'] = pd.to_numeric(self.uber_data.loc[:, 'A_0']) # many calcs\n self.uber_data.loc[:, 'PP_1'] = pd.to_numeric(self.uber_data.loc[:, 'PP_1']) # equity calc\n self.uber_data.loc[:, 'PP_2'] = pd.to_numeric(self.uber_data.loc[:, 'PP_2']) # LEV_LTM calc\n self.uber_data.loc[:, 'P_8'] = pd.to_numeric(self.uber_data.loc[:, 'P_8']) # equity calc\n self.uber_data.loc[:, 'WO_0'] = pd.to_numeric(self.uber_data.loc[:, 'WO_0']) # PROF calc\n self.uber_data.loc[:, 'R[AM_0]'] = pd.to_numeric(self.uber_data.loc[:, 'R[AM_0]']) # PROF calc\n self.uber_data.loc[:, 'AA_1'] = pd.to_numeric(self.uber_data.loc[:, 'AA_1']) # TANG calc\n self.uber_data.loc[:, 'market_price'] = pd.to_numeric(self.uber_data.loc[:, 'market_price'])\n\n # market value = market_price * combined_num_of_shares (ilość akcji w tysiącach) (uzyskana wartość w tysiącach)\n self.uber_data.loc[:, 'market_value'] = self.uber_data.loc[:, 'market_price'] * \\\n self.uber_data.loc[:, 'combined_num_of_shares']\n self.uber_data.loc[:, 'market_value'] = pd.to_numeric(self.uber_data.loc[:, 'market_value'])\n\n # PP_2 / A_0 (zobowiązania długoterminowe / suma aktywów)\n self.uber_data.loc[:, 'LEV_LTB'] = self.uber_data.loc[:, 'PP_2'] / self.uber_data.loc[:, 'A_0']\n self.uber_data.loc[:, 'LEV_LTB'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_LTB'])\n\n # PP_2 /(PP_2+market_value) zobowiązania_długoterminowe / (zobowiązania_długoterminowe+wartość rynkowa)\n self.uber_data.loc[:, 'LEV_LTM'] = (self.uber_data.loc[:, 'PP_2']) / \\\n (self.uber_data.loc[:, 'PP_2'] + self.uber_data.loc[:, 'market_value'])\n self.uber_data.loc[:, 'LEV_LTM'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_LTM'])\n\n # ln (A_0) ln(suma aktywów)\n self.uber_data.loc[:, 'Size'] = np.log(self.uber_data.loc[:, 'A_0'].tolist())\n self.uber_data.loc[:, 'Size'] = pd.to_numeric(self.uber_data.loc[:, 'Size'])\n\n self.uber_data.loc[:, 'equity'] = (self.uber_data.loc[:, 'PP_1'] + self.uber_data.loc[:, 'P_8'])\n self.uber_data.loc[:, 'equity'] = pd.to_numeric(self.uber_data.loc[:, 'equity'])\n\n # market_value / (PP_1 + P_8)\n # (wartość rynkowa w tys / (Kapitał własny udziałowców podmiotu dominującego + Udziały niekontrolujące)\n # (different procedures)\n self.uber_data.loc[:, 'MB'] = self.uber_data.loc[:, 'market_value'] / self.uber_data.loc[:, 'equity']\n\n self.uber_data.loc[:, 'MB'] = pd.to_numeric(self.uber_data.loc[:, 'MB'])\n\n # (WO_0+R[AM_0]) / A_0 ((Zysk/strata z działalności operacyjnej+amortyzacja) / suma aktywów)\n self.uber_data.loc[:, 'PROF'] = (self.uber_data.loc[:, 'WO_0'] + self.uber_data.loc[:, 'R[AM_0]'])\\\n / self.uber_data.loc[:, 'A_0']\n self.uber_data.loc[:, 'PROF'] = pd.to_numeric(self.uber_data.loc[:, 'PROF'])\n\n # AA_1 / A_0 (Aktywa trwałe / suma aktywów)\n self.uber_data.loc[:, 'TANG'] = self.uber_data.loc[:, 'AA_1'] / self.uber_data.loc[:, 'A_0']\n self.uber_data.loc[:, 'TANG'] = pd.to_numeric(self.uber_data.loc[:, 'TANG'])\n\n self.uber_data.loc[self.uber_data.loc[:, 'CFC_7'] < 0, 'DivPayer'] = 1\n self.uber_data.loc[self.uber_data.loc[:, 'DivPayer'] != 1, 'DivPayer'] = 0\n self.uber_data.loc[:, 'DivPayer'] = pd.to_numeric(self.uber_data.loc[:, 'DivPayer'])\n\n self.uber_data.loc[self.uber_data.loc[:, 'gov_owned'] != 1, 'gov_owned'] = 0\n self.uber_data.loc[:, 'gov_owned'] = pd.to_numeric(self.uber_data.loc[:, 'gov_owned'])\n\n self.uber_data.loc[:, 'growth_phase'] = self.uber_data.loc[:, 'D_BZ_date'].map(lambda n: self.get_phase(n))\n self.uber_data.loc[:, 'growth_phase'] = pd.to_numeric(self.uber_data.loc[:, 'growth_phase'])\n\n self.uber_data.loc[:, 'LEV_IMed'] = np.nan\n group_criterion = 'industry'\n for i, x in self.uber_data.iterrows():\n ss = x.at[group_criterion]\n for ii in self.uber_data.loc[:, group_criterion].unique():\n if ss == ii:\n self.uber_data.loc[i, 'LEV_IMed'] = self.uber_data.loc[\n self.uber_data.loc[:, group_criterion] == ii, 'LEV_LTB'].median()\n continue\n self.uber_data.loc[:, 'LEV_IMed'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_IMed'])\n\n # CFVol\n self.uber_data.loc[:, 'CFVol'] = np.nan\n for i, x in self.uber_data.iterrows():\n older = self.uber_data.loc[(self.uber_data.loc[:, 'isin'] == x.at['isin']) &\n (self.uber_data.loc[:, 'D_BZ_date'] < x.at['D_BZ_date']) &\n (self.uber_data.loc[:, 'WO_0'].notnull()), :]\n if len(older) >= 3:\n self.uber_data.at[i, 'CFVol'] = older.loc[:, 'WO_0'].std()\n self.uber_data.loc[:, 'CFVol'] = pd.to_numeric(self.uber_data.loc[:, 'CFVol'])\n\n self.uber_data.set_index(['isin', 'D_BZ'], inplace=True, drop=False)\n\n if dump is True:\n self.save_to_pickle(self.uber_data, 'uber_data')","def find_street_in_descriprion(self):\n from filtering_functions import find_street\n for ad_id, ad_data in self.ads_data.items():\n if 'Ulica_re' not in ad_data.keys():\n self.ads_data[ad_id]['Ulica_re'] = find_street(self.ads_data[ad_id]['Opis'])","def get_268_data(self, dbca_initial_control=None):\n qs_regions = get_sorted_regions()\n\n if dbca_initial_control:\n # get the fires managed by DBCA\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED], initial_control=Agency.DBCA,reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\n else:\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED],reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\n\n pbs_fires_dict = get_pbs_bushfires(outstanding_fires) or []\n\n if not dbca_initial_control:\n self.pbs_fires_dict = pbs_fires_dict\n #logger.info(\"self.pbs_fires_dict: \" + str(self.pbs_fires_dict))\n self.found_fires = [i['fire_id'] for i in self.pbs_fires_dict]\n self.missing_fires = list(set(outstanding_fires).difference(self.found_fires)) # fire_numbers not returned from PB\n\n rpt_map = {}\n for i in pbs_fires_dict: \n region_id = i['region']\n\n exists = [i for r in qs_regions if r.id==region_id]\n if exists:\n if rpt_map.has_key(region_id):\n rpt_map[region_id]['area'] = rpt_map[region_id]['area'] + float(i['area'])\n rpt_map[region_id]['number'] = rpt_map[region_id]['number'] + 1\n \n else:\n rpt_map[region_id] = {\n 'area' : float(i['area']),\n 'number' : 1\n }\n\n else:\n raise Exception(\"PBS Region id({}) Not Found in BFRS\".format(region_id))\n\n return rpt_map","def recalculate_delivery_numbers(self):\n from .delivery import Delivery\n qry = Delivery.objects.filter(deadline__assignment_group=self,\n successful=True)\n qry = qry.order_by('time_of_delivery')\n for number, delivery in enumerate(qry, 1):\n delivery.number = number\n delivery.save()","def update_db(bus_id=def_id):\n # Instantiate the SQL class for the business data we will be pulling\n sql = Sql(bus_id)\n\n # Check if we have previously analyzed the requested business\n # If not, pull the raw data and processing the data\n if sql.check() is not False:\n print \"Already in database!\"\n return\n\n # Get business data (name, country, etc) from Yelp API\n # Limited to 25,000 Yelp API calls per day\n # There are over 4 million reviews and over 140,000 businesses in database\n while True:\n try:\n bus_info = Yelp(bus_id)\n break\n except ValueError:\n pass\n except YelpAPI.YelpAPIError:\n return\n\n # Grab review text from SQL database\n sql.pull_reviews()\n\n # Use our trained XGBoost Classifier and TFIDF vectorizer\n # to determine whether each review is \"Favorable\" or \"Unfavorable\"\n model.predict(sql.reviews)\n\n # Conduct sentiment analysis and evaluate word counts in order to\n # \"penalize\" the weighting of reviews that don't fit the threshold\n nlp = Nlp(sql.reviews, sql.stars, model.preds,\n bus_info.name, bus_info.country, bus_info.city)\n\n # Assign variables from all the objects attributes we created\n # and then input them into a tuple.\n # The tuple is used to populate the SQL database for faster lookup of\n # our analysis at a later time\n # The tuple is also used to populate our dictionary which will be\n # used for variables that will be rendered on our website\n name = nlp.name\n city = nlp.city\n country = nlp.country\n old_rating = int(100 * nlp.stars_avg / 5)\n new_rating = int(nlp.new_rating * 100)\n rev_count = len(sql.reviews)\n count_5 = sql.stars.count(5)\n count_4 = sql.stars.count(4)\n count_3 = sql.stars.count(3)\n count_2 = sql.stars.count(2)\n count_1 = sql.stars.count(1)\n fav_count = (model.preds == 1).sum()\n unfav_count = (model.preds == 0).sum()\n avg_wts = int(100*sum(nlp.avg_wts) / len(nlp.avg_wts))\n bus_tup = (bus_id, name, city, country, old_rating, new_rating,\n rev_count, count_5, count_4, count_3, count_2, count_1,\n fav_count, unfav_count, avg_wts)\n sql.insert(bus_tup)\n print bus_tup","def update_priority(self, indexes, values):\n values = values * 10000\n values = self._clip_p(values)\n values = int(values)\n self.sum_tree.update(indexes, values)","def load_presn_runs(offset, limit):\n now_local = datetime.now()\n timelimit = timedelta(hours=100)\n server = couchdb.Server(\"http://snoplus:\"+app.config[\"COUCHDB_PASSWORD\"]+\"@\"+app.config[\"COUCHDB_HOSTNAME\"])\n db = server[\"pre-supernova\"]\n results = []\n skip = offset\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\n total = all.total_rows\n offset = all.offset\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\n year = row.key[0]\n mon = row.key[1]\n day = row.key[2]\n hour = row.key[3]\n minute = row.key[4]\n sec = row.key[5]\n run = row.value\n run_id = row.id\n runtime=datetime(year, mon, day, hour, minute, sec)\n timediff = now_local - runtime\n if timediff<timelimit:\n try:\n results.append(dict(db.get(run_id).items()))\n except KeyError:\n app.logger.warning(\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\" % run)\n results.sort(reverse=True)\n return results, total, offset, limit","def fill_priority_table(target_table, curs, conn, no_bins=5, no_obs=4):\n tar_ids = list(target_table['TAR_ID'])\n no_bins_1 = [no_bins]*len(target_table)\n noobs_bin_1 = [no_obs]*len(target_table)\n complete_1 = ['00'*no_bins]*len(target_table)\n no_bins_2 = [no_bins]*len(target_table)\n noobs_bin_2 = [no_obs]*len(target_table)\n complete_2 = ['00'*no_bins]*len(target_table)\n urgency = [0]*len(target_table)\n for i in range(0,len(target_table)):\n item = [tar_ids[i], no_bins_1[i], noobs_bin_1[i], complete_1[i], \n no_bins_2[i], noobs_bin_2[i], complete_2[i], urgency[i]]\n connect_database.add_priority_to_database(item, curs, conn)","def assign_ground_set_to_equi_salary_partitions(self, num_of_partitions, cardinality_constraint):\n print('In freelancer salary partition.')\n costs = set()\n for user_id in self.E:\n costs.add(self.cost_vector[user_id])\n sorted_costs = sorted(list(costs))\n # each cost is a partition\n if len(sorted_costs) <= num_of_partitions:\n self.partitions = defaultdict(dict,{i:{'users':set(), 'k':cardinality_constraint} for i in sorted_costs})\n else:\n partition_costs = list(self.split(sorted_costs, num_of_partitions))\n self.partitions = defaultdict(dict,{i[-1]:{'users':set(), 'k':cardinality_constraint} for i in partition_costs})\n\n for user_id in self.E:\n user_cost = self.cost_vector[user_id] \n min_val = 0\n for cost, users in self.partitions.items():\n max_val = cost\n if user_cost > min_val and user_cost <= max_val:\n self.partitions[max_val]['users'].add(user_id)\n break\n min_val = max_val","def assign_priorities_and_dp(self):\r\n taskset_copy = copy(self.taskset)\r\n tasks = taskset_copy.sorted_by_crit()","def locate(self):\n \n #CONNECT TO API\n api = GoogleV3(api_key = self.google_key)\n\n #INITALIZE ARRAY\n array = []\n\n #START GEOCODING ADDRESSES\n for i in tqdm(range(len(self.df)), desc='Geocoding Addresses'):\n\n \n row = self.df.iloc[i]\n\n #GET ADDRESS VARIABLES\n st_name = row['street_name']\n st_number = row['house_number']\n city = row['city']\n state = row['state/province']\n listing_number = row['listing_number']\n zip = row['postal_code']\n\n\n #FORMAT ADDRESS FOR API\n full_address = str(\"{} {},{},{},{}\".format(st_number, st_name, city, state, zip))\n\n #TRY TO LOCATE WITH GOOGLE\n try:\n \n location = api.geocode(full_address, timeout=10)\n\n lat = location.latitude\n lon = location.longitude\n \n\n info = [lat,lon, listing_number]\n\n array.append(info)\n\n next \n\n #Go to next if you cant locate\n except:\n\n info = [0,0, listing_number]\n\n array.append(info)\n\n next\n\n #CONVERT SERIES TO DATAFRAME\n geo_data = pd.DataFrame(data = array, columns = ['lat', 'lon', 'listing_number'])\n \n #INNER JOIN DATA TO DATAFRAME\n self.df = pd.merge(self.df, geo_data, on= 'listing_number', how = 'inner')","def fill_test_form(data, data_test, fcst, store, dept):\n c = data_test['Store'] == store\n c2 = data_test['Dept'] == dept\n fcst = pd.DataFrame(fcst).rename(columns={0: 'Weekly_Sales'})\n try:\n fcst_for_test = data_test[c&c2].set_index('Date').join(fcst, on='Date', how='left', lsuffix='_0', rsuffix='_1').drop(columns='Weekly_Sales_0').Weekly_Sales_1\n except:\n start = pivot_df(data, dept).index[-1] + relativedelta(weeks=1)\n idx = pd.DatetimeIndex(start=start, periods=len(fcst), freq='W-FRI')\n fcst.index = idx \n fcst_for_test = data_test[c&c2].set_index('Date').join(fcst, on='Date', how='left', lsuffix='_0', rsuffix='_1').drop(columns='Weekly_Sales_0').Weekly_Sales_1\n data_test.loc[c&c2,'Weekly_Sales'] = fcst_for_test.values\n c = np.where(data_test['Weekly_Sales'] > 0)[0]\n return data_test","def improve_population(self):\r\n for index in range(len(self.district_population)):\r\n district = self.district_population[index]\r\n districtsolution = hillclimber.HillClimber(district, self.cable_cost, self.battery_cost)\r\n self.district_population[index] = districtsolution.run(1000, 80000)\r\n self.cost_populations[index] = district.total_cost(self.battery_cost, self.cable_cost)","def weekly_limit(self, weekly_limit):\n\n self._weekly_limit = weekly_limit","def ingest_all(self):\n\t\tfor place in self.district_codes():\n\t\t\tself.sequence_ingest(place)\n\t\tif self.edition:\n\t\t\tconfigs.userconfig.update('PHE','latest_cases',self.edition)","def set_dns_names(self):\n log.info(\"Collecting NetBox IP address objects to set DNS Names.\")\n # Grab all the IPs from NetBox related tagged from the vCenter host\n ip_objs = self.request(\n req_type=\"get\", nb_obj_type=\"ip_addresses\",\n query=\"?tag={}\".format(format_slug(self.vc_tag))\n )[\"results\"]\n log.info(\"Collected %s NetBox IP address objects.\", ip_objs)\n # We take the IP address objects and make a map of relevant details to\n # compare against and use later\n nb_objs = {}\n for obj in ip_objs:\n ip = obj[\"address\"].split(\"/\")[0]\n nb_objs[ip] = {\n \"id\": obj[\"id\"],\n \"dns_name\": obj[\"dns_name\"]\n }\n ips = [ip[\"address\"].split(\"/\")[0] for ip in ip_objs]\n ptrs = queue_dns_lookups(ips)\n # Having collected the IP address objects from NetBox already we can\n # avoid individual checks for updates by comparing the objects and ptrs\n log.info(\"Comparing latest PTR records against existing NetBox data.\")\n for ip, ptr in ptrs:\n if ptr != nb_objs[ip][\"dns_name\"]:\n log.info(\n \"Mismatch! The latest PTR for '%s' is '%s' while NetBox \"\n \"has '%s'. Requesting update.\", ip, ptr,\n nb_objs[ip][\"dns_name\"]\n )\n self.request(\n req_type=\"patch\", nb_obj_type=\"ip_addresses\",\n nb_id=nb_objs[ip][\"id\"], data={\"dns_name\": ptr}\n )\n else:\n log.info(\"NetBox has the latest PTR for '%s'. Moving on.\", ip)","def set_all_pins(self, ap):\n self.allpins = ap","def forc_model(self):\n lag1_loc = self.X[self.model_mask_cols].columns.get_loc('shrink_value_per_day_lag1_by_store')\n lag2_loc = self.X[self.model_mask_cols].columns.get_loc('shrink_value_per_day_lag2_by_store')\n for add in self.X.address1.unique():\n add_mask = self.X.address1 == add\n foo = self.X[ add_mask ].sort_values('visit_date', ascending=False)\n top_index = foo.index[0]\n clust = int(foo.cluster.values[0])\n # get values from last visit for store\n base_input = foo[self.model_mask_cols].values[0]\n base_actual = self.y[top_index]\n lag2_val = base_input[lag1_loc]\n lag1_val = base_actual\n\n for i in range(1, self.num_periods + 1):\n model = self.model_list[clust]\n inputs = base_input\n inputs[lag1_loc] = lag1_val\n inputs[lag2_loc] = lag2_val\n \n pred = model.predict(inputs.reshape(1, -1))\n self._update_cust_table(add, i, pred)\n \n lag2_val = lag1_val\n lag1_val = pred","def update(self):\n self.entries = Entry.objects.filter(contest=self.contest)\n self.lineups = [e.lineup for e in self.entries]\n self.lineup_players = lineup.models.Player.objects.filter(lineup__in=self.lineups)\n\n # add players to the data with an initial count of 1.\n # increment a players count if they already exist\n self.player_counter = Counter([p.player.srid for p in self.lineup_players]).items()","def _test_auto_assign_one_hundred_and_fifty(self):\n shifts = []\n for i in range(150):\n shifts.append(\n RegularWorkshift.objects.create(\n workshift_type=self.wtype1,\n pool=self.p1,\n hours=5,\n )\n )\n for i in range(1, 150):\n User.objects.create_user(username=\"u{0}\".format(i))\n\n utils.make_workshift_pool_hours(semester=self.semester)\n unfinished = utils.auto_assign_shifts(self.semester)\n self.assertEqual([], unfinished)\n for shift in shifts:\n self.assertEqual(1, shift.current_assignees.count())","def addQueryArp(self, num=1):\n self.query_arp += num","def resAlloc(self,band):\n schd = self.schType[0:2]\n if schd=='PF' and len(list(self.ues.keys()))>0:\n exp_num = float(self.schType[2])\n exp_den = float(self.schType[3])\n self.setUEfactor(exp_num, exp_den)\n maxInd = self.findMaxFactor()\n for ue in list(self.ues.keys()):\n if ue == maxInd:\n self.ues[ue].prbs = band\n else:\n self.ues[ue].prbs = 0\n if len(self.ues[ue].pastTbsz)>self.promLen:\n self.ues[ue].pastTbsz.popleft()\n self.ues[ue].pastTbsz.append(self.ues[ue].tbsz)\n self.ues[ue].tbsz = 1\n # Print Resource Allocation\n self.printResAlloc()","def prep_info_all_sites(info_all_sites):\n \n info_all_sites = info_all_sites.copy()\n info_all_sites['GSCNQUAL_max'] = info_all_sites[['GSCNQUAL_ipscore','GSCNQUAL_hipsci_fib']].max(axis =1)\n\n info_filt, filt_all_ind, info_all_sites = info_all_sites.pipe(filter_info, qual_thresh_dup=12, qual_thresh_del=2, qual_thresh_mcnv=14, qual_col = 'GSCNQUAL_max')\n \n \n return info_all_sites, info_filt","def assign_heat_rates_to_projects(generators, year):\n\n fuels = {\n 'LFG':'Bio_Gas',\n 'OBG':'Bio_Gas',\n 'AB':'Bio_Solid',\n 'BLQ':'Bio_Liquid',\n 'NG':'Gas',\n 'OG':'Gas',\n 'PG':'Gas',\n 'DFO':'DistillateFuelOil',\n 'JF':'ResidualFuelOil',\n 'COAL':'Coal',\n 'GEO':'Geothermal',\n 'NUC':'Uranium',\n 'PC':'Coal',\n 'SUN':'Solar',\n 'WDL':'Bio_Liquid',\n 'WDS':'Bio_Solid',\n 'MSW':'Bio_Solid',\n 'PUR':'Purchased_Steam',\n 'WH':'Waste_Heat',\n 'OTH':'Other',\n 'WAT':'Water',\n 'MWH':'Electricity',\n 'WND':'Wind'\n }\n generators = generators.replace({'Energy Source':fuels})\n\n existing_gens = generators[generators['Operational Status']=='Operable']\n print \"-------------------------------------\"\n print \"There are {} existing thermal projects that sum up to {:.1f} GW.\".format(\n len(existing_gens[existing_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]),\n existing_gens[existing_gens['Prime Mover'].isin(['CC','GT','IC','ST'])][\n 'Nameplate Capacity (MW)'].sum()/1000)\n heat_rate_data = pd.read_csv(\n os.path.join('processed_data','historic_heat_rates_WIDE.tab'), sep='\\t').rename(\n columns={'Plant Code':'EIA Plant Code'})\n heat_rate_data = heat_rate_data[heat_rate_data['Year']==year]\n heat_rate_data = heat_rate_data.replace({'Energy Source':fuels})\n thermal_gens = pd.merge(\n existing_gens, heat_rate_data[['EIA Plant Code','Prime Mover','Energy Source','Best Heat Rate']],\n how='left', suffixes=('',''),\n on=['EIA Plant Code','Prime Mover','Energy Source']).drop_duplicates()\n\n thermal_gens = thermal_gens[thermal_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\n\n # Replace null and unrealistic heat rates by average values per technology,\n # fuel, and vintage. Also, set HR of top and bottom .5% to max and min\n null_heat_rates = thermal_gens['Best Heat Rate'].isnull()\n unrealistic_heat_rates = (((thermal_gens['Energy Source'] == 'Coal') &\n (thermal_gens['Best Heat Rate'] < 8.607)) |\n ((thermal_gens['Energy Source'] != 'Coal') &\n (thermal_gens['Best Heat Rate'] < 6.711)))\n print \"{} generators don't have heat rate data specified ({:.1f} GW of capacity)\".format(\n len(thermal_gens[null_heat_rates]), thermal_gens[null_heat_rates]['Nameplate Capacity (MW)'].sum()/1000.0)\n print \"{} generators have better heat rate than the best historical records ({} GW of capacity)\".format(\n len(thermal_gens[unrealistic_heat_rates]), thermal_gens[unrealistic_heat_rates]['Nameplate Capacity (MW)'].sum()/1000.0)\n thermal_gens_w_hr = thermal_gens[~null_heat_rates & ~unrealistic_heat_rates]\n thermal_gens_wo_hr = thermal_gens[null_heat_rates | unrealistic_heat_rates]\n\n # Print fuels and technologies with missing HR to console\n\n # for fuel in thermal_gens_wo_hr['Energy Source'].unique():\n # print \"{} of these use {} as their fuel\".format(\n # len(thermal_gens_wo_hr[thermal_gens_wo_hr['Energy Source']==fuel]),fuel)\n # print \"Technologies:\"\n # for prime_mover in thermal_gens_wo_hr[thermal_gens_wo_hr['Energy Source']==fuel]['Prime Mover'].unique():\n # print \"\\t{} use {}\".format(\n # len(thermal_gens_wo_hr[(thermal_gens_wo_hr['Energy Source']==fuel) &\n # (thermal_gens_wo_hr['Prime Mover']==prime_mover)]),prime_mover)\n \n print \"-------------------------------------\"\n print \"Assigning max/min heat rates per technology and fuel to top .5% / bottom .5%, respectively:\"\n n_outliers = int(len(thermal_gens_w_hr)*0.008)\n thermal_gens_w_hr = thermal_gens_w_hr.sort_values('Best Heat Rate')\n min_hr = thermal_gens_w_hr.loc[thermal_gens_w_hr.index[n_outliers],'Best Heat Rate']\n max_hr = thermal_gens_w_hr.loc[thermal_gens_w_hr.index[-1-n_outliers],'Best Heat Rate']\n print \"(Total capacity of these plants is {:.1f} GW)\".format(\n thermal_gens_w_hr[thermal_gens_w_hr['Best Heat Rate'] < min_hr]['Nameplate Capacity (MW)'].sum()/1000.0 +\n thermal_gens_w_hr[thermal_gens_w_hr['Best Heat Rate'] > max_hr]['Nameplate Capacity (MW)'].sum()/1000.0)\n print \"Minimum heat rate is {:.3f}\".format(min_hr)\n print \"Maximum heat rate is {:.3f}\".format(max_hr)\n for i in range(n_outliers):\n thermal_gens_w_hr.loc[thermal_gens_w_hr.index[i],'Best Heat Rate'] = min_hr\n thermal_gens_w_hr.loc[thermal_gens_w_hr.index[-1-i],'Best Heat Rate'] = max_hr\n\n\n def calculate_avg_heat_rate(thermal_gens_df, prime_mover, energy_source, vintage, window=2):\n similar_generators = thermal_gens_df[\n (thermal_gens_df['Prime Mover']==prime_mover) &\n (thermal_gens_df['Energy Source']==energy_source) &\n (thermal_gens_df['Operating Year']>=vintage-window) &\n (thermal_gens_df['Operating Year']<=vintage+window)]\n while len(similar_generators) < 4:\n window += 2\n similar_generators = thermal_gens_df[\n (thermal_gens_df['Prime Mover']==prime_mover) &\n (thermal_gens_df['Energy Source']==energy_source) &\n (thermal_gens_df['Operating Year']>=vintage-window) &\n (thermal_gens_df['Operating Year']<=vintage+window)]\n # Gens span from 1925 to 2015, so a window of 90 years is the maximum\n if window >= 90:\n break\n if len(similar_generators) > 0:\n return similar_generators['Best Heat Rate'].mean()\n else:\n # If no other similar projects exist, return average of technology\n return thermal_gens_df[thermal_gens_df['Prime Mover']==prime_mover]['Best Heat Rate'].mean()\n\n\n print \"-------------------------------------\"\n print \"Assigning average heat rates per technology, fuel, and vintage to projects w/o heat rate...\"\n for idx in thermal_gens_wo_hr.index:\n pm = thermal_gens_wo_hr.loc[idx,'Prime Mover']\n es = thermal_gens_wo_hr.loc[idx,'Energy Source']\n v = thermal_gens_wo_hr.loc[idx,'Operating Year']\n #print \"{}\\t{}\\t{}\\t{}\".format(pm,es,v,calculate_avg_heat_rate(thermal_gens_w_hr, pm, es, v))\n thermal_gens_wo_hr.loc[idx,'Best Heat Rate'] = calculate_avg_heat_rate(\n thermal_gens_w_hr, pm, es, v)\n\n thermal_gens = pd.concat([thermal_gens_w_hr, thermal_gens_wo_hr], axis=0)\n existing_gens = pd.merge(existing_gens, thermal_gens, on=list(existing_gens.columns), how='left')\n\n\n # Plot histograms for resulting heat rates per technology and fuel\n thermal_gens[\"Technology\"] = thermal_gens[\"Energy Source\"].map(str) + ' ' + thermal_gens[\"Prime Mover\"]\n p = ggplot(aes(x='Best Heat Rate',fill='Technology'), data=thermal_gens) + geom_histogram(binwidth=0.5) + facet_wrap(\"Technology\") + ylim(0,30)\n p.save(os.path.join(outputs_directory,'heat_rate_distributions.pdf'))\n\n proposed_gens = generators[generators['Operational Status']=='Proposed']\n thermal_proposed_gens = proposed_gens[proposed_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\n other_proposed_gens = proposed_gens[~proposed_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\n print \"There are {} proposed thermal projects that sum up to {:.2f} GW.\".format(\n len(thermal_proposed_gens), thermal_proposed_gens['Nameplate Capacity (MW)'].sum()/1000)\n print \"Assigning average heat rate of technology and fuel of most recent years...\"\n for idx in thermal_proposed_gens.index:\n pm = thermal_proposed_gens.loc[idx,'Prime Mover']\n es = thermal_proposed_gens.loc[idx,'Energy Source']\n #print \"{}\\t{}\\t{}\\t{}\".format(pm,es,v,calculate_avg_heat_rate(thermal_gens_w_hr, pm, es, v))\n thermal_proposed_gens.loc[idx,'Best Heat Rate'] = calculate_avg_heat_rate(\n thermal_gens_w_hr, pm, es, year)\n\n other_proposed_gens['Best Heat Rate'] = float('nan')\n proposed_gens = pd.concat([thermal_proposed_gens,other_proposed_gens], axis=0)\n\n return pd.concat([existing_gens, proposed_gens], axis=0)","def __add_homes(self):\n for home in self.__positions_of_homes:\n self.__grid[home[0]][home[1]][\"humans\"] = math.floor(\n self.__number_of_humans / self.__number_of_homes\n )","def pagerank(self, limit=20):\r\n\t\tfor urlid in self.url_ids:\r\n\t\t\tself.all_scores[urlid] = 1.0\r\n\r\n\t\tfor i in range(limit):\r\n\t\t\tfor urlid in self.url_ids:\r\n\t\t\t\tscore = self.all_scores[urlid]\r\n\t\t\t\tfor fromid in self.from_ids[urlid]:\r\n\t\t\t\t\tscore += self.all_scores[fromid] / \\\r\n\t\t\t\t\t\t\t (len(self.from_ids[fromid])+len(self.to_ids[fromid]))\r\n\t\t\t\tscore *= 0.85\r\n\t\t\t\tscore += 0.15\r\n\t\t\t\tself.all_scores[urlid] = score\r\n\t\tself.save_pr()","def load_street_address(data):\n street_addresses = [address['address1'] for address in data]\n street_address_objects = [StreetAddress(data=street_address)\n for street_address\n in street_addresses]\n StreetAddress.objects.bulk_create(street_address_objects)","def update_reported_taps(taps):\n store_formula_list(formula_list=taps, file_path=REPORTED_TAPS_FILE)","def process(self):\n\t\tif self.update_check() or self.force_update:\n\t\t\tself.district_check() #pull all local data and regions\n\t\t\tself.fix() #fix data anomalies - e.g add in Bucks.\n\t\t\tself.save_all() #store a copy of the data\n\t\t\tself.ingest() #add data to models\n\t\t\tself.update_totals() #calculate weekly data\n\t\telse:\n\t\t\tlog.info('PHE cases up to date')","def prepare_company_data(self, month, year, row, company_data):\n for key, value in row.items():\n if not company_data[key]:\n company_data[key] = {'year':year, 'month':month, 'value':value}\n else:\n \"\"\"main operation updating the company's data per year\n and month vise \"\"\"\n company_data[key].update({'year':year, 'month':month, 'value':value})\\\n if company_data[key]['value'] < value else None","def optimize_on_n_cops(self):\n self.optimize_on_target_profiles()\n max_revenue = -INF\n while self.get_revenue_per_hour() >= max_revenue:\n max_revenue = self.get_revenue_per_hour()\n prev_target_profiles = self.target_profiles\n self.cops += 1\n self.optimize_on_target_profiles()\n self.cops -= 1\n self.target_profiles = prev_target_profiles\n self.target_profile = reduce(lambda x, y: x + y, self.target_profiles)","def optimize_best(self, population, evo_num):\n evo_at_least = settings[\"phone_optimize\"][\"evo_at_least\"]\n evo_frequency = settings[\"phone_optimize\"][\"evo_frequency\"]\n if((evo_num >= evo_at_least) and (evo_num % evo_frequency == 0)):\n self.population = self.phone_opt.run_genetic(self.population,0)# call main function in PhoneOptimize once ready.\n map(lambda c: c.set_results(None), population)\n return population","def _test_pre_fill_and_assign_humor(self):\n for i in range(1, 50):\n User.objects.create_user(username=\"u{0}\".format(i))\n pre_fill.main([\"--managers\", \"--workshift\"])\n utils.make_workshift_pool_hours(semester=self.semester)\n # Assign manager shifts beforehand\n manager_shifts = RegularWorkshift.objects.filter(\n pool=self.p1, workshift_type__auto_assign=False,\n )\n profiles = WorkshiftProfile.objects.all()\n for profile, shift in zip(profiles, manager_shifts):\n shift.current_assignees.add(profile)\n shift.save()\n unfinished = utils.auto_assign_shifts(\n self.semester, pool=WorkshiftPool.objects.get(title=\"Humor Shift\")\n )\n self.assertEqual([], unfinished)","def _load_preps(self, context: 'IconScoreContext'):\n icx_storage: 'IcxStorage' = context.storage.icx\n\n for prep in context.storage.prep.get_prep_iterator():\n account: 'Account' = icx_storage.get_account(context, prep.address, Intent.ALL)\n\n prep.stake = account.stake\n prep.delegated = account.delegated_amount\n\n self.preps.add(prep)\n\n self.preps.freeze()","def planned(self, planned):\n\n self._planned = planned","def setUp(self):\n N = 10\n pA = 0.5\n pB = 0.5\n qA = 1 - pA\n qB = 1 - pB\n locus_A = (['A'] * int(N * pA)) + (['a'] * int(round(N * qA)))\n locus_B = (['B'] * int(N * pB)) + (['b'] * int(round(N * qB)))\n self.pop = population.Population(N, locus_A, locus_B)","def array_update(self, table_list):\r\n for tbl in table_list:\r\n x = kit.SQL_pull('name, subject_id', tbl)\r\n r = {i[0]: i[1] for i in x}\r\n h = {i[1]: tbl for i in x}\r\n \r\n self.refference.update(r)\r\n self.home_table.update(h)\r\n \r\n self.counts[tbl] = len(x)","def test_place(self):\n places = self.geographies.find({ 'geoid': '1562600' })\n\n self.assertEqual(places.count(), 1)\n\n place = places[0]\n\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\n self.assertEqual(place['metadata']['STATE'], '15')\n self.assertEqual(place['metadata']['PLACE'], '62600')\n\n pop_2000 = 30976\n pop_2010 = 47698 \n self._test_totalpop(place, pop_2000, pop_2010)","def adjust(loanbook):\n\n # get names of AG8 columns\n ag8_cols = [x for x in loanbook.columns if 'adjust' in x.lower()]\n\n # remove NaN values from AG8 columns\n for col in ag8_cols:\n loanbook[col] = pd.Series(loanbook[col].fillna(0),\n index=loanbook.index)\n\n return loanbook","def SetPRBinConstraint(self, model ) :\n tot = np.multiply(self.wish, self.dispo)\n for val in tot :\n if not val : continue\n if self.bound>0 : model += val <= self.valBound\n elif self.bound<0 : model += val >= self.valBound","def prepare(self, popSize, evaluate):\n for i in range(popSize):\n member = Member(self.memberLength, self.lowerDomain, self.upperDomain, self.memberDataType)\n member.loss = evaluate(member.rep)\n self.population.append(member)\n if (self.eliteLoss is None) or (self.eliteLoss > member.loss):\n self.eliteLoss = member.loss\n self.eliteIndex = i\n elif (self.diversityLoss is None) or (self.diversityLoss < member.loss):\n self.diversityLoss = member.loss\n self.diversityIndex = i","def __data_set_is_payday_positive_08_09_10(cls):\n _pay_cycle_object = pay_cycle_object()\n date_to_check = date_class(2020,1,10)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\n\n date_to_check = date_class(2020,1,24)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\n\n date_to_check = date_class(2022,10,14)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))","def run_past_matches(self):\n for year in self.store.years:\n # print(year)\n for event in self.store.events[year]:\n for match in self.store.matches[year][event.key]:\n red_alliance = match.red_alliance\n blue_alliance = match.blue_alliance\n\n for team in red_alliance + blue_alliance:\n if team not in self.scores.keys():\n self.scores[team] = self.default_score\n\n prediction = self.predict(red_alliance, blue_alliance, key=match.key)\n self.update_score(red_alliance, blue_alliance, prediction,\n match.red_score, match.blue_score)","def __data_set_is_payday_positive_05_06_07(cls):\n _pay_cycle_object = pay_cycle_object()\n date_to_check = date_class(2019,11,1)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\n\n date_to_check = date_class(2019,11,29)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\n\n date_to_check = date_class(2019,12,13)\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))","def check_point_update(self):\n self.cp_count += 1\n\n if len(self.cases) > self.nyquist:\n \"\"\"\n Recalculates nyquist, releases cases and updates model (merges graphs)\n \"\"\"\n self.release_cases_from_memory()\n if self.check_point_cases > 5:\n self.nyquist = self.check_point_cases * 2\n\n check_point_graph = initialize_graph(nx.DiGraph(), self.cases)\n self.process_model_graph = merge_graphs(self.process_model_graph, check_point_graph)\n\n self.check_point_cases = 0","def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\n addr = address.lower()\n balances = self.addresses[addr] if addr in self.addresses else []\n balances.append({\n 'USDC': value_USDC,\n 'eXRD': value_eXRD,\n 'LP': value_LP\n })\n self.addresses[addr] = balances","def set_penalty_start_eventnums(self):\n for period in self.Periods:\n period.PenaltyStartEventNums = {self.HomeTeamId: None, self.VisitorTeamId: None}\n if period.Number <= 4:\n fouls_to_give = {self.HomeTeamId: 4, self.VisitorTeamId: 4}\n else:\n # in overtime periods teams start with 3 fouls to give\n fouls_to_give = {self.HomeTeamId: 3, self.VisitorTeamId: 3}\n\n for event in period.Events:\n if event.is_foul_that_counts_toward_penalty():\n foul_team = event.team_id\n event_time = event.seconds_remaining\n if event_time <= 120 and fouls_to_give[foul_team] > 1:\n # only 1 foul to give in final 2 minutes regardless of how many fouls committed up until then\n fouls_to_give[foul_team] = 1\n if fouls_to_give[foul_team] > 0:\n fouls_to_give[foul_team] -= 1\n if fouls_to_give[foul_team] == 0:\n # team entered penalty on this foul\n if 'Shooting' in event.get_foul_type():\n # shooting foul - start tracking at final ft so we don't count FTs as penalty\n final_fts_at_time_of_foul = [\n pbp_event for pbp_event in period.Events\n if pbp_event.seconds_remaining == event_time and\n pbp_event.team_id != foul_team and\n (pbp_event.is_ft_1_of_1() or pbp_event.is_ft_2_of_2() or pbp_event.is_ft_3_of_3())\n ]\n if len(final_fts_at_time_of_foul) == 0:\n # Example of when this happens: lane violation\n # just use last event that occured at time of foul\n events_at_time_of_foul = [\n pbp_event for pbp_event in period.Events\n if pbp_event.seconds_remaining == event_time\n ]\n start_event = events_at_time_of_foul[-1].order\n elif final_fts_at_time_of_foul[-1].is_missed_ft():\n # if FT is missed need to see if it was oreb or dreb\n rebounds_after_ft = [\n pbp_event for pbp_event in period.Events\n if pbp_event.order > event.order and\n pbp_event.is_rebound()\n ]\n # use first rebound after missed FT as bonus start event\n start_event = rebounds_after_ft[0].order\n else:\n # use last FT as bonus start event\n start_event = final_fts_at_time_of_foul[-1].order\n else:\n # non shooting foul - start tracking bonus at this event\n start_event = event.order\n offense_team = utils.swap_team_id_for_game(foul_team, [self.HomeTeamId, self.VisitorTeamId])\n period.PenaltyStartEventNums[offense_team] = start_event","def insert_humans_staging(self):\n for year in range(1880, CURRENT_YEAR):\n self.load_wikidata(\"humans\", HUMANS_BY_YEAR_SPARQL_QUERY, INSERT_HUMAN_SQL_QUERY,\n INSERT_HUMAN_MAP_COLUMNS, year=year)","def test_ipam_vlans_update(self):\n pass","def main(self):\n results = []\n for t in Config.APPHOSTS:\n custom_domain = t[\"custom_domain\"]\n heroku_host = t[\"heroku_host\"]\n result = self.ip_update(custom_domain, heroku_host)\n results.append(result)\n return results"],"string":"[\n \"def _set_top_preps(self) -> None :\\n prep_dict = self._system.getPReps(1, 20)\\n prep_address_list = prep_dict['preps']\\n for each_prep in prep_address_list:\\n self._top_preps.put(each_prep['address'])\",\n \"def update_weekly_total(areacode=AREACODE,areaname=AREA):\\n start,stop=model_calcs.RANGE_WEEK\\n log.debug(f'Processing {areaname}')\\n for week in range(start,stop+1):\\n end_day=ons_week.week(week)\\n \\n week_total=weekly_total(end_day,areacode=areacode,areaname=areaname)\\n #print(f'{areaname}: Weektotal for week number {week} ending {end_day}: {week_total}')\\n \\n if week_total is not None:\\n try:\\n stored,created=CovidWeek.objects.get_or_create(areacode=areacode,week=week)\\n #print(stored.weeklycases)\\n if stored.weeklycases != week_total:\\n log.debug(f'{areaname}: updating week {week} from {stored.weeklycases} to {week_total}')\\n stored.weeklycases=week_total\\n stored.areaname=areaname\\n stored.save()\\n if created:\\n stored.nation=ons_week.nation[areacode]\\n stored.areaname=areaname\\n log.debug(f'Created new entry for week {week} for {areaname}')\\n stored.week=week\\n stored.save()\\n except Exception as e:\\n log.error(e)\\n log.error(f'No data stored for {areaname} week {week}')\\n else:\\n log.error(f'Bypassing {areaname} - no data')\",\n \"def update_take_x_ip_requests(limit):\\n global ip_report\\n\\n for remote_host, record in ip_report.items():\\n ip_report[remote_host]['requests'] = {k: ip_report[remote_host]['requests'][k] for k in list(ip_report[remote_host]['requests'])[:limit]}\",\n \"def _set_addresses(self):\\n if self._report_key in (ReportTypes.SEARCH_DETAIL_REPORT, ReportTypes.SEARCH_BODY_REPORT) and \\\\\\n self._report_data['totalResultsSize'] > 0:\\n self._set_search_addresses()\\n elif self._report_key in (ReportTypes.MHR_REGISTRATION, ReportTypes.MHR_TRANSFER,\\n ReportTypes.MHR_EXEMPTION, ReportTypes.MHR_TRANSPORT_PERMIT, ReportTypes.MHR_NOTE):\\n self._set_registration_addresses()\",\n \"def populate(self):\\n\\n NUM_COUNTRIES = 2 # random.randint(1, 4)\\n\\n # find a suitable hex\\n with Timer(\\\"Creating initial data\\\", debug=self.debug):\\n\\n for i in range(NUM_COUNTRIES):\\n country, provinces, pops = create_country(self, self.map)\\n country.determine_tax_policy()\\n self.countries.append(country)\",\n \"def assignNurses(solution, hini, data):\\n\\n demand = data[\\\"demand\\\"]\\n pending = solution[\\\"pending\\\"]\\n hours = data[\\\"hours\\\"]\\n sumW = [0] * data[\\\"nNurses\\\"]\\n\\n\\n checkers = initCheckers(data)\\n\\n z = solution[\\\"z\\\"]\\n w = solution[\\\"w\\\"]\\n\\n\\n for h in range(hours):\\n\\n #print(\\\" for loop h=\\\"+str(h))\\n\\n solution[\\\"mustWork_count\\\"] = 0\\n \\n mustWork, canWork = computeAssignments(solution, h, data, checkers=checkers, sumW=sumW )\\n\\n # print(\\\"h=\\\" + str(h))\\n # print(\\\"mustWork\\\")\\n # print(mustWork)\\n # print(\\\"canWork\\\")\\n # print(canWork)\\n # print(\\\"hini:\\\")\\n # print(hini)\\n # print(\\\"demand\\\")\\n # print(data[\\\"demand\\\"])\\n # print(\\\"pending\\\")\\n # print(solution[\\\"pending\\\"])\\n\\n\\n \\n # try to assign if pending[h] > 0 and h >= hini[n]\\n for n in mustWork:\\n # print(\\\"nurse :\\\" + str(n) + \\\" h: \\\" + str(h) + \\\" pending: \\\")\\n # print(pending)\\n update_checkers(solution, data, n, h, 1,checkers)\\n w[n][h] = 1\\n sumW[n] += 1\\n pending[h] -= 1\\n if z[n] == 0:\\n z[n] = 1\\n solution[\\\"cost\\\"] += 1\\n \\n #print(\\\"w[\\\" + str(n) + \\\",\\\" + str(h) + \\\"] = 1\\\")\\n # pp.pprint(solution[\\\"w\\\"])\\n\\n for n in canWork:\\n\\n # print(\\\"nurse :\\\" + str(n) + \\\" h: \\\" + str(h) + \\\" pending: \\\")\\n # print(pending)\\n if pending[h] + hini[h] > 0:\\n update_checkers(solution, data, n, h, 1,checkers) \\n w[n][h] = 1\\n sumW[n] += 1\\n pending[h] -= 1\\n if z[n] == 0:\\n z[n] = 1\\n solution[\\\"cost\\\"] += 1\\n \\n #print(\\\"w[\\\" + str(n) + \\\",\\\" + str(h) + \\\"] = 1\\\")\\n # print(\\\"w[\\\" + str(n) + \\\"]\\\")\\n # pp.pprint(solution[\\\"w\\\"]) \\n\\n # pp.pprint(data)\\n # pp.pprint(solution[\\\"cost\\\"])\\n # print(\\\"\\\")\\n\\n # compute feasibility: if unfeasible -> fitness should be inf\\n if not isFeasible(solution, data):\\n # assign the max cost\\n #solution[\\\"cost\\\"] = 200000 * data[\\\"nNurses\\\"]\\n solution[\\\"cost\\\"] = 100 * solution[\\\"cost\\\"]\\n # print(data[\\\"demand\\\"])\\n # print(solution[\\\"pending\\\"])\\n # print(\\\"\\\")\",\n \"def Process_address(self):\\n\\n self.data = np.load(self.cache_path, allow_pickle=True)[()]\\n\\n ID = self.data.keys()\\n\\n cnt = 0\\n for id in tqdm(ID):\\n if not 'address' in self.data[id] and 'post' in self.data[id]:\\n self.data[id]['address'] = ''\\n self.data[id]['location'] = ''\\n Q = self.Query_baidu(self.data[id]['post'])\\n self.data[id]['address'] = Q['address']\\n self.data[id]['location'] = Q['location']\\n cnt += 1\\n\\n print(\\\"Query %d info\\\" % cnt)\\n\\n np.save(self.cache_path, self.data)\",\n \"def placement_fix():\\r\\n def func(place):\\r\\n if place in ['3', '4']:\\r\\n return '3-4'\\r\\n elif place in ['5', '6', '7', '8']:\\r\\n return '5-8'\\r\\n else:\\r\\n return place\\r\\n \\r\\n for place in decks_coll.find({}):\\r\\n record_id = place['_id']\\r\\n decks_coll.update_one({'_id': record_id}, {'$set': {'placement': func(place['placement'])}})\",\n \"def populate_homes(self, breakdown):\\n #check!#\\n\\n ###your code here###\\n tot=self.nx*self.ny\\n for n in range(len(breakdown)):\\n breakdown[n]=int(round(tot*breakdown[n]))\\n for i in range(breakdown[n]):\\n new_home=self.empty_homes.pop(random.randrange(len(self.empty_homes)))\\n home_address=(new_home.x,new_home.y)\\n x=Person(group=n,home=self.homes[home_address])\\n self.homes[home_address].occupant=x\\n self.people.append(x)\",\n \"def build_addresses(self):\\n \\n from ambry.geo.geocoders import DstkGeocoder\\n\\n facilities = self.partitions.find(table='facilities')\\n\\n def address_gen():\\n for row in facilities.query(\\\"SELECT * FROM facilities\\\"):\\n address = \\\"{}, {}, {} {}\\\".format(row['dba_address1'], row['dba_city'], 'CA', row['dba_zip_code'])\\n yield (address, row)\\n\\n dstk_service = self.config.service('dstk')\\n \\n dstk_gc = DstkGeocoder(dstk_service, address_gen())\\n \\n p = self.partitions.find_or_new(table='facilities_addresses')\\n p.clean()\\n \\n lr = self.init_log_rate(500)\\n \\n with p.inserter() as ins:\\n for i, (k, r, inp_row) in enumerate(dstk_gc.geocode()):\\n lr(\\\"Addresses \\\"+str(i))\\n r['facilities_id'] = inp_row['id']\\n ins.insert(r)\",\n \"def ingest(self,check=True):\\n\\t\\tdata=self.data_all\\n\\t\\tpubdate=time_utils.parseISO(self.api.last_update).date()\\n\\t\\t\\n\\t\\tcounter=0\\n\\t\\tfor item in data:\\n\\t\\t\\tareacode=item['areaCode']\\n\\t\\t\\tdatestring=item['specimenDate']\\n\\t\\t\\t_date=fetchdate(datestring)\\n\\t\\t\\trow,created=DailyCases.objects.get_or_create(specimenDate=_date,areacode=areacode)\\n\\t\\t\\trow.areaname=item['areaName']\\n\\t\\t\\tdaily=item['newCasesBySpecimenDate']\\n\\t\\t\\ttotal=item['cumCasesBySpecimenDate']\\n\\t\\t\\t\\n\\t\\t\\t#log.debug(f'{row.areaname}: {datestring}')\\t\\t\\t\\n\\t\\t\\tif created:\\n\\t\\t\\t\\trow.dailyLabConfirmedCases=daily\\n\\t\\t\\t\\trow.totalLabConfirmedCases=total\\n\\t\\t\\t\\trow.save()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif daily:\\n\\t\\t\\t\\t\\tlag=(pubdate-_date.date()).days\\n\\t\\t\\t\\t\\tlog.debug(f'date:{_date} lag: {lag} daily:{daily}')\\n\\t\\t\\t\\t\\tdrow,dcreated=DailyReport.objects.get_or_create(specimenDate=_date,areacode=areacode,publag=lag)\\n\\t\\t\\t\\t\\tdrow.dailycases=daily\\n\\t\\t\\t\\t\\tdrow.add_cases=daily #if a new daily case, assume no prior report\\n\\t\\t\\t\\t\\tdrow.save()\\n\\t\\t\\t\\n\\t\\t\\tif not created:\\n\\t\\t\\t\\texisting_daily=row.dailyLabConfirmedCases\\n\\t\\t\\t\\texisting_total=row.totalLabConfirmedCases\\n\\t\\t\\t\\tif daily is not None:\\n\\t\\t\\t\\t\\tif existing_daily !=daily or existing_total!=total:\\n\\t\\t\\t\\t\\t\\trow.dailyLabConfirmedCases=daily\\n\\t\\t\\t\\t\\t\\trow.totalLabConfirmedCases=total\\n\\t\\t\\t\\t\\t\\trow.save()\\n\\t\\t\\t\\t\\t\\tif existing_daily !=daily:\\n\\t\\t\\t\\t\\t\\t\\tlog.debug(f'Updating {row.areaname} on {datestring}: Daily: {existing_daily} to {daily} Total: {existing_total} to {total}')\\n\\t\\t\\t\\t\\t\\t\\tif existing_daily:\\n\\t\\t\\t\\t\\t\\t\\t\\t_increase=daily-existing_daily\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t_increase=daily\\n\\t\\t\\t\\t\\t\\t\\tlag=(pubdate-_date.date()).days\\n\\t\\t\\t\\t\\t\\t\\tdrow,dcreated=DailyReport.objects.get_or_create(specimenDate=_date,areacode=areacode,publag=lag)\\n\\t\\t\\t\\t\\t\\t\\tdrow.dailycases=daily\\n\\t\\t\\t\\t\\t\\t\\tdrow.add_cases=_increase\\n\\t\\t\\t\\t\\t\\t\\tdrow.save()\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tcounter+=1\\n\\t\\t\\tif counter%1000==0:\\n\\t\\t\\t\\tlog.info(f'Processing row {counter}')\\n\\t\\tlog.info(f'Processed: {counter} rows')\\n\\n\\t\\tif self.edition:\\n\\t\\t\\tconfigs.userconfig.update('PHE','latest_update',self.edition)\\n\\t\\telse:\\n\\t\\t\\tlog.info('Latest update not updated')\",\n \"def update_historical_data():\\n print('updating historical data')\\n for sp in SupplyPoint.objects.filter(supplypointwarehouserecord__isnull=True).exclude(type__code=SupplyPointCodes.ZONE):\\n update_historical_data_for_supply_point(sp)\",\n \"def create_address_data():\\r\\n print(\\\"Reading address data file\\\")\\r\\n addresses = pd.read_csv(raw_loc + 'san_francisco_addresses.csv')\\r\\n addresses.columns = map(str.lower, addresses.columns)\\r\\n\\r\\n keepcolumns = ['lon', 'lat', 'number', 'street']\\r\\n addresses = addresses[keepcolumns]\\r\\n addresses['number'] = addresses['number'].apply(lambda x: re.findall( '\\\\d+', x)[0]).astype(int)\\r\\n addresses['address'] = addresses.apply(lambda x: str(x['number']) + \\\" \\\" + str(x['street']), axis = 1)\\r\\n addresses['streetname'] = addresses['street'].apply(return_street)\\r\\n addresses.drop_duplicates(subset = 'address', inplace = True)\\r\\n addresses['type'] = 'known'\\r\\n addresses.to_sql('raw_address_data', if_exists = 'replace', con = conn)\\r\\n\\r\\n\\r\\n print(\\\"Finding similar addresses\\\")\\r\\n df = pd.read_sql_query('Select distinct tickstreetno , tickstreetname , count(*) total_tickets from raw_ticket_data t1'\\r\\n ' left join raw_address_data t2 on t1.TickStreetNo = t2.number and t1.TickStreetName = t2.streetname '\\r\\n \\\" where t2.address is null group by tickstreetno, tickstreetname \\\", conn)\\r\\n\\r\\n df['TickStreetNo'] = df['TickStreetNo'].apply(return_num)\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(replace_street)\\r\\n df['TickStreetName'] = df['TickStreetName'].apply(return_street)\\r\\n df['blocknum'] = df['TickStreetNo'].apply(lambda x: math.ceil(x/100))\\r\\n df.drop_duplicates(inplace = True)\\r\\n\\r\\n df2 = addresses\\r\\n df2['blocknum'] = df2['number'].apply(lambda x: math.ceil(x/100))\\r\\n newdf = df.merge(df2, how = 'left', left_on = ['TickStreetName', 'blocknum'], \\\\\\r\\n right_on = ['streetname', 'blocknum'])\\r\\n\\r\\n\\r\\n unfound = newdf[pd.isnull(newdf.number)]\\r\\n unfound['type'] == \\\"unknown\\\"\\r\\n newdf = newdf[pd.isnull(newdf.number) == False]\\r\\n newdf['delta'] = np.abs(newdf['number'] - newdf['TickStreetNo'])\\r\\n newdf.sort_values(by = 'delta', inplace = True)\\r\\n newdf.drop_duplicates(subset = ['TickStreetName', 'TickStreetNo'], keep = 'first', inplace = True)\\r\\n\\r\\n newdf = newdf[[ 'lon', 'lat', 'TickStreetNo', 'street', 'address','streetname' ]]\\r\\n newdf.columns = ['lon', 'lat', 'number', 'street', 'address','streetname' ]\\r\\n newdf['address'] = newdf['number'].map(str) + ' ' + newdf['street']\\r\\n newdf.drop_duplicates(inplace = True)\\r\\n newdf['type'] = 'similar'\\r\\n newdf.to_sql('raw_address_data', conn, if_exists = 'append')\\r\\n unfound = unfound[unfound.TickStreetNo < 10000]\\r\\n\\r\\n\\r\\n print(\\\"Searching for Intersection Addresses\\\")\\r\\n #unfound = unfound[(unfound.TickStreetNo < 10000) & (unfound.TickStreetNo > 0)]\\r\\n isection = unfound[['TickStreetNo','TickStreetName', 'total_tickets']]\\r\\n isection['address'] = isection['TickStreetName'].apply(return_intersections)\\r\\n unfound = isection[pd.isnull(isection.address) == True]\\r\\n isection = isection[pd.isnull(isection.address) == False]\\r\\n isection = isection.merge(addresses, left_on = 'address', right_on = 'address')\\r\\n isection = isection[['number', 'streetname', 'street', 'address', 'lat', 'lon']]\\r\\n isection.to_sql('raw_address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n\\r\\n print(\\\"Searching for Unknown Addresses\\\")\\r\\n unfound.drop_duplicates(inplace = True)\\r\\n tqdm.pandas()\\r\\n unfound['street'] = unfound.apply(lambda x: return_streetname_unknown(x['TickStreetNo'], x['TickStreetName']), axis = 1)\\r\\n unfound['address'] = unfound.apply(lambda x: str(x['TickStreetNo']) + \\\" \\\" + str(x['street']), axis = 1)\\r\\n numlookup = 5000\\r\\n print(\\\"There are \\\" + str(unfound.shape[0]) + \\\" addresses we couldn't find, we're goin to lookup \\\" + str(numlookup))\\r\\n lookup = unfound.sort_values(by = 'total_tickets', ascending = False)[:numlookup] #CHANGE TO 5000\\r\\n lookup['coordinates'] = lookup['address'].progress_apply(lambda x: create_locs(x + ' SAN FRANCISCO CA'))\\r\\n lookup.dropna(subset = ['coordinates'], inplace = True)\\r\\n lookup['lat'] = lookup['coordinates'].apply(lambda x: x[0])\\r\\n lookup['lon'] = lookup['coordinates'].apply(lambda x: x[1])\\r\\n lookup.rename(columns = {'TickStreetNo':'number', 'TickStreetName':'streetname'}, inplace = True)\\r\\n lookup = lookup[['lat', 'lon', 'street', 'number', 'streetname', 'address']]\\r\\n unfound = unfound[unfound['address'].isin(lookup['address']) == False]\\r\\n unfound['type'] = 'unfound'\\r\\n lookup['type'] = 'searched'\\r\\n lookup.to_sql('raw_address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n print(\\\"associating neighborhoods\\\")\\r\\n addresses = pd.read_sql_query('Select * from raw_address_data', conn)\\r\\n addresses['geometry'] = addresses.apply(lambda x: Point(x['lon'], x['lat']), axis = 1)\\r\\n point = gpd.GeoDataFrame(addresses['geometry'])\\r\\n point.crs = {'init': 'epsg:4326'}\\r\\n poly = gpd.GeoDataFrame.from_file(raw_loc+ 'AnalysisNeighborhoods.geojson')\\r\\n pointInPolys = gpd.tools.sjoin(point, poly, how='left')\\r\\n addresses['geometry'] = addresses['geometry'].astype(str)\\r\\n pointInPolys['geometry'] = pointInPolys['geometry'].astype(str)\\r\\n addresses = addresses.merge(pointInPolys, left_on = 'geometry', right_on = 'geometry')\\r\\n addresses.drop(columns = ['geometry', 'index', 'index_right'], inplace = True)\\r\\n addresses.drop_duplicates(subset = 'address', inplace = True)\\r\\n addresses['number'] = addresses['number'].astype(int)\\r\\n addresses.to_sql('address_data', conn, if_exists = 'replace')\\r\\n\\r\\n\\r\\n unfound.rename(columns = {'TickStreetNo':'number', 'TickStreetName': 'streetname'}, inplace = True)\\r\\n unfound.drop(columns = 'total_tickets', inplace = True)\\r\\n unfound['number'] = unfound['number'].astype(int)\\r\\n unfound.to_sql('address_data', if_exists = 'append', con = conn)\\r\\n\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"Function is to separate addresses into those that may have have more than one address associated with a ticket and street name combo. \\\"\\\"\\\"\\r\\n grouped = addresses.groupby(by = ['number', 'streetname'], as_index = False)['address'].agg('count')\\r\\n grouped.sort_values(by = 'address', ascending = False)\\r\\n grouped.columns = ['number', 'streetname', 'count_ad']\\r\\n single_address = grouped[grouped.count_ad ==1]\\r\\n single_address = single_address.merge(addresses, left_on = ['number', 'streetname'], right_on = ['number', 'streetname'])\\r\\n double_address = addresses[addresses.address.isin(single_address['address']) == False]\\r\\n single_address.to_sql('single_address', conn, if_exists = 'replace')\\r\\n\\r\\n return single_address, double_address, addresses\",\n \"def test_ipam_ip_addresses_update(self):\\n pass\",\n \"def test_pre_fill_and_assign(self):\\n users = []\\n for i in range(1, 50):\\n users.append(User.objects.create_user(username=\\\"u{0}\\\".format(i)))\\n pre_fill.main([\\\"--managers\\\", \\\"--workshift\\\"])\\n utils.make_workshift_pool_hours(semester=self.semester)\\n # Assign manager shifts beforehand\\n for user, manager in zip(users, Manager.objects.all()):\\n manager.incumbent = UserProfile.objects.get(user=user)\\n manager.save()\\n unfinished = utils.auto_assign_shifts(self.semester)\\n self.assertEqual([], unfinished)\",\n \"def _prefit(self,costfunc,sample):\\n # Here we obtain 10 initial candidates to best fitting\\n #opt=100.\\n if self.long_fitting[sample]:\\n l1=np.linspace(-20,0,16)\\n l2=np.linspace(-10,-0.3,16)\\n l3=np.linspace(-0.5,0.5,16)\\n l4=np.linspace(-0.015,0.015,16)\\n else:\\n l1=np.linspace(-20,0,5)\\n l2=np.linspace(-10,-0.3,5)\\n l3=np.linspace(-0.5,0.5,5)\\n l4=np.linspace(-0.015,0.015,5)\\n l1,l2,l3,l4=np.meshgrid(l1,l2,l3,l4)\\n l1,l2,l3,l4=l1.ravel(),l2.ravel(),l3.ravel(),l4.ravel()\\n #self._message(\\\"(%s) Prefitting data (grid search) - %d tests.\\\"%(sample,l1.size))\\n costs=np.ones_like(l1)\\n #optpar=np.array((l1[8],l2[8],l3[8],l4[8]))\\n for j in range(l1.size):\\n ll=np.array((l1[j],l2[j],l3[j],l4[j]))\\n costs[j]=costfunc(ll)\\n idx=np.argsort(costs)\\n opt=costs[idx]\\n optpars=np.column_stack((l1[idx],l2[idx],l3[idx],l4[idx]))\\n #self._message(str(optpars.shape))\\n #self._message(\\\"(%s) Prefitting done. Error achieved after prefitting: %s.\\\"%(sample,str(opt)))\\n #self._message(\\\"(%s) Prefitting done. Error achieved after prefitting: %g.\\\"%(sample,opt[0]))\\n if opt[0]>=1:\\n self._message(\\\"Warning: (%s) Prefitting did not find a good initial condition (%g).\\\"%(sample,opt[0]))\\n return optpars,opt\",\n \"def test_ipam_ip_addresses_partial_update(self):\\n pass\",\n \"def test_do_apogee_science_500s_after_1000s_cart7(self):\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 1000)\\n self.assertEqual(cmdState.keywords['expTime'], 1000)\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 500)\\n self.assertEqual(cmdState.keywords['expTime'], 500)\",\n \"def check_setpoints(self):\\n # TODO: Can possibly put this in the CCBC Brains\\n for heater in self.ard_data['heaters'].keys():\\n current_temp = float(self.ard_data['tempsensors'][self.ard_data['heaters'][heater]['tsensor_name']]['value'])\\n\\n # Assign the pin_status the previous value from the previous iteration\\n pin_status = self.ard_data['heaters'][heater]['status']\\n\\n if current_temp > self.ard_data['heaters'][heater]['upper limit']:\\n pin_status = 'OFF'\\n\\n if current_temp < self.ard_data['heaters'][heater]['lower limit']:\\n pin_status = 'ON'\\n\\n if current_temp >= self.ard_data['heaters'][heater]['maxtemp']:\\n pin_status = 'OFF'\\n\\n self.ard_data['heaters'][heater]['status'] = pin_status\\n\\n for pump in self.ard_data['pumps'].keys():\\n pressure = float(self.ard_data['presssensors'][self.ard_data['pumps'][pump]['psensor_name']]['pressure'])\\n gallons = float(pressure * self.ard_data['pumps'][pump]['psi_to_gal_slope'] +\\n self.ard_data['pumps'][pump]['psi_to_gal_intercept'])\\n self.ard_data['pumps'][pump]['gallons'] = gallons\\n\\n # Assign the pin status the previous value from the previous cycle\\n pin_status = self.ard_data['pumps'][pump]['status']\\n\\n if gallons > self.ard_data['pumps'][pump]['upper limit']:\\n # Turn the pump off when the setpoint is above the setpoint\\n pin_status = 'OFF'\\n # TODO: Account for solenoid valve control when available\\n\\n if gallons < self.ard_data['pumps'][pump]['lower limit']:\\n pin_status = 'ON'\\n\\n self.ard_data['pumps'][pump]['status'] = pin_status\",\n \"def test_auto_assign_one_overflow(self):\\n shift1 = RegularWorkshift.objects.create(\\n workshift_type=self.wtype1,\\n pool=self.p1,\\n hours=6,\\n )\\n unfinished = utils.auto_assign_shifts(self.semester)\\n self.assertEqual([self.profile], unfinished)\\n self.assertNotIn(self.profile, shift1.current_assignees.all())\\n\\n instances = WorkshiftInstance.objects.filter(weekly_workshift=shift1)\\n self.assertGreater(instances.count(), 0)\\n self.assertTrue(all(\\n instance.workshifter is None\\n for instance in instances\\n ))\\n\\n pool_hours = self.profile.pool_hours.get(pool=self.p1)\\n self.assertEqual(\\n pool_hours.assigned_hours,\\n 0,\\n )\",\n \"def readdata(self, prefix, date, county):\\n print('F30A: prefix and date', prefix, date)\\n\\n filetoread = open(prefix + 'EL30A')\\n\\n lines = []\\n for line in filetoread:\\n lines.append(line)\\n\\n linelimit = len(lines)\\n# print('LINELIMIT', linelimit)\\n linesub = 0\\n while linesub < linelimit:\\n line = lines[linesub]\\n\\n if len(line) < 4:\\n linesub += 1\\n continue\\n if len(line.split()) < 2:\\n linesub += 1\\n continue\\n possiblepctnumber = line[0:4]\\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\\n self._pctnumber = possiblepctnumber\\n self._pctname = line[4:].strip()\\n if self._pctnumber not in globalpcts:\\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\\n else:\\n onepct = globalpcts[self._pctnumber]\\n\\n # here's the new 12 June 2018 kluge to get the numbers\\n if 'BALLOTS CAST - TOTAL' in line:\\n line = line.replace('.', ' ')\\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\\n line = line.replace(',', '') # commas in numbers\\n\\n# linesplit = line.split()\\n self._ballots = []\\n for item in line.split():\\n self._ballots.append(int(item))\\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\\n onepct.updatefrom30a(self._registered, self._ballots, county)\\n globalpcts[self._pctnumber] = onepct\\n linesub += 1\",\n \"def partition_geocode(con: sqlite3.Connection, cur: sqlite3.Cursor, quarter: str, county_cht: str):\\n cur.execute('''SELECT 土地區段位置或建物區門牌 FROM \\\"{0}/TRX\\\"\\n WHERE 縣市 = ?\\n GROUP BY 土地區段位置或建物區門牌;'''.format(quarter), (county_cht,))\\n for address, in cur.fetchall():\\n cur.execute('''SELECT GEO.編號\\n FROM \\\"{0}/TRX\\\" AS TRX, \\\"{0}/GEO\\\" AS GEO\\n WHERE TRX.編號 = GEO.編號\\n AND TRX.土地區段位置或建物區門牌 = ?\\n AND GEO.LAT_Avg ISNULL;'''.format(quarter), (address,))\\n identities = cur.fetchall()\\n if not identities:\\n continue\\n print(\\\"[%d] \\\"%(len(identities)) + address)\\n try:\\n results = selective_geocode(address)\\n except geo.AddressError:\\n continue\\n if len(results[\\\"lat\\\"]) != 5 or len(results[\\\"lon\\\"]) != 5:\\n continue\\n results[\\\"lat\\\"].append(sum(results[\\\"lat\\\"]) / len(results[\\\"lat\\\"]))\\n results[\\\"lon\\\"].append(sum(results[\\\"lon\\\"]) / len(results[\\\"lon\\\"]))\\n combined = [num for zipped in zip(results[\\\"lat\\\"], results[\\\"lon\\\"]) for num in zipped]\\n values = [(tuple(combined) + identity) for identity in identities]\\n cur.executemany('''UPDATE \\\"{0}/GEO\\\" SET\\n LAT_1 = ?, LON_1 = ?,\\n LAT_2 = ?, LON_2 = ?,\\n LAT_3 = ?, LON_3 = ?,\\n LAT_4 = ?, LON_4 = ?,\\n LAT_5 = ?, LON_5 = ?,\\n LAT_Avg = ?, LON_Avg = ?\\n WHERE 編號 = ?;'''.format(quarter), values)\\n con.commit()\",\n \"def _set_search_addresses(self):\\n if self._report_data and self._report_data['details']:\\n for detail in self._report_data['details']:\\n if detail.get('ownerGroups'):\\n for group in detail['ownerGroups']:\\n for owner in group['owners']:\\n Report._format_address(owner['address'])\\n if detail.get('location') and 'address' in detail['location']:\\n Report._format_address(detail['location']['address'])\\n if detail.get('notes'):\\n for note in detail['notes']:\\n if note.get('contactAddress'):\\n Report._format_address(note['contactAddress'])\\n elif note.get('givingNoticeParty') and note['givingNoticeParty'].get('address'):\\n Report._format_address(note['givingNoticeParty']['address'])\",\n \"def addresses_per_kvk_to_sql(self):\\n\\n self.logger.info(\\\"Start writing the addressees to the sql Addresses table\\\")\\n if self.address_df.index.size == 0:\\n self.logger.debug(\\\"Empty address data frame. Nothing to write\\\")\\n return\\n\\n # create selection of data columns\\n self.address_df[COMPANY_KEY] = None\\n columns = [KVK_KEY, NAME_KEY, ADDRESS_KEY, POSTAL_CODE_KEY, CITY_KEY, COMPANY_KEY]\\n df = self.address_df[columns].copy()\\n df.sort_values([KVK_KEY], inplace=True)\\n # count the number of urls per kvk\\n\\n n_postcode_per_kvk = df.groupby(KVK_KEY)[KVK_KEY].count()\\n self.logger.info(f\\\"Found: {self.n_company} companies\\\")\\n wdg = PB_WIDGETS\\n if self.progressbar:\\n wdg[-1] = progress_bar_message(0, self.n_company)\\n progress = pb.ProgressBar(widgets=wdg, maxval=self.n_company, fd=sys.stdout).start()\\n else:\\n progress = None\\n\\n company_list = list()\\n for counter, company in enumerate(self.company_vs_kvk):\\n kvk_nr = int(company.kvk_nummer)\\n # we need to check if this kvk is in de address list still\\n\\n try:\\n n_postcode = n_postcode_per_kvk.loc[kvk_nr]\\n except KeyError:\\n continue\\n\\n # add the company number of url time to the list\\n company_list.extend([company] * n_postcode)\\n\\n if progress:\\n wdg[-1] = progress_bar_message(counter, self.n_company, kvk_nr, company.naam)\\n progress.update(counter)\\n if counter % MAX_SQL_CHUNK == 0:\\n self.logger.info(\\\" Added {} / {}\\\".format(counter, self.n_company))\\n if progress:\\n progress.finish()\\n\\n df[COMPANY_KEY] = company_list\\n\\n self.logger.info(\\\"Converting addresses to dict. This make take some time...\\\")\\n address_list = list(df.to_dict(orient=\\\"index\\\").values())\\n\\n # turn the list of dictionaries into a sql table\\n self.logger.info(\\\"Start writing table addresses\\\")\\n n_batch = int(len(address_list) / MAX_SQL_CHUNK) + 1\\n if self.progressbar:\\n wdg = PB_WIDGETS\\n wdg[-1] = progress_bar_message(0, self.n_company)\\n progress = pb.ProgressBar(widgets=wdg, maxval=n_batch, fd=sys.stdout).start()\\n else:\\n progress = None\\n with self.database.atomic():\\n for cnt, batch in enumerate(pw.chunked(address_list, MAX_SQL_CHUNK)):\\n self.logger.info(\\\"Address chunk nr {}/{}\\\".format(cnt + 1, n_batch))\\n self.AddressTbl.insert_many(batch).execute()\\n if progress:\\n wdg[-1] = progress_bar_message(cnt, n_batch)\\n progress.update(cnt)\\n if progress:\\n progress.finish()\",\n \"def _update_cust_table(self, add, i, pred):\\n self.cust_table.set_value(add, 'period{}_forc_shrink_value_per_day_per_item'.format(i), pred)\\n days_i = self.cust_table.columns.get_loc('days_between_visits')\\n days = self.cust_table.loc[add][days_i]\\n last_visit_i = self.cust_table.columns.get_loc('last_visit')\\n last_visit = self.cust_table.loc[add][last_visit_i]\\n next_visit = last_visit.to_datetime() + pd.to_timedelta(i * days, unit='D')\\n self.cust_table.set_value(add, 'period{}_pred_date'.format(i), next_visit)\",\n \"def test_do_apogee_science_1000s_after_500s_cart7(self):\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLeadCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 500)\\n self.assertEqual(cmdState.keywords['expTime'], 500)\\n\\n sopTester.updateModel('platedb', TestHelper.platedbState['apogeeLead1000sCart7'])\\n self._update_cart(7, 'APOGEE')\\n cmdState = self.actorState.doApogeeScience\\n cmdState.reinitialize(self.cmd)\\n self.assertEqual(cmdState.expTime, 1000)\\n self.assertEqual(cmdState.keywords['expTime'], 1000)\",\n \"def load_presn_search(search, start, end, offset, limit):\\n now_local = datetime.now()\\n timelimit = timedelta(hours=100)\\n server = couchdb.Server(\\\"http://snoplus:\\\"+app.config[\\\"COUCHDB_PASSWORD\\\"]+\\\"@\\\"+app.config[\\\"COUCHDB_HOSTNAME\\\"])\\n db = server[\\\"pre-supernova\\\"]\\n \\n results = []\\n skip = offset\\n\\n if search == \\\"run\\\":\\n startkey = [int(start)]\\n endkey = [int(end)]\\n view = '_design/presn/_view/presn_by_run_date'\\n\\n elif search == \\\"date\\\":\\n start_year = start[0:4]\\n start_month = start[5:7]\\n start_day = start[8:10]\\n end_year = end[0:4]\\n end_month = end[5:7]\\n end_day = end[8:10]\\n if start_month[0] == \\\"0\\\":\\n start_month = start_month[1]\\n if end_month[0] == \\\"0\\\":\\n end_month = end_month[1]\\n if start_day[0] == \\\"0\\\":\\n start_day = start_day[1]\\n if end_day[0] == \\\"0\\\":\\n end_day = end_day[1]\\n startkey = [int(start_year), int(start_month), int(start_day)]\\n endkey = [int(end_year), int(end_month), int(end_day)]\\n view = '_design/presn/_view/presn_by_date_run'\\n \\n if search == \\\"run\\\":\\n try:\\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\\n total = len(all.rows)\\n print \\\"OK, run gives us\\\", total\\n print all\\n except:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB.\\\")\\n\\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\\n try:\\n year = row.value[0]\\n mon = row.value[1]\\n day = row.value[2]\\n hour = row.value[3]\\n minute = row.value[4]\\n sec = row.value[5]\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n run = row.key\\n run_id = row.id\\n if timediff<timelimit:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n\\n elif search == \\\"date\\\":\\n try:\\n all = db.view(view, startkey=startkey, endkey=endkey, descending=False)\\n total = len(all.rows)\\n except:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB.\\\")\\n\\n for row in db.view(view, startkey=startkey, endkey=endkey, descending=False, skip=skip, limit=limit):\\n try:\\n year = row.key[0]\\n mon = row.key[1]\\n day = row.key[2]\\n hour = row.key[3]\\n minute = row.key[4]\\n sec = row.key[5]\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n run = row.value\\n run_id = row.id\\n if timediff<timelimit:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n return results, total, offset, limit\",\n \"def set_address(self, new_address, ):\\n self.address.append(new_address)\\n self.save()\",\n \"def cleanup(self):\\n all_aps_info = self.zd.get_all_ap_info()\\n all_aps_ins = self.testbed.components['AP']\\n for ap_ins in all_aps_ins:\\n for ap_info in all_aps_info:\\n if ap_ins.base_mac_addr.upper() == ap_info.get('mac').upper() and ap_info.get('ip_addr') != '':\\n ap_ins.ip_addr = ap_info.get('ip_addr')\",\n \"def set_addresses(cls, records, name, value=None):\\n Party = Pool().get('party.party')\\n\\n for record in records:\\n Party.write([record.party], {'addresses': value})\",\n \"def firstPass(self, priorityBondList=[]):\\r\\n self.lastRefreshTime = datetime.datetime.now()\\r\\n if priorityBondList == []:\\r\\n emptyLines = list(self.df.index)\\r\\n isins = self.embondsisins + BBGHand + ' Corp'\\r\\n else:\\r\\n emptyLines = priorityBondList\\r\\n isins = self.df.loc[priorityBondList, 'ISIN'] + BBGHand + ' Corp'\\r\\n isins = list(isins.astype(str))\\r\\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceLongQuery)\\r\\n blptsStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\\r\\n blpts.register(blptsStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n isins = self.rfbondsisins + ' @CBBT Corp'\\r\\n isins = list(isins.astype(str))\\r\\n blpts = blpapiwrapper.BLPTS(isins, self.bbgPriceRFQuery)\\r\\n blptsStream = StreamWatcher(self, BloombergQuery.FIRSTPASS)\\r\\n blpts.register(blptsStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n specialBondList = list(set(emptyLines) & set(SPECIALBONDS))\\r\\n specialIsins = map(lambda x:self.df.at[x,'ISIN'] + BBGHand + ' Corp',specialBondList)\\r\\n blpts = blpapiwrapper.BLPTS(specialIsins, self.bbgPriceLongSpecialQuery)\\r\\n specialbondStream = StreamWatcher(self,BloombergQuery.FIRSTPASS)\\r\\n blpts.register(specialbondStream)\\r\\n blpts.get()\\r\\n blpts.closeSession()\\r\\n\\r\\n for bond in emptyLines:\\r\\n self.updateStaticAnalytics(bond) # This will update benchmarks and fill grid. Has to be done here so all data for benchmarks is ready.\\r\",\n \"def change_map501_pswap_trades(status):\\n print(\\\"Processing pswaps for MAP501\\\")\\n portfolio = acm.FPhysicalPortfolio[\\\"PB_PSWAP_MAP_501_CR\\\"]\\n graveyard = acm.FPhysicalPortfolio[\\\"GRAVEYARD\\\"]\\n trades = [t for t in portfolio.Trades()\\n if is_child_portf(t.Instrument().FundPortfolio(), graveyard)]\\n set_status(trades, status)\",\n \"def UpdatePlacements(WeeklyResultsfile, oldPlacementsfile:str, Placementsfile:str, week:int):\\r\\n WR = pd.read_csv(WeeklyResultsfile, encoding = \\\"ISO-8859-1\\\")\\r\\n if week != 1:\\r\\n Placement = pd.read_csv(oldPlacementsfile, encoding = \\\"ISO-8859-1\\\")\\r\\n Placement[f'PWeek{week}'] = -2\\r\\n for index, row in WR.iterrows():\\r\\n oldPlayer = Placement[Placement['SmasherID'].isin([row['SmasherID']])]\\r\\n if len(oldPlayer) > 0: # Have they entered before?\\r\\n index = oldPlayer.index[0]\\r\\n Placement.at[index, 'SmashTag'] = row['SmashTag'] # If someone changes their tag\\r\\n Placement.at[index, f'PWeek{week}'] = row['Placement']\\r\\n else:\\r\\n new_row = {'SmasherID': row['SmasherID'], # New TMT Entrant\\r\\n 'SmashTag': row['SmashTag'],\\r\\n f'PWeek{week}': row['Placement']}\\r\\n for i in range(1, week):\\r\\n new_row[f'PWeek{i}'] = -2\\r\\n Placement = Placement.append(new_row, ignore_index = True)\\r\\n else:\\r\\n WR['NumTMTEntered'] = 0\\r\\n WR['NumInBracket'] = 0\\r\\n Placement = WR[['SmasherID', 'SmashTag', 'NumTMTEntered',\\r\\n 'NumInBracket', 'Placement']]\\r\\n Placement = Placement.rename(columns={'Placement': 'PWeek1'})\\r\\n \\r\\n FindTournamentEntrants(Placement, week)\\r\\n Placement = Placement.sort_values(by = 'SmasherID')\\r\\n Placement.to_csv(Placementsfile, index=False, encoding = \\\"ISO-8859-1\\\")\",\n \"def _set_ppr_search(self): # pylint: disable=too-many-branches, too-many-statements\\n for detail in self._report_data['details']:\\n if detail.get('pprRegistrations'):\\n for registration in detail['pprRegistrations']:\\n current_app.logger.debug('Setting up ppr registration for ' +\\n registration['financingStatement']['baseRegistrationNumber'])\\n if 'registrationAct' in registration['financingStatement']:\\n act: str = registration['financingStatement']['registrationAct']\\n registration['financingStatement']['registrationAct'] = act.title()\\n ppr_report_utils.set_ppr_template_data(registration['financingStatement'])\",\n \"def reap_recent_assignments():\\n from anubis.config import config\\n\\n recent_assignments = Assignment.query.filter(\\n Assignment.release_date > datetime.now(),\\n Assignment.due_date > datetime.now() - config.STATS_REAP_DURATION,\\n ).all()\\n\\n print(json.dumps({\\n 'reaping assignments:': [assignment.data for assignment in recent_assignments]\\n }, indent=2))\\n\\n for assignment in recent_assignments:\\n for submission in Submission.query.filter(\\n Submission.assignment_id == assignment.id,\\n Submission.build == None,\\n ).all():\\n if submission.build is None:\\n init_submission(submission)\\n enqueue_autograde_pipeline(submission.id)\\n\\n for assignment in recent_assignments:\\n bulk_autograde(assignment.id)\",\n \"def update_db(df, db, app=None):\\n db = db\\n\\n print_or_log(\\\"Formatting data...\\\", app=app)\\n\\n # list to keep track of filtered data\\n # keys are the date with the code concatenated\\n entries = {}\\n i = 1\\n for key, sheet in df.items():\\n\\n # print progress\\n print_or_log(\\\"{}/{}\\\".format(i, len(df.items())), end=\\\"\\\\r\\\", app=app)\\n i += 1\\n\\n # prepare exam results from sheet period\\n for index, row in sheet.iterrows():\\n\\n # skip if not exam\\n if row[\\\"Provnamn\\\"] != \\\"Tentamen\\\":\\n continue\\n\\n # retrieve course code\\n code = row[\\\"Kurs\\\"]\\n\\n # retrieve course name\\n name = row[\\\"Kursnamn\\\"]\\n\\n # retrieve grade\\n grade = row[\\\"Betyg\\\"]\\n\\n # retrieve amount of results\\n amount = row[\\\"Antal\\\"]\\n\\n # retrieve exam date\\n date = row[\\\"Provdatum\\\"]\\n if type(date) is pd.Timestamp:\\n date = str(date.date())\\n\\n # necessary because of different date formats in sheets\\n elif type(date) is str:\\n date = str(parse(date).date())\\n\\n # if exam occasion hasn't been encountered yet, add it\\n key = code + date\\n if key not in entries:\\n entries[key] = {\\n \\\"taken\\\": date,\\n \\\"code\\\": code,\\n \\\"name\\\": name,\\n \\\"failures\\\": 0,\\n \\\"threes\\\": 0,\\n \\\"fours\\\": 0,\\n \\\"fives\\\": 0,\\n }\\n\\n # now modify grade that this iteration concerns in occasion\\n if grade == \\\"U\\\":\\n entries[key][\\\"failures\\\"] = amount\\n elif grade == \\\"3\\\":\\n entries[key][\\\"threes\\\"] = amount\\n elif grade == \\\"4\\\":\\n entries[key][\\\"fours\\\"] = amount\\n elif grade == \\\"5\\\":\\n entries[key][\\\"fives\\\"] = amount\\n\\n print_or_log(\\\"\\\\nInserting data...\\\", app=app)\\n insertions = 0\\n i = 1\\n\\n # go through entries and add them if they're not already present in the database\\n for key, entry in entries.items():\\n\\n # print progress\\n print_or_log(\\\"{}/{}\\\".format(i, len(entries.items())), end=\\\"\\\\r\\\", app=app)\\n i += 1\\n\\n # see if there is an entry matching the course code and exam date\\n db_entry = db.query(\\n \\\"SELECT * FROM results WHERE code=%s AND taken=%s\\\", (entry[\\\"code\\\"], entry[\\\"taken\\\"]))\\n\\n # if there isn't, we can insert the new result in the database\\n if len(db_entry) == 0:\\n insertions += 1\\n\\n db.query(\\\"INSERT INTO results (taken, code, name, failures, threes, fours, fives) \\\"\\n \\\"VALUES (%s,%s,%s,%s,%s,%s,%s)\\\", (entry[\\\"taken\\\"], entry[\\\"code\\\"], entry[\\\"name\\\"], entry[\\\"failures\\\"],\\n entry[\\\"threes\\\"], entry[\\\"fours\\\"], entry[\\\"fives\\\"]))\\n\\n print_or_log(\\\"\\\\nInserted \\\" + str(insertions) + \\\" entries in database\\\", app=app)\",\n \"def _put_reg_prep_in_rc_db(context: 'IconScoreContext', address: 'Address'):\\n\\n rc_tx_batch: list = context.rc_tx_batch\\n block_height: int = context.block.height\\n\\n tx: 'PRepRegisterTx' = RewardCalcDataCreator.create_tx_prep_reg()\\n iiss_tx_data: 'TxData' = RewardCalcDataCreator.create_tx(address, block_height, tx)\\n context.storage.rc.put(rc_tx_batch, iiss_tx_data)\",\n \"def collect_web_sites(self):\\n min_distance = None\\n max_sequence_match = None\\n index_string_match = index_distance = None\\n self.collection = collections.OrderedDict()\\n for i_web, web_row in self.company_urls_df.iterrows():\\n # get the url first from the websites table which list all the urls belonging to\\n # one kvk search\\n url = web_row[URL_KEY]\\n\\n # skip all none uls and also the filtered urls\\n if url is None or url == \\\"\\\":\\n logger.debug(\\\"Skipping url because it is None or empty\\\")\\n continue\\n if self.filter_urls and url not in self.filter_urls:\\n logger.debug(f\\\"filter urls is given so skip {url}\\\")\\n continue\\n\\n # store a list of UrlInfo object with a minimum info the url which was tested\\n url_info = UrlInfo(index=i_web, url=url)\\n self.collection[url] = url_info\\n\\n print_banner(f\\\"Processing {url}\\\")\\n\\n # quick check if we can processes this url based on the country code\\n suffix = url_info.url_extract.suffix\\n if suffix in self.exclude_extensions.index:\\n url_info.outside_nl = True\\n logger.info(f\\\"Web site {url} has suffix '.{suffix}' Continue \\\")\\n\\n # get the processing time of the last time you did this url from the table\\n try:\\n processing_time = self.urls_df.loc[url, DATETIME_KEY]\\n except KeyError:\\n processing_time = None\\n\\n if self.force_process or self.rescan_missing_urls:\\n url_info.needs_update = True\\n else:\\n url_info.needs_update = check_if_url_needs_update(processing_time=processing_time,\\n current_time=self.current_time,\\n older_time=self.older_time)\\n if url_info.needs_update:\\n # if the url needs update, store the current time\\n url_info.processing_time = self.current_time\\n else:\\n url_info.processing_time = processing_time\\n\\n url_analyse = self.scrape_url_and_store_in_dataframes(url, url_info)\\n\\n url_info.url_analyse = url_analyse\\n\\n if url_analyse and not url_analyse.exists:\\n self.logger.debug(f\\\"url '{url}'' does not exist\\\")\\n continue\\n\\n # based on the company postcodes and kvknummer and web contents, make a ranking how\\n # good the web sides matches the company\\n match = UrlCompanyRanking(url, self.company_name_small,\\n url_extract=url_info.url_extract,\\n url_analyse=url_analyse,\\n company_kvk_nummer=self.kvk_nr,\\n company_postcodes=self.postcodes,\\n threshold_string_match=self.threshold_string_match,\\n threshold_distance=self.threshold_distance,\\n logger=self.logger)\\n\\n url_info.match = match\\n\\n # update the min max\\n if min_distance is None or match.distance < min_distance:\\n index_distance = i_web\\n min_distance = match.distance\\n\\n if max_sequence_match is None or match.string_match > max_sequence_match:\\n index_string_match = i_web\\n max_sequence_match = match.string_match\\n\\n self.logger.debug(\\\" * {} - {} - {}\\\".format(url, match.ext.domain,\\n match.distance))\\n\\n if min_distance is None:\\n self.company_urls_df = None\\n elif index_string_match != index_distance:\\n self.logger.warning(\\n \\\"Found minimal distance for {}: {}\\\\nwhich differs from \\\"\\n \\\"best string match {}: {}\\\".format(index_distance,\\n self.collection[url].url,\\n index_string_match,\\n self.collection[url].url))\",\n \"def district_check(self):\\n\\t\\t\\n\\t\\tplaces_2_fetch=list(ons_week.stored_names.values())+ons_week.extra_places\\n\\t\\tself.edition=None\\n\\t\\tfor place in places_2_fetch:\\n\\t\\t\\t_filters=self.district_filter(place)\\n\\t\\t\\tif _filters:\\n\\t\\t\\t\\tself.api.filters=_filters\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlog.info(f'Not fetching {place} - not in PHE API')\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\ttries=0\\n\\t\\t\\twhile tries < 5:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tlog.debug(f'Fetching {place}')\\n\\t\\t\\t\\t\\tself.data=self.api.get_json() # Returns a dictionary\\n\\t\\t\\t\\t\\tnew_data=self.data.get('data')\\n\\t\\t\\t\\t\\t#log.info(self.latest_update)\\n\\t\\t\\t\\t\\tif not self.edition:\\n\\t\\t\\t\\t\\t\\tself.edition=self.latest_update\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\t\\tlog.error(e)\\n\\t\\t\\t\\t\\tlog.error('Retrying after 8 secs')\\n\\t\\t\\t\\t\\ttime.sleep(8)\\n\\t\\t\\t\\t\\ttries +=1\\n\\t\\t\\t\\t\\tnew_data=[]\\n\\t\\t\\tif not new_data:\\n\\t\\t\\t\\tlog.error(f'No data found for {place}')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.data_all +=new_data\\n\\t\\t\\ttime.sleep(0.1)\",\n \"def _compute_adress(self):\\r\\n\\t\\tfor leads in self:\\r\\n\\t\\t\\tleads.address = leads.street + \\\" \\\" + leads.street2\",\n \"def update_address(cls, address_data):\\n address_instance = cls.objects.get(email=address_data['customer']['email'])\\n address_data = address_data.get('addresses')\\n for field_name, values in address_data:\\n setattr(address_instance, field_name, values)\\n address_instance.save()\\n return address_instance.save()\",\n \"def decideWorkers(availableWorkers,today,num=4,mopping=False):\\n secondary = 0 # count for how many secondaries are working today\\n\\n availableWorkers.sort(key=lambda worker: worker.getCleanCount())\\n for minion in availableWorkers[:num]: # take the first four lowest\\n if minion.getWorkEnd() != 9.0: # find the number of secondaries\\n secondary += 1\\n\\n for minion in availableWorkers[:num+secondary]: # take the first four lowest and additionals to replace secondaries\\n if mopping and (minion.getWorkEnd() == 9.0): #only people who will be at the end of lab to mop gets mopping counted\\n minion.mopped()\\n else: #if they aren't mopping or cannot mop, they only clean\\n minion.cleaned()\\n # Add this assignment to the schedule\\n working = (minion.getName(),minion.getCleanCount()) #make the name and clean count a tuple\\n \\n \\n \\n today.append(working)\\n return today\",\n \"def test_can_lookup_postcode(self):\\n postcode_to_lookup = \\\"SW1A 1AA\\\"\\n os_places_key = self.app.config.get(\\\"OS_PLACES_API_KEY\\\")\\n addresses = AddressLookup(key=os_places_key).by_postcode(postcode_to_lookup)\\n self.assertGreater(len(addresses), 0)\\n result_postcode = addresses[0].get(\\\"DPA\\\", {}).get(\\\"POSTCODE\\\")\\n self.assertEqual(result_postcode, postcode_to_lookup)\",\n \"def test_pre_assigned(self):\\n shift1 = RegularWorkshift.objects.create(\\n workshift_type=self.wtype1,\\n pool=self.p1,\\n hours=5,\\n )\\n shift2 = RegularWorkshift.objects.create(\\n workshift_type=self.wtype3,\\n pool=self.p1,\\n hours=1,\\n )\\n shift2.current_assignees = [self.profile]\\n\\n unfinished = utils.auto_assign_shifts(self.semester)\\n self.assertEqual([self.profile], unfinished)\\n self.assertNotIn(self.profile, shift1.current_assignees.all())\\n\\n pool_hours = self.profile.pool_hours.get(pool=self.p1)\\n self.assertEqual(\\n pool_hours.assigned_hours,\\n 1,\\n )\",\n \"def _set_rules_pxeboot(self, gnp_config, network, host):\\n\\n addr_pool = self.dbapi.address_pool_get(network.pool_uuid)\\n ip_version = IPAddress(f\\\"{addr_pool.network}\\\").version\\n self._add_source_net_filter(gnp_config[\\\"spec\\\"][\\\"ingress\\\"],\\n f\\\"{addr_pool.network}/{addr_pool.prefix}\\\")\\n if (ip_version == 6):\\n self._add_source_net_filter(gnp_config[\\\"spec\\\"][\\\"ingress\\\"], LINK_LOCAL)\\n if (ip_version == 4):\\n # add rule to allow DHCP requests (dhcp-offer have src addr == 0.0.0.0)\\n rule = self._get_dhcp_rule(host.personality, \\\"UDP\\\", ip_version)\\n gnp_config[\\\"spec\\\"][\\\"ingress\\\"].append(rule)\",\n \"def populate_town(self, people=50):\\n \\n #1.5 acres farm needed per person\\n #farmer could farm 20-40 (30) acres\\n #30/1.5 = 20 people per farm\\n people_to_assign = people\\n farms_needed = (self.population + people)/20 + 1\\n if people_to_assign >= farms_needed:\\n self.occupations['farmer'] += farms_needed\\n people_to_assign -= farms_needed\\n else:\\n self.occupations['farmer'] += people_to_assign\\n shuffle(sites['object list'])\\n while people_to_assign > 0:\\n for site in [\\n x for x in sites['object list'] if ref.structure_type_dct[x.structure.structure_type]['site type'] == 'resource'\\n ]:\\n if site.structure.worker_capacity > 0:\\n self.occupations[ref.structure_type_dct[\\n site.structure.structure_type]['worker type']] += 1\\n site.structure.add_worker()\\n people_to_assign -= 1\\n continue\\n self.occupations[choice(\\n ['artisan']*2 + \\n ['homekeeper']*5 + \\n ['government'] +\\n ['retail']*2)] += 1\\n people_to_assign -= 1 \\n \\n self.population += people\\n return self\",\n \"def set_primary_ips(self):\\n for nb_obj_type in (\\\"devices\\\", \\\"virtual_machines\\\"):\\n log.info(\\n \\\"Collecting NetBox %s objects to set Primary IPs.\\\",\\n nb_obj_type[:-1].replace(\\\"_\\\", \\\" \\\")\\n )\\n obj_key = self.obj_map[nb_obj_type][\\\"key\\\"]\\n # Collect all parent objects that support Primary IPs\\n parents = self.request(\\n req_type=\\\"get\\\", nb_obj_type=nb_obj_type,\\n query=\\\"?tag={}\\\".format(format_slug(self.vc_tag))\\n )\\n log.info(\\\"Collected %s NetBox objects.\\\", parents[\\\"count\\\"])\\n for nb_obj in parents[\\\"results\\\"]:\\n update_object = False\\n parent_id = nb_obj[\\\"id\\\"]\\n nb_obj_name = nb_obj[obj_key]\\n new_pri_ip = self.get_primary_ip(nb_obj_type, parent_id)\\n # Skip the rest if we don't have a usable IP\\n if new_pri_ip is None:\\n log.info(\\n \\\"No usable IPs were found for NetBox '%s' object. \\\"\\n \\\"Moving on.\\\",\\n nb_obj_name\\n )\\n continue\\n if nb_obj[\\\"primary_ip\\\"] is None:\\n log.info(\\n \\\"No existing Primary IP found for NetBox '%s' object.\\\",\\n nb_obj_name\\n )\\n update_object = True\\n else:\\n log.info(\\n \\\"Primary IP already set for NetBox '%s' object. \\\"\\n \\\"Comparing.\\\",\\n nb_obj_name\\n )\\n old_pri_ip = nb_obj[\\\"primary_ip\\\"][\\\"id\\\"]\\n if old_pri_ip != new_pri_ip[\\\"id\\\"]:\\n log.info(\\n \\\"Existing Primary IP does not match latest check. \\\"\\n \\\"Requesting update.\\\"\\n )\\n update_object = True\\n else:\\n log.info(\\n \\\"Existing Primary IP matches latest check. Moving \\\"\\n \\\"on.\\\"\\n )\\n if update_object:\\n log.info(\\n \\\"Setting NetBox '%s' object primary IP to %s.\\\",\\n nb_obj_name, new_pri_ip[\\\"address\\\"]\\n )\\n ip_version = str(\\n \\\"primary_ip{}\\\".format(\\n ip_network(\\n new_pri_ip[\\\"address\\\"], strict=False\\n ).version\\n ))\\n data = {ip_version: new_pri_ip[\\\"id\\\"]}\\n self.request(\\n req_type=\\\"patch\\\", nb_obj_type=nb_obj_type,\\n nb_id=parent_id, data=data\\n )\",\n \"def assign_zone_veh(self, t, warmup_phase, penalty, operator):\\n for z in self.zones:\\n z.assign(self.zones, t, warmup_phase, penalty, operator)\",\n \"def adjust_fitness_scores(self):\\n\\n for species in self.species:\\n species.adjust_fitness()\",\n \"def test_update__endtoend__4(\\n address_book, FieldFactory, UpdateablePersonFactory,\\n PostalAddressFactory, browser):\\n field_name = FieldFactory(\\n address_book, IPostalAddress, 'Choice', u'distance',\\n values=[u'< 50 km', u'>= 50 km']).__name__\\n PostalAddressFactory(UpdateablePersonFactory(address_book),\\n **{field_name: '>= 50 km', 'set_as_default': True})\\n\\n browser.login('mgr')\\n browser.keyword_search(KEYWORD, apply='Update')\\n browser.getControl('field').displayValue = ['postal address -- distance']\\n browser.getControl('Next').click()\\n assert ['No value', '< 50 km', '>= 50 km'] == browser.getControl(\\n 'new value').displayOptions\\n browser.getControl('new value').displayValue = ['< 50 km']\\n browser.getControl('operation').displayValue = [\\n 'replace existing value with new one']\\n browser.getControl('Next').click()\\n # Update sets the value to '< 50 km':\\n assert ('<td>Tester</td><td><50km</td>' in\\n browser.contents_without_whitespace)\",\n \"def add_vars(self, dump=False) -> None:\\n self.logger.info('add_vars')\\n\\n # delete finance and insurance companies\\n self.uber_data = self.uber_data.loc[\\n (self.uber_data.loc[:, 'industry'] != 'banki')\\n & (self.uber_data.loc[:, 'industry'] != 'ubezpieczenia'), :]\\n\\n self.uber_data.loc[:, 'D_BZ_date'] = self.uber_data.loc[:, 'D_BZ'].map(\\n lambda m: datetime.datetime.strptime(m, \\\"%Y-%m-%d\\\").date())\\n self.uber_data.loc[:, 'year'] = self.uber_data.loc[:, 'D_BZ_date'].map(lambda n: n.year)\\n\\n for i, x in self.uber_data.iterrows():\\n statement_date = x.at['D_BZ_date']\\n reference_date = statement_date\\n if x.at['isin'] not in self.prices.keys():\\n self.logger.warning('isin in data not in prices: {}'.format(x.at['isin']))\\n continue\\n # I don't trust Notoria, so I will check on my own in GPWinfostrefa for prices for debug\\n before_ipo_date_check = False\\n if reference_date <= self.ipo_dates[x.at['isin']]:\\n before_ipo_date_check = True\\n\\n # add market price for balance sheet date\\n while True:\\n try:\\n self.uber_data.loc[i, 'market_price'] = self.prices[x.at['isin']].loc[reference_date, 'eod_price']\\n self.uber_data.loc[i, 'market_price_date'] = reference_date\\n break\\n except KeyError:\\n reference_date = reference_date - datetime.timedelta(days=1)\\n distance = statement_date - reference_date\\n if distance >= datetime.timedelta(days=10):\\n if before_ipo_date_check is False:\\n self.logger.warning('achtung! no price in last {}, isin: {}, {}.'.format(\\n distance, x.at['isin'], statement_date\\n ))\\n break\\n\\n # find price at the end of year for market cap calc\\n # d = 31\\n # while d > 25:\\n # date = datetime.date(year=x.at['year'], month=12, day=d)\\n # try:\\n # self.uber_data.loc[i, 'price_end_of_year'] = self.prices[x.at['isin']].loc[date, 'eod_price']\\n # except KeyError:\\n # d = d - 1\\n\\n for i, x in self.uber_data.iterrows():\\n self.uber_data.at[i, 'better_num_of_shares'] = self.get_number_of_shares(\\n isin=x['isin'],\\n date=x['D_BZ_date']\\n )\\n\\n self.uber_data.loc[:, 'better_num_of_shares'] = pd.to_numeric(self.uber_data.loc[:, 'better_num_of_shares'])\\n self.uber_data.loc[:, 'combined_num_of_shares'] = self.uber_data.loc[:, 'better_num_of_shares'] / 1000\\n\\n self.uber_data.loc[:, 'A_0'] = pd.to_numeric(self.uber_data.loc[:, 'A_0']) # many calcs\\n self.uber_data.loc[:, 'PP_1'] = pd.to_numeric(self.uber_data.loc[:, 'PP_1']) # equity calc\\n self.uber_data.loc[:, 'PP_2'] = pd.to_numeric(self.uber_data.loc[:, 'PP_2']) # LEV_LTM calc\\n self.uber_data.loc[:, 'P_8'] = pd.to_numeric(self.uber_data.loc[:, 'P_8']) # equity calc\\n self.uber_data.loc[:, 'WO_0'] = pd.to_numeric(self.uber_data.loc[:, 'WO_0']) # PROF calc\\n self.uber_data.loc[:, 'R[AM_0]'] = pd.to_numeric(self.uber_data.loc[:, 'R[AM_0]']) # PROF calc\\n self.uber_data.loc[:, 'AA_1'] = pd.to_numeric(self.uber_data.loc[:, 'AA_1']) # TANG calc\\n self.uber_data.loc[:, 'market_price'] = pd.to_numeric(self.uber_data.loc[:, 'market_price'])\\n\\n # market value = market_price * combined_num_of_shares (ilość akcji w tysiącach) (uzyskana wartość w tysiącach)\\n self.uber_data.loc[:, 'market_value'] = self.uber_data.loc[:, 'market_price'] * \\\\\\n self.uber_data.loc[:, 'combined_num_of_shares']\\n self.uber_data.loc[:, 'market_value'] = pd.to_numeric(self.uber_data.loc[:, 'market_value'])\\n\\n # PP_2 / A_0 (zobowiązania długoterminowe / suma aktywów)\\n self.uber_data.loc[:, 'LEV_LTB'] = self.uber_data.loc[:, 'PP_2'] / self.uber_data.loc[:, 'A_0']\\n self.uber_data.loc[:, 'LEV_LTB'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_LTB'])\\n\\n # PP_2 /(PP_2+market_value) zobowiązania_długoterminowe / (zobowiązania_długoterminowe+wartość rynkowa)\\n self.uber_data.loc[:, 'LEV_LTM'] = (self.uber_data.loc[:, 'PP_2']) / \\\\\\n (self.uber_data.loc[:, 'PP_2'] + self.uber_data.loc[:, 'market_value'])\\n self.uber_data.loc[:, 'LEV_LTM'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_LTM'])\\n\\n # ln (A_0) ln(suma aktywów)\\n self.uber_data.loc[:, 'Size'] = np.log(self.uber_data.loc[:, 'A_0'].tolist())\\n self.uber_data.loc[:, 'Size'] = pd.to_numeric(self.uber_data.loc[:, 'Size'])\\n\\n self.uber_data.loc[:, 'equity'] = (self.uber_data.loc[:, 'PP_1'] + self.uber_data.loc[:, 'P_8'])\\n self.uber_data.loc[:, 'equity'] = pd.to_numeric(self.uber_data.loc[:, 'equity'])\\n\\n # market_value / (PP_1 + P_8)\\n # (wartość rynkowa w tys / (Kapitał własny udziałowców podmiotu dominującego + Udziały niekontrolujące)\\n # (different procedures)\\n self.uber_data.loc[:, 'MB'] = self.uber_data.loc[:, 'market_value'] / self.uber_data.loc[:, 'equity']\\n\\n self.uber_data.loc[:, 'MB'] = pd.to_numeric(self.uber_data.loc[:, 'MB'])\\n\\n # (WO_0+R[AM_0]) / A_0 ((Zysk/strata z działalności operacyjnej+amortyzacja) / suma aktywów)\\n self.uber_data.loc[:, 'PROF'] = (self.uber_data.loc[:, 'WO_0'] + self.uber_data.loc[:, 'R[AM_0]'])\\\\\\n / self.uber_data.loc[:, 'A_0']\\n self.uber_data.loc[:, 'PROF'] = pd.to_numeric(self.uber_data.loc[:, 'PROF'])\\n\\n # AA_1 / A_0 (Aktywa trwałe / suma aktywów)\\n self.uber_data.loc[:, 'TANG'] = self.uber_data.loc[:, 'AA_1'] / self.uber_data.loc[:, 'A_0']\\n self.uber_data.loc[:, 'TANG'] = pd.to_numeric(self.uber_data.loc[:, 'TANG'])\\n\\n self.uber_data.loc[self.uber_data.loc[:, 'CFC_7'] < 0, 'DivPayer'] = 1\\n self.uber_data.loc[self.uber_data.loc[:, 'DivPayer'] != 1, 'DivPayer'] = 0\\n self.uber_data.loc[:, 'DivPayer'] = pd.to_numeric(self.uber_data.loc[:, 'DivPayer'])\\n\\n self.uber_data.loc[self.uber_data.loc[:, 'gov_owned'] != 1, 'gov_owned'] = 0\\n self.uber_data.loc[:, 'gov_owned'] = pd.to_numeric(self.uber_data.loc[:, 'gov_owned'])\\n\\n self.uber_data.loc[:, 'growth_phase'] = self.uber_data.loc[:, 'D_BZ_date'].map(lambda n: self.get_phase(n))\\n self.uber_data.loc[:, 'growth_phase'] = pd.to_numeric(self.uber_data.loc[:, 'growth_phase'])\\n\\n self.uber_data.loc[:, 'LEV_IMed'] = np.nan\\n group_criterion = 'industry'\\n for i, x in self.uber_data.iterrows():\\n ss = x.at[group_criterion]\\n for ii in self.uber_data.loc[:, group_criterion].unique():\\n if ss == ii:\\n self.uber_data.loc[i, 'LEV_IMed'] = self.uber_data.loc[\\n self.uber_data.loc[:, group_criterion] == ii, 'LEV_LTB'].median()\\n continue\\n self.uber_data.loc[:, 'LEV_IMed'] = pd.to_numeric(self.uber_data.loc[:, 'LEV_IMed'])\\n\\n # CFVol\\n self.uber_data.loc[:, 'CFVol'] = np.nan\\n for i, x in self.uber_data.iterrows():\\n older = self.uber_data.loc[(self.uber_data.loc[:, 'isin'] == x.at['isin']) &\\n (self.uber_data.loc[:, 'D_BZ_date'] < x.at['D_BZ_date']) &\\n (self.uber_data.loc[:, 'WO_0'].notnull()), :]\\n if len(older) >= 3:\\n self.uber_data.at[i, 'CFVol'] = older.loc[:, 'WO_0'].std()\\n self.uber_data.loc[:, 'CFVol'] = pd.to_numeric(self.uber_data.loc[:, 'CFVol'])\\n\\n self.uber_data.set_index(['isin', 'D_BZ'], inplace=True, drop=False)\\n\\n if dump is True:\\n self.save_to_pickle(self.uber_data, 'uber_data')\",\n \"def find_street_in_descriprion(self):\\n from filtering_functions import find_street\\n for ad_id, ad_data in self.ads_data.items():\\n if 'Ulica_re' not in ad_data.keys():\\n self.ads_data[ad_id]['Ulica_re'] = find_street(self.ads_data[ad_id]['Opis'])\",\n \"def get_268_data(self, dbca_initial_control=None):\\n qs_regions = get_sorted_regions()\\n\\n if dbca_initial_control:\\n # get the fires managed by DBCA\\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED], initial_control=Agency.DBCA,reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\\n else:\\n outstanding_fires = list(Bushfire.objects.filter(report_status__in=[Bushfire.STATUS_INITIAL_AUTHORISED],reporting_year__lte=self.reporting_year).values_list('fire_number', flat=True))\\n\\n pbs_fires_dict = get_pbs_bushfires(outstanding_fires) or []\\n\\n if not dbca_initial_control:\\n self.pbs_fires_dict = pbs_fires_dict\\n #logger.info(\\\"self.pbs_fires_dict: \\\" + str(self.pbs_fires_dict))\\n self.found_fires = [i['fire_id'] for i in self.pbs_fires_dict]\\n self.missing_fires = list(set(outstanding_fires).difference(self.found_fires)) # fire_numbers not returned from PB\\n\\n rpt_map = {}\\n for i in pbs_fires_dict: \\n region_id = i['region']\\n\\n exists = [i for r in qs_regions if r.id==region_id]\\n if exists:\\n if rpt_map.has_key(region_id):\\n rpt_map[region_id]['area'] = rpt_map[region_id]['area'] + float(i['area'])\\n rpt_map[region_id]['number'] = rpt_map[region_id]['number'] + 1\\n \\n else:\\n rpt_map[region_id] = {\\n 'area' : float(i['area']),\\n 'number' : 1\\n }\\n\\n else:\\n raise Exception(\\\"PBS Region id({}) Not Found in BFRS\\\".format(region_id))\\n\\n return rpt_map\",\n \"def recalculate_delivery_numbers(self):\\n from .delivery import Delivery\\n qry = Delivery.objects.filter(deadline__assignment_group=self,\\n successful=True)\\n qry = qry.order_by('time_of_delivery')\\n for number, delivery in enumerate(qry, 1):\\n delivery.number = number\\n delivery.save()\",\n \"def update_db(bus_id=def_id):\\n # Instantiate the SQL class for the business data we will be pulling\\n sql = Sql(bus_id)\\n\\n # Check if we have previously analyzed the requested business\\n # If not, pull the raw data and processing the data\\n if sql.check() is not False:\\n print \\\"Already in database!\\\"\\n return\\n\\n # Get business data (name, country, etc) from Yelp API\\n # Limited to 25,000 Yelp API calls per day\\n # There are over 4 million reviews and over 140,000 businesses in database\\n while True:\\n try:\\n bus_info = Yelp(bus_id)\\n break\\n except ValueError:\\n pass\\n except YelpAPI.YelpAPIError:\\n return\\n\\n # Grab review text from SQL database\\n sql.pull_reviews()\\n\\n # Use our trained XGBoost Classifier and TFIDF vectorizer\\n # to determine whether each review is \\\"Favorable\\\" or \\\"Unfavorable\\\"\\n model.predict(sql.reviews)\\n\\n # Conduct sentiment analysis and evaluate word counts in order to\\n # \\\"penalize\\\" the weighting of reviews that don't fit the threshold\\n nlp = Nlp(sql.reviews, sql.stars, model.preds,\\n bus_info.name, bus_info.country, bus_info.city)\\n\\n # Assign variables from all the objects attributes we created\\n # and then input them into a tuple.\\n # The tuple is used to populate the SQL database for faster lookup of\\n # our analysis at a later time\\n # The tuple is also used to populate our dictionary which will be\\n # used for variables that will be rendered on our website\\n name = nlp.name\\n city = nlp.city\\n country = nlp.country\\n old_rating = int(100 * nlp.stars_avg / 5)\\n new_rating = int(nlp.new_rating * 100)\\n rev_count = len(sql.reviews)\\n count_5 = sql.stars.count(5)\\n count_4 = sql.stars.count(4)\\n count_3 = sql.stars.count(3)\\n count_2 = sql.stars.count(2)\\n count_1 = sql.stars.count(1)\\n fav_count = (model.preds == 1).sum()\\n unfav_count = (model.preds == 0).sum()\\n avg_wts = int(100*sum(nlp.avg_wts) / len(nlp.avg_wts))\\n bus_tup = (bus_id, name, city, country, old_rating, new_rating,\\n rev_count, count_5, count_4, count_3, count_2, count_1,\\n fav_count, unfav_count, avg_wts)\\n sql.insert(bus_tup)\\n print bus_tup\",\n \"def update_priority(self, indexes, values):\\n values = values * 10000\\n values = self._clip_p(values)\\n values = int(values)\\n self.sum_tree.update(indexes, values)\",\n \"def load_presn_runs(offset, limit):\\n now_local = datetime.now()\\n timelimit = timedelta(hours=100)\\n server = couchdb.Server(\\\"http://snoplus:\\\"+app.config[\\\"COUCHDB_PASSWORD\\\"]+\\\"@\\\"+app.config[\\\"COUCHDB_HOSTNAME\\\"])\\n db = server[\\\"pre-supernova\\\"]\\n results = []\\n skip = offset\\n all = db.view('_design/presn/_view/presn_by_date_run', descending=True, skip=skip)\\n total = all.total_rows\\n offset = all.offset\\n for row in db.view('_design/presn/_view/presn_by_date_run', descending=True, limit=limit, skip=skip):\\n year = row.key[0]\\n mon = row.key[1]\\n day = row.key[2]\\n hour = row.key[3]\\n minute = row.key[4]\\n sec = row.key[5]\\n run = row.value\\n run_id = row.id\\n runtime=datetime(year, mon, day, hour, minute, sec)\\n timediff = now_local - runtime\\n if timediff<timelimit:\\n try:\\n results.append(dict(db.get(run_id).items()))\\n except KeyError:\\n app.logger.warning(\\\"Code returned KeyError searching for presn information in the couchDB. Run Number: %d\\\" % run)\\n results.sort(reverse=True)\\n return results, total, offset, limit\",\n \"def fill_priority_table(target_table, curs, conn, no_bins=5, no_obs=4):\\n tar_ids = list(target_table['TAR_ID'])\\n no_bins_1 = [no_bins]*len(target_table)\\n noobs_bin_1 = [no_obs]*len(target_table)\\n complete_1 = ['00'*no_bins]*len(target_table)\\n no_bins_2 = [no_bins]*len(target_table)\\n noobs_bin_2 = [no_obs]*len(target_table)\\n complete_2 = ['00'*no_bins]*len(target_table)\\n urgency = [0]*len(target_table)\\n for i in range(0,len(target_table)):\\n item = [tar_ids[i], no_bins_1[i], noobs_bin_1[i], complete_1[i], \\n no_bins_2[i], noobs_bin_2[i], complete_2[i], urgency[i]]\\n connect_database.add_priority_to_database(item, curs, conn)\",\n \"def assign_ground_set_to_equi_salary_partitions(self, num_of_partitions, cardinality_constraint):\\n print('In freelancer salary partition.')\\n costs = set()\\n for user_id in self.E:\\n costs.add(self.cost_vector[user_id])\\n sorted_costs = sorted(list(costs))\\n # each cost is a partition\\n if len(sorted_costs) <= num_of_partitions:\\n self.partitions = defaultdict(dict,{i:{'users':set(), 'k':cardinality_constraint} for i in sorted_costs})\\n else:\\n partition_costs = list(self.split(sorted_costs, num_of_partitions))\\n self.partitions = defaultdict(dict,{i[-1]:{'users':set(), 'k':cardinality_constraint} for i in partition_costs})\\n\\n for user_id in self.E:\\n user_cost = self.cost_vector[user_id] \\n min_val = 0\\n for cost, users in self.partitions.items():\\n max_val = cost\\n if user_cost > min_val and user_cost <= max_val:\\n self.partitions[max_val]['users'].add(user_id)\\n break\\n min_val = max_val\",\n \"def assign_priorities_and_dp(self):\\r\\n taskset_copy = copy(self.taskset)\\r\\n tasks = taskset_copy.sorted_by_crit()\",\n \"def locate(self):\\n \\n #CONNECT TO API\\n api = GoogleV3(api_key = self.google_key)\\n\\n #INITALIZE ARRAY\\n array = []\\n\\n #START GEOCODING ADDRESSES\\n for i in tqdm(range(len(self.df)), desc='Geocoding Addresses'):\\n\\n \\n row = self.df.iloc[i]\\n\\n #GET ADDRESS VARIABLES\\n st_name = row['street_name']\\n st_number = row['house_number']\\n city = row['city']\\n state = row['state/province']\\n listing_number = row['listing_number']\\n zip = row['postal_code']\\n\\n\\n #FORMAT ADDRESS FOR API\\n full_address = str(\\\"{} {},{},{},{}\\\".format(st_number, st_name, city, state, zip))\\n\\n #TRY TO LOCATE WITH GOOGLE\\n try:\\n \\n location = api.geocode(full_address, timeout=10)\\n\\n lat = location.latitude\\n lon = location.longitude\\n \\n\\n info = [lat,lon, listing_number]\\n\\n array.append(info)\\n\\n next \\n\\n #Go to next if you cant locate\\n except:\\n\\n info = [0,0, listing_number]\\n\\n array.append(info)\\n\\n next\\n\\n #CONVERT SERIES TO DATAFRAME\\n geo_data = pd.DataFrame(data = array, columns = ['lat', 'lon', 'listing_number'])\\n \\n #INNER JOIN DATA TO DATAFRAME\\n self.df = pd.merge(self.df, geo_data, on= 'listing_number', how = 'inner')\",\n \"def fill_test_form(data, data_test, fcst, store, dept):\\n c = data_test['Store'] == store\\n c2 = data_test['Dept'] == dept\\n fcst = pd.DataFrame(fcst).rename(columns={0: 'Weekly_Sales'})\\n try:\\n fcst_for_test = data_test[c&c2].set_index('Date').join(fcst, on='Date', how='left', lsuffix='_0', rsuffix='_1').drop(columns='Weekly_Sales_0').Weekly_Sales_1\\n except:\\n start = pivot_df(data, dept).index[-1] + relativedelta(weeks=1)\\n idx = pd.DatetimeIndex(start=start, periods=len(fcst), freq='W-FRI')\\n fcst.index = idx \\n fcst_for_test = data_test[c&c2].set_index('Date').join(fcst, on='Date', how='left', lsuffix='_0', rsuffix='_1').drop(columns='Weekly_Sales_0').Weekly_Sales_1\\n data_test.loc[c&c2,'Weekly_Sales'] = fcst_for_test.values\\n c = np.where(data_test['Weekly_Sales'] > 0)[0]\\n return data_test\",\n \"def improve_population(self):\\r\\n for index in range(len(self.district_population)):\\r\\n district = self.district_population[index]\\r\\n districtsolution = hillclimber.HillClimber(district, self.cable_cost, self.battery_cost)\\r\\n self.district_population[index] = districtsolution.run(1000, 80000)\\r\\n self.cost_populations[index] = district.total_cost(self.battery_cost, self.cable_cost)\",\n \"def weekly_limit(self, weekly_limit):\\n\\n self._weekly_limit = weekly_limit\",\n \"def ingest_all(self):\\n\\t\\tfor place in self.district_codes():\\n\\t\\t\\tself.sequence_ingest(place)\\n\\t\\tif self.edition:\\n\\t\\t\\tconfigs.userconfig.update('PHE','latest_cases',self.edition)\",\n \"def set_dns_names(self):\\n log.info(\\\"Collecting NetBox IP address objects to set DNS Names.\\\")\\n # Grab all the IPs from NetBox related tagged from the vCenter host\\n ip_objs = self.request(\\n req_type=\\\"get\\\", nb_obj_type=\\\"ip_addresses\\\",\\n query=\\\"?tag={}\\\".format(format_slug(self.vc_tag))\\n )[\\\"results\\\"]\\n log.info(\\\"Collected %s NetBox IP address objects.\\\", ip_objs)\\n # We take the IP address objects and make a map of relevant details to\\n # compare against and use later\\n nb_objs = {}\\n for obj in ip_objs:\\n ip = obj[\\\"address\\\"].split(\\\"/\\\")[0]\\n nb_objs[ip] = {\\n \\\"id\\\": obj[\\\"id\\\"],\\n \\\"dns_name\\\": obj[\\\"dns_name\\\"]\\n }\\n ips = [ip[\\\"address\\\"].split(\\\"/\\\")[0] for ip in ip_objs]\\n ptrs = queue_dns_lookups(ips)\\n # Having collected the IP address objects from NetBox already we can\\n # avoid individual checks for updates by comparing the objects and ptrs\\n log.info(\\\"Comparing latest PTR records against existing NetBox data.\\\")\\n for ip, ptr in ptrs:\\n if ptr != nb_objs[ip][\\\"dns_name\\\"]:\\n log.info(\\n \\\"Mismatch! The latest PTR for '%s' is '%s' while NetBox \\\"\\n \\\"has '%s'. Requesting update.\\\", ip, ptr,\\n nb_objs[ip][\\\"dns_name\\\"]\\n )\\n self.request(\\n req_type=\\\"patch\\\", nb_obj_type=\\\"ip_addresses\\\",\\n nb_id=nb_objs[ip][\\\"id\\\"], data={\\\"dns_name\\\": ptr}\\n )\\n else:\\n log.info(\\\"NetBox has the latest PTR for '%s'. Moving on.\\\", ip)\",\n \"def set_all_pins(self, ap):\\n self.allpins = ap\",\n \"def forc_model(self):\\n lag1_loc = self.X[self.model_mask_cols].columns.get_loc('shrink_value_per_day_lag1_by_store')\\n lag2_loc = self.X[self.model_mask_cols].columns.get_loc('shrink_value_per_day_lag2_by_store')\\n for add in self.X.address1.unique():\\n add_mask = self.X.address1 == add\\n foo = self.X[ add_mask ].sort_values('visit_date', ascending=False)\\n top_index = foo.index[0]\\n clust = int(foo.cluster.values[0])\\n # get values from last visit for store\\n base_input = foo[self.model_mask_cols].values[0]\\n base_actual = self.y[top_index]\\n lag2_val = base_input[lag1_loc]\\n lag1_val = base_actual\\n\\n for i in range(1, self.num_periods + 1):\\n model = self.model_list[clust]\\n inputs = base_input\\n inputs[lag1_loc] = lag1_val\\n inputs[lag2_loc] = lag2_val\\n \\n pred = model.predict(inputs.reshape(1, -1))\\n self._update_cust_table(add, i, pred)\\n \\n lag2_val = lag1_val\\n lag1_val = pred\",\n \"def update(self):\\n self.entries = Entry.objects.filter(contest=self.contest)\\n self.lineups = [e.lineup for e in self.entries]\\n self.lineup_players = lineup.models.Player.objects.filter(lineup__in=self.lineups)\\n\\n # add players to the data with an initial count of 1.\\n # increment a players count if they already exist\\n self.player_counter = Counter([p.player.srid for p in self.lineup_players]).items()\",\n \"def _test_auto_assign_one_hundred_and_fifty(self):\\n shifts = []\\n for i in range(150):\\n shifts.append(\\n RegularWorkshift.objects.create(\\n workshift_type=self.wtype1,\\n pool=self.p1,\\n hours=5,\\n )\\n )\\n for i in range(1, 150):\\n User.objects.create_user(username=\\\"u{0}\\\".format(i))\\n\\n utils.make_workshift_pool_hours(semester=self.semester)\\n unfinished = utils.auto_assign_shifts(self.semester)\\n self.assertEqual([], unfinished)\\n for shift in shifts:\\n self.assertEqual(1, shift.current_assignees.count())\",\n \"def addQueryArp(self, num=1):\\n self.query_arp += num\",\n \"def resAlloc(self,band):\\n schd = self.schType[0:2]\\n if schd=='PF' and len(list(self.ues.keys()))>0:\\n exp_num = float(self.schType[2])\\n exp_den = float(self.schType[3])\\n self.setUEfactor(exp_num, exp_den)\\n maxInd = self.findMaxFactor()\\n for ue in list(self.ues.keys()):\\n if ue == maxInd:\\n self.ues[ue].prbs = band\\n else:\\n self.ues[ue].prbs = 0\\n if len(self.ues[ue].pastTbsz)>self.promLen:\\n self.ues[ue].pastTbsz.popleft()\\n self.ues[ue].pastTbsz.append(self.ues[ue].tbsz)\\n self.ues[ue].tbsz = 1\\n # Print Resource Allocation\\n self.printResAlloc()\",\n \"def prep_info_all_sites(info_all_sites):\\n \\n info_all_sites = info_all_sites.copy()\\n info_all_sites['GSCNQUAL_max'] = info_all_sites[['GSCNQUAL_ipscore','GSCNQUAL_hipsci_fib']].max(axis =1)\\n\\n info_filt, filt_all_ind, info_all_sites = info_all_sites.pipe(filter_info, qual_thresh_dup=12, qual_thresh_del=2, qual_thresh_mcnv=14, qual_col = 'GSCNQUAL_max')\\n \\n \\n return info_all_sites, info_filt\",\n \"def assign_heat_rates_to_projects(generators, year):\\n\\n fuels = {\\n 'LFG':'Bio_Gas',\\n 'OBG':'Bio_Gas',\\n 'AB':'Bio_Solid',\\n 'BLQ':'Bio_Liquid',\\n 'NG':'Gas',\\n 'OG':'Gas',\\n 'PG':'Gas',\\n 'DFO':'DistillateFuelOil',\\n 'JF':'ResidualFuelOil',\\n 'COAL':'Coal',\\n 'GEO':'Geothermal',\\n 'NUC':'Uranium',\\n 'PC':'Coal',\\n 'SUN':'Solar',\\n 'WDL':'Bio_Liquid',\\n 'WDS':'Bio_Solid',\\n 'MSW':'Bio_Solid',\\n 'PUR':'Purchased_Steam',\\n 'WH':'Waste_Heat',\\n 'OTH':'Other',\\n 'WAT':'Water',\\n 'MWH':'Electricity',\\n 'WND':'Wind'\\n }\\n generators = generators.replace({'Energy Source':fuels})\\n\\n existing_gens = generators[generators['Operational Status']=='Operable']\\n print \\\"-------------------------------------\\\"\\n print \\\"There are {} existing thermal projects that sum up to {:.1f} GW.\\\".format(\\n len(existing_gens[existing_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]),\\n existing_gens[existing_gens['Prime Mover'].isin(['CC','GT','IC','ST'])][\\n 'Nameplate Capacity (MW)'].sum()/1000)\\n heat_rate_data = pd.read_csv(\\n os.path.join('processed_data','historic_heat_rates_WIDE.tab'), sep='\\\\t').rename(\\n columns={'Plant Code':'EIA Plant Code'})\\n heat_rate_data = heat_rate_data[heat_rate_data['Year']==year]\\n heat_rate_data = heat_rate_data.replace({'Energy Source':fuels})\\n thermal_gens = pd.merge(\\n existing_gens, heat_rate_data[['EIA Plant Code','Prime Mover','Energy Source','Best Heat Rate']],\\n how='left', suffixes=('',''),\\n on=['EIA Plant Code','Prime Mover','Energy Source']).drop_duplicates()\\n\\n thermal_gens = thermal_gens[thermal_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\\n\\n # Replace null and unrealistic heat rates by average values per technology,\\n # fuel, and vintage. Also, set HR of top and bottom .5% to max and min\\n null_heat_rates = thermal_gens['Best Heat Rate'].isnull()\\n unrealistic_heat_rates = (((thermal_gens['Energy Source'] == 'Coal') &\\n (thermal_gens['Best Heat Rate'] < 8.607)) |\\n ((thermal_gens['Energy Source'] != 'Coal') &\\n (thermal_gens['Best Heat Rate'] < 6.711)))\\n print \\\"{} generators don't have heat rate data specified ({:.1f} GW of capacity)\\\".format(\\n len(thermal_gens[null_heat_rates]), thermal_gens[null_heat_rates]['Nameplate Capacity (MW)'].sum()/1000.0)\\n print \\\"{} generators have better heat rate than the best historical records ({} GW of capacity)\\\".format(\\n len(thermal_gens[unrealistic_heat_rates]), thermal_gens[unrealistic_heat_rates]['Nameplate Capacity (MW)'].sum()/1000.0)\\n thermal_gens_w_hr = thermal_gens[~null_heat_rates & ~unrealistic_heat_rates]\\n thermal_gens_wo_hr = thermal_gens[null_heat_rates | unrealistic_heat_rates]\\n\\n # Print fuels and technologies with missing HR to console\\n\\n # for fuel in thermal_gens_wo_hr['Energy Source'].unique():\\n # print \\\"{} of these use {} as their fuel\\\".format(\\n # len(thermal_gens_wo_hr[thermal_gens_wo_hr['Energy Source']==fuel]),fuel)\\n # print \\\"Technologies:\\\"\\n # for prime_mover in thermal_gens_wo_hr[thermal_gens_wo_hr['Energy Source']==fuel]['Prime Mover'].unique():\\n # print \\\"\\\\t{} use {}\\\".format(\\n # len(thermal_gens_wo_hr[(thermal_gens_wo_hr['Energy Source']==fuel) &\\n # (thermal_gens_wo_hr['Prime Mover']==prime_mover)]),prime_mover)\\n \\n print \\\"-------------------------------------\\\"\\n print \\\"Assigning max/min heat rates per technology and fuel to top .5% / bottom .5%, respectively:\\\"\\n n_outliers = int(len(thermal_gens_w_hr)*0.008)\\n thermal_gens_w_hr = thermal_gens_w_hr.sort_values('Best Heat Rate')\\n min_hr = thermal_gens_w_hr.loc[thermal_gens_w_hr.index[n_outliers],'Best Heat Rate']\\n max_hr = thermal_gens_w_hr.loc[thermal_gens_w_hr.index[-1-n_outliers],'Best Heat Rate']\\n print \\\"(Total capacity of these plants is {:.1f} GW)\\\".format(\\n thermal_gens_w_hr[thermal_gens_w_hr['Best Heat Rate'] < min_hr]['Nameplate Capacity (MW)'].sum()/1000.0 +\\n thermal_gens_w_hr[thermal_gens_w_hr['Best Heat Rate'] > max_hr]['Nameplate Capacity (MW)'].sum()/1000.0)\\n print \\\"Minimum heat rate is {:.3f}\\\".format(min_hr)\\n print \\\"Maximum heat rate is {:.3f}\\\".format(max_hr)\\n for i in range(n_outliers):\\n thermal_gens_w_hr.loc[thermal_gens_w_hr.index[i],'Best Heat Rate'] = min_hr\\n thermal_gens_w_hr.loc[thermal_gens_w_hr.index[-1-i],'Best Heat Rate'] = max_hr\\n\\n\\n def calculate_avg_heat_rate(thermal_gens_df, prime_mover, energy_source, vintage, window=2):\\n similar_generators = thermal_gens_df[\\n (thermal_gens_df['Prime Mover']==prime_mover) &\\n (thermal_gens_df['Energy Source']==energy_source) &\\n (thermal_gens_df['Operating Year']>=vintage-window) &\\n (thermal_gens_df['Operating Year']<=vintage+window)]\\n while len(similar_generators) < 4:\\n window += 2\\n similar_generators = thermal_gens_df[\\n (thermal_gens_df['Prime Mover']==prime_mover) &\\n (thermal_gens_df['Energy Source']==energy_source) &\\n (thermal_gens_df['Operating Year']>=vintage-window) &\\n (thermal_gens_df['Operating Year']<=vintage+window)]\\n # Gens span from 1925 to 2015, so a window of 90 years is the maximum\\n if window >= 90:\\n break\\n if len(similar_generators) > 0:\\n return similar_generators['Best Heat Rate'].mean()\\n else:\\n # If no other similar projects exist, return average of technology\\n return thermal_gens_df[thermal_gens_df['Prime Mover']==prime_mover]['Best Heat Rate'].mean()\\n\\n\\n print \\\"-------------------------------------\\\"\\n print \\\"Assigning average heat rates per technology, fuel, and vintage to projects w/o heat rate...\\\"\\n for idx in thermal_gens_wo_hr.index:\\n pm = thermal_gens_wo_hr.loc[idx,'Prime Mover']\\n es = thermal_gens_wo_hr.loc[idx,'Energy Source']\\n v = thermal_gens_wo_hr.loc[idx,'Operating Year']\\n #print \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\".format(pm,es,v,calculate_avg_heat_rate(thermal_gens_w_hr, pm, es, v))\\n thermal_gens_wo_hr.loc[idx,'Best Heat Rate'] = calculate_avg_heat_rate(\\n thermal_gens_w_hr, pm, es, v)\\n\\n thermal_gens = pd.concat([thermal_gens_w_hr, thermal_gens_wo_hr], axis=0)\\n existing_gens = pd.merge(existing_gens, thermal_gens, on=list(existing_gens.columns), how='left')\\n\\n\\n # Plot histograms for resulting heat rates per technology and fuel\\n thermal_gens[\\\"Technology\\\"] = thermal_gens[\\\"Energy Source\\\"].map(str) + ' ' + thermal_gens[\\\"Prime Mover\\\"]\\n p = ggplot(aes(x='Best Heat Rate',fill='Technology'), data=thermal_gens) + geom_histogram(binwidth=0.5) + facet_wrap(\\\"Technology\\\") + ylim(0,30)\\n p.save(os.path.join(outputs_directory,'heat_rate_distributions.pdf'))\\n\\n proposed_gens = generators[generators['Operational Status']=='Proposed']\\n thermal_proposed_gens = proposed_gens[proposed_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\\n other_proposed_gens = proposed_gens[~proposed_gens['Prime Mover'].isin(['CC','GT','IC','ST'])]\\n print \\\"There are {} proposed thermal projects that sum up to {:.2f} GW.\\\".format(\\n len(thermal_proposed_gens), thermal_proposed_gens['Nameplate Capacity (MW)'].sum()/1000)\\n print \\\"Assigning average heat rate of technology and fuel of most recent years...\\\"\\n for idx in thermal_proposed_gens.index:\\n pm = thermal_proposed_gens.loc[idx,'Prime Mover']\\n es = thermal_proposed_gens.loc[idx,'Energy Source']\\n #print \\\"{}\\\\t{}\\\\t{}\\\\t{}\\\".format(pm,es,v,calculate_avg_heat_rate(thermal_gens_w_hr, pm, es, v))\\n thermal_proposed_gens.loc[idx,'Best Heat Rate'] = calculate_avg_heat_rate(\\n thermal_gens_w_hr, pm, es, year)\\n\\n other_proposed_gens['Best Heat Rate'] = float('nan')\\n proposed_gens = pd.concat([thermal_proposed_gens,other_proposed_gens], axis=0)\\n\\n return pd.concat([existing_gens, proposed_gens], axis=0)\",\n \"def __add_homes(self):\\n for home in self.__positions_of_homes:\\n self.__grid[home[0]][home[1]][\\\"humans\\\"] = math.floor(\\n self.__number_of_humans / self.__number_of_homes\\n )\",\n \"def pagerank(self, limit=20):\\r\\n\\t\\tfor urlid in self.url_ids:\\r\\n\\t\\t\\tself.all_scores[urlid] = 1.0\\r\\n\\r\\n\\t\\tfor i in range(limit):\\r\\n\\t\\t\\tfor urlid in self.url_ids:\\r\\n\\t\\t\\t\\tscore = self.all_scores[urlid]\\r\\n\\t\\t\\t\\tfor fromid in self.from_ids[urlid]:\\r\\n\\t\\t\\t\\t\\tscore += self.all_scores[fromid] / \\\\\\r\\n\\t\\t\\t\\t\\t\\t\\t (len(self.from_ids[fromid])+len(self.to_ids[fromid]))\\r\\n\\t\\t\\t\\tscore *= 0.85\\r\\n\\t\\t\\t\\tscore += 0.15\\r\\n\\t\\t\\t\\tself.all_scores[urlid] = score\\r\\n\\t\\tself.save_pr()\",\n \"def load_street_address(data):\\n street_addresses = [address['address1'] for address in data]\\n street_address_objects = [StreetAddress(data=street_address)\\n for street_address\\n in street_addresses]\\n StreetAddress.objects.bulk_create(street_address_objects)\",\n \"def update_reported_taps(taps):\\n store_formula_list(formula_list=taps, file_path=REPORTED_TAPS_FILE)\",\n \"def process(self):\\n\\t\\tif self.update_check() or self.force_update:\\n\\t\\t\\tself.district_check() #pull all local data and regions\\n\\t\\t\\tself.fix() #fix data anomalies - e.g add in Bucks.\\n\\t\\t\\tself.save_all() #store a copy of the data\\n\\t\\t\\tself.ingest() #add data to models\\n\\t\\t\\tself.update_totals() #calculate weekly data\\n\\t\\telse:\\n\\t\\t\\tlog.info('PHE cases up to date')\",\n \"def prepare_company_data(self, month, year, row, company_data):\\n for key, value in row.items():\\n if not company_data[key]:\\n company_data[key] = {'year':year, 'month':month, 'value':value}\\n else:\\n \\\"\\\"\\\"main operation updating the company's data per year\\n and month vise \\\"\\\"\\\"\\n company_data[key].update({'year':year, 'month':month, 'value':value})\\\\\\n if company_data[key]['value'] < value else None\",\n \"def optimize_on_n_cops(self):\\n self.optimize_on_target_profiles()\\n max_revenue = -INF\\n while self.get_revenue_per_hour() >= max_revenue:\\n max_revenue = self.get_revenue_per_hour()\\n prev_target_profiles = self.target_profiles\\n self.cops += 1\\n self.optimize_on_target_profiles()\\n self.cops -= 1\\n self.target_profiles = prev_target_profiles\\n self.target_profile = reduce(lambda x, y: x + y, self.target_profiles)\",\n \"def optimize_best(self, population, evo_num):\\n evo_at_least = settings[\\\"phone_optimize\\\"][\\\"evo_at_least\\\"]\\n evo_frequency = settings[\\\"phone_optimize\\\"][\\\"evo_frequency\\\"]\\n if((evo_num >= evo_at_least) and (evo_num % evo_frequency == 0)):\\n self.population = self.phone_opt.run_genetic(self.population,0)# call main function in PhoneOptimize once ready.\\n map(lambda c: c.set_results(None), population)\\n return population\",\n \"def _test_pre_fill_and_assign_humor(self):\\n for i in range(1, 50):\\n User.objects.create_user(username=\\\"u{0}\\\".format(i))\\n pre_fill.main([\\\"--managers\\\", \\\"--workshift\\\"])\\n utils.make_workshift_pool_hours(semester=self.semester)\\n # Assign manager shifts beforehand\\n manager_shifts = RegularWorkshift.objects.filter(\\n pool=self.p1, workshift_type__auto_assign=False,\\n )\\n profiles = WorkshiftProfile.objects.all()\\n for profile, shift in zip(profiles, manager_shifts):\\n shift.current_assignees.add(profile)\\n shift.save()\\n unfinished = utils.auto_assign_shifts(\\n self.semester, pool=WorkshiftPool.objects.get(title=\\\"Humor Shift\\\")\\n )\\n self.assertEqual([], unfinished)\",\n \"def _load_preps(self, context: 'IconScoreContext'):\\n icx_storage: 'IcxStorage' = context.storage.icx\\n\\n for prep in context.storage.prep.get_prep_iterator():\\n account: 'Account' = icx_storage.get_account(context, prep.address, Intent.ALL)\\n\\n prep.stake = account.stake\\n prep.delegated = account.delegated_amount\\n\\n self.preps.add(prep)\\n\\n self.preps.freeze()\",\n \"def planned(self, planned):\\n\\n self._planned = planned\",\n \"def setUp(self):\\n N = 10\\n pA = 0.5\\n pB = 0.5\\n qA = 1 - pA\\n qB = 1 - pB\\n locus_A = (['A'] * int(N * pA)) + (['a'] * int(round(N * qA)))\\n locus_B = (['B'] * int(N * pB)) + (['b'] * int(round(N * qB)))\\n self.pop = population.Population(N, locus_A, locus_B)\",\n \"def array_update(self, table_list):\\r\\n for tbl in table_list:\\r\\n x = kit.SQL_pull('name, subject_id', tbl)\\r\\n r = {i[0]: i[1] for i in x}\\r\\n h = {i[1]: tbl for i in x}\\r\\n \\r\\n self.refference.update(r)\\r\\n self.home_table.update(h)\\r\\n \\r\\n self.counts[tbl] = len(x)\",\n \"def test_place(self):\\n places = self.geographies.find({ 'geoid': '1562600' })\\n\\n self.assertEqual(places.count(), 1)\\n\\n place = places[0]\\n\\n self.assertEqual(place['sumlev'], config.SUMLEV_PLACE)\\n self.assertEqual(place['metadata']['NAME'], 'Pearl City CDP')\\n self.assertEqual(place['metadata']['STATE'], '15')\\n self.assertEqual(place['metadata']['PLACE'], '62600')\\n\\n pop_2000 = 30976\\n pop_2010 = 47698 \\n self._test_totalpop(place, pop_2000, pop_2010)\",\n \"def adjust(loanbook):\\n\\n # get names of AG8 columns\\n ag8_cols = [x for x in loanbook.columns if 'adjust' in x.lower()]\\n\\n # remove NaN values from AG8 columns\\n for col in ag8_cols:\\n loanbook[col] = pd.Series(loanbook[col].fillna(0),\\n index=loanbook.index)\\n\\n return loanbook\",\n \"def SetPRBinConstraint(self, model ) :\\n tot = np.multiply(self.wish, self.dispo)\\n for val in tot :\\n if not val : continue\\n if self.bound>0 : model += val <= self.valBound\\n elif self.bound<0 : model += val >= self.valBound\",\n \"def prepare(self, popSize, evaluate):\\n for i in range(popSize):\\n member = Member(self.memberLength, self.lowerDomain, self.upperDomain, self.memberDataType)\\n member.loss = evaluate(member.rep)\\n self.population.append(member)\\n if (self.eliteLoss is None) or (self.eliteLoss > member.loss):\\n self.eliteLoss = member.loss\\n self.eliteIndex = i\\n elif (self.diversityLoss is None) or (self.diversityLoss < member.loss):\\n self.diversityLoss = member.loss\\n self.diversityIndex = i\",\n \"def __data_set_is_payday_positive_08_09_10(cls):\\n _pay_cycle_object = pay_cycle_object()\\n date_to_check = date_class(2020,1,10)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\\n\\n date_to_check = date_class(2020,1,24)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\\n\\n date_to_check = date_class(2022,10,14)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\",\n \"def run_past_matches(self):\\n for year in self.store.years:\\n # print(year)\\n for event in self.store.events[year]:\\n for match in self.store.matches[year][event.key]:\\n red_alliance = match.red_alliance\\n blue_alliance = match.blue_alliance\\n\\n for team in red_alliance + blue_alliance:\\n if team not in self.scores.keys():\\n self.scores[team] = self.default_score\\n\\n prediction = self.predict(red_alliance, blue_alliance, key=match.key)\\n self.update_score(red_alliance, blue_alliance, prediction,\\n match.red_score, match.blue_score)\",\n \"def __data_set_is_payday_positive_05_06_07(cls):\\n _pay_cycle_object = pay_cycle_object()\\n date_to_check = date_class(2019,11,1)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\\n\\n date_to_check = date_class(2019,11,29)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\\n\\n date_to_check = date_class(2019,12,13)\\n cls.TEST_DATA_SET.append((_pay_cycle_object, date_to_check, True))\",\n \"def check_point_update(self):\\n self.cp_count += 1\\n\\n if len(self.cases) > self.nyquist:\\n \\\"\\\"\\\"\\n Recalculates nyquist, releases cases and updates model (merges graphs)\\n \\\"\\\"\\\"\\n self.release_cases_from_memory()\\n if self.check_point_cases > 5:\\n self.nyquist = self.check_point_cases * 2\\n\\n check_point_graph = initialize_graph(nx.DiGraph(), self.cases)\\n self.process_model_graph = merge_graphs(self.process_model_graph, check_point_graph)\\n\\n self.check_point_cases = 0\",\n \"def addStake(self, address: str, value_USDC: int, value_eXRD: int, value_LP: int):\\n addr = address.lower()\\n balances = self.addresses[addr] if addr in self.addresses else []\\n balances.append({\\n 'USDC': value_USDC,\\n 'eXRD': value_eXRD,\\n 'LP': value_LP\\n })\\n self.addresses[addr] = balances\",\n \"def set_penalty_start_eventnums(self):\\n for period in self.Periods:\\n period.PenaltyStartEventNums = {self.HomeTeamId: None, self.VisitorTeamId: None}\\n if period.Number <= 4:\\n fouls_to_give = {self.HomeTeamId: 4, self.VisitorTeamId: 4}\\n else:\\n # in overtime periods teams start with 3 fouls to give\\n fouls_to_give = {self.HomeTeamId: 3, self.VisitorTeamId: 3}\\n\\n for event in period.Events:\\n if event.is_foul_that_counts_toward_penalty():\\n foul_team = event.team_id\\n event_time = event.seconds_remaining\\n if event_time <= 120 and fouls_to_give[foul_team] > 1:\\n # only 1 foul to give in final 2 minutes regardless of how many fouls committed up until then\\n fouls_to_give[foul_team] = 1\\n if fouls_to_give[foul_team] > 0:\\n fouls_to_give[foul_team] -= 1\\n if fouls_to_give[foul_team] == 0:\\n # team entered penalty on this foul\\n if 'Shooting' in event.get_foul_type():\\n # shooting foul - start tracking at final ft so we don't count FTs as penalty\\n final_fts_at_time_of_foul = [\\n pbp_event for pbp_event in period.Events\\n if pbp_event.seconds_remaining == event_time and\\n pbp_event.team_id != foul_team and\\n (pbp_event.is_ft_1_of_1() or pbp_event.is_ft_2_of_2() or pbp_event.is_ft_3_of_3())\\n ]\\n if len(final_fts_at_time_of_foul) == 0:\\n # Example of when this happens: lane violation\\n # just use last event that occured at time of foul\\n events_at_time_of_foul = [\\n pbp_event for pbp_event in period.Events\\n if pbp_event.seconds_remaining == event_time\\n ]\\n start_event = events_at_time_of_foul[-1].order\\n elif final_fts_at_time_of_foul[-1].is_missed_ft():\\n # if FT is missed need to see if it was oreb or dreb\\n rebounds_after_ft = [\\n pbp_event for pbp_event in period.Events\\n if pbp_event.order > event.order and\\n pbp_event.is_rebound()\\n ]\\n # use first rebound after missed FT as bonus start event\\n start_event = rebounds_after_ft[0].order\\n else:\\n # use last FT as bonus start event\\n start_event = final_fts_at_time_of_foul[-1].order\\n else:\\n # non shooting foul - start tracking bonus at this event\\n start_event = event.order\\n offense_team = utils.swap_team_id_for_game(foul_team, [self.HomeTeamId, self.VisitorTeamId])\\n period.PenaltyStartEventNums[offense_team] = start_event\",\n \"def insert_humans_staging(self):\\n for year in range(1880, CURRENT_YEAR):\\n self.load_wikidata(\\\"humans\\\", HUMANS_BY_YEAR_SPARQL_QUERY, INSERT_HUMAN_SQL_QUERY,\\n INSERT_HUMAN_MAP_COLUMNS, year=year)\",\n \"def test_ipam_vlans_update(self):\\n pass\",\n \"def main(self):\\n results = []\\n for t in Config.APPHOSTS:\\n custom_domain = t[\\\"custom_domain\\\"]\\n heroku_host = t[\\\"heroku_host\\\"]\\n result = self.ip_update(custom_domain, heroku_host)\\n results.append(result)\\n return results\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63330156","0.53173107","0.49326813","0.49134898","0.48076132","0.47747403","0.47253653","0.46731806","0.46633682","0.46196696","0.4618803","0.46049136","0.45915735","0.4584027","0.45573524","0.45506656","0.45506567","0.45332375","0.45256045","0.4525433","0.45152608","0.45083424","0.44994208","0.44865313","0.44571888","0.44444034","0.44289398","0.44143116","0.44124472","0.44118905","0.44026002","0.44000936","0.4397657","0.43942764","0.43880376","0.4380867","0.43745732","0.43736035","0.4371118","0.4368809","0.43622968","0.4333598","0.43332106","0.43232068","0.43204898","0.43181813","0.43126747","0.43116984","0.43090364","0.4308517","0.43066648","0.43018714","0.43007708","0.43005365","0.42971107","0.42967582","0.42916837","0.4285558","0.42787424","0.42775074","0.42774737","0.4276319","0.4273905","0.42606595","0.4255089","0.42463818","0.42339116","0.42324638","0.42312092","0.42311734","0.42284882","0.42284712","0.42196932","0.4217102","0.421636","0.4210248","0.42082298","0.42073873","0.42068163","0.42060816","0.42055377","0.42052722","0.41975832","0.41939718","0.41918793","0.41877162","0.41866648","0.4185886","0.41742015","0.41677144","0.41664758","0.41612023","0.41598624","0.41591504","0.4159133","0.41583535","0.41574797","0.4154522","0.41534516","0.41518816"],"string":"[\n \"0.63330156\",\n \"0.53173107\",\n \"0.49326813\",\n \"0.49134898\",\n \"0.48076132\",\n \"0.47747403\",\n \"0.47253653\",\n \"0.46731806\",\n \"0.46633682\",\n \"0.46196696\",\n \"0.4618803\",\n \"0.46049136\",\n \"0.45915735\",\n \"0.4584027\",\n \"0.45573524\",\n \"0.45506656\",\n \"0.45506567\",\n \"0.45332375\",\n \"0.45256045\",\n \"0.4525433\",\n \"0.45152608\",\n \"0.45083424\",\n \"0.44994208\",\n \"0.44865313\",\n \"0.44571888\",\n \"0.44444034\",\n \"0.44289398\",\n \"0.44143116\",\n \"0.44124472\",\n \"0.44118905\",\n \"0.44026002\",\n \"0.44000936\",\n \"0.4397657\",\n \"0.43942764\",\n \"0.43880376\",\n \"0.4380867\",\n \"0.43745732\",\n \"0.43736035\",\n \"0.4371118\",\n \"0.4368809\",\n \"0.43622968\",\n \"0.4333598\",\n \"0.43332106\",\n \"0.43232068\",\n \"0.43204898\",\n \"0.43181813\",\n \"0.43126747\",\n \"0.43116984\",\n \"0.43090364\",\n \"0.4308517\",\n \"0.43066648\",\n \"0.43018714\",\n \"0.43007708\",\n \"0.43005365\",\n \"0.42971107\",\n \"0.42967582\",\n \"0.42916837\",\n \"0.4285558\",\n \"0.42787424\",\n \"0.42775074\",\n \"0.42774737\",\n \"0.4276319\",\n \"0.4273905\",\n \"0.42606595\",\n \"0.4255089\",\n \"0.42463818\",\n \"0.42339116\",\n \"0.42324638\",\n \"0.42312092\",\n \"0.42311734\",\n \"0.42284882\",\n \"0.42284712\",\n \"0.42196932\",\n \"0.4217102\",\n \"0.421636\",\n \"0.4210248\",\n \"0.42082298\",\n \"0.42073873\",\n \"0.42068163\",\n \"0.42060816\",\n \"0.42055377\",\n \"0.42052722\",\n \"0.41975832\",\n \"0.41939718\",\n \"0.41918793\",\n \"0.41877162\",\n \"0.41866648\",\n \"0.4185886\",\n \"0.41742015\",\n \"0.41677144\",\n \"0.41664758\",\n \"0.41612023\",\n \"0.41598624\",\n \"0.41591504\",\n \"0.4159133\",\n \"0.41583535\",\n \"0.41574797\",\n \"0.4154522\",\n \"0.41534516\",\n \"0.41518816\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5096449"},"document_rank":{"kind":"string","value":"2"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":846,"numItemsPerPage":100,"numTotalItems":95772,"offset":84600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAxMjE1MiwianRpIjoiNGU3MzI2NjEtZDdhYy00YzI4LTg5N2MtZWM5YzIxNThjYmZiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMTU3NTIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.sPzmw5JtYw1yrU9hKT7oWjf161vjTHlVDp7mS3DVcM-jqAQAUqvwVJC8m-O2-27SmTDKkb0F6b-zojGWiiR_CA","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 |
|---|---|---|---|---|---|---|
Process IMU data in realtime. | def process_imu(
self,
im_data: np.ndarray,
accel: bool = False,
squared: bool = False,
norm_min_bound: int = None,
norm_max_bound: int = None,
**kwargs,
) -> np.ndarray:
self.update_signal_processing_parameters(**kwargs)
tic = time.time()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imu_callback(self, msg):\n self.mutex.acquire()\n\n self.ni[3] = msg.angular_rate.x\n self.ni[4] = msg.angular_rate.y\n self.ni[5] = msg.angular_rate.z\n\n self.eta2[0] = msg.orientation.roll\n self.eta2[1] = msg.orientation.pitch\n self.eta2[2] = msg.orientatio... | [
"0.63551223",
"0.6044613",
"0.58962166",
"0.5722179",
"0.5667444",
"0.5629212",
"0.5587109",
"0.55798817",
"0.5566661",
"0.55389005",
"0.55101794",
"0.55088514",
"0.5492298",
"0.5483712",
"0.5476294",
"0.5472477",
"0.54616934",
"0.5400902",
"0.5393032",
"0.5378483",
"0.537767... | 0.5108354 | 48 |
Allow to get the number of peaks for an analog signal (to get cadence from treadmill for instance). | def get_peaks(
self,
new_sample: np.ndarray,
threshold: float,
min_peaks_interval=None,
) -> tuple:
tic = time.time()
nb_peaks = []
if len(new_sample.shape) == 1:
new_sample = np.expand_dims(new_sample, 0)
sample_proc = np.copy(new_sample)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_interval_peak(arr1d, lower, upper):\n from scipy.signal import find_peaks\n peaks = find_peaks(arr1d, height=(lower, upper))\n return len(peaks[0])",
"def count_abs_peak(arr1d, threshold):\n from scipy.signal import find_peaks\n peaks = find_peaks(arr1d, height=threshold)\n return len... | [
"0.6425269",
"0.63765293",
"0.6173016",
"0.61437225",
"0.6119126",
"0.6118085",
"0.61028016",
"0.6076271",
"0.59957093",
"0.59269536",
"0.59211403",
"0.59087247",
"0.5859496",
"0.58115536",
"0.580975",
"0.5803837",
"0.58019924",
"0.5797852",
"0.57864153",
"0.57161665",
"0.570... | 0.0 | -1 |
Allow to apply a custom processing function to the data. | def custom_processing(self, funct: callable, data_tmp: np.ndarray, **kwargs) -> np.ndarray:
tic = time.time()
data_tmp = funct(data_tmp, **kwargs)
self.process_time.append(time.time() - tic)
return data_tmp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_fn(self,fn):\r\n \r\n self.check_Data()\r\n for split,data_ in self.processed_data.items():\r\n x = data_['x']\r\n x = np.array([fn(xi) for xi in x])\r\n data_['x'] = x",
"def _process(self, data: np.ndarray) -> np.ndarray:",
"def _process(self, d... | [
"0.7209119",
"0.71054864",
"0.71054864",
"0.70158184",
"0.67586684",
"0.66956675",
"0.6674667",
"0.6640138",
"0.66138846",
"0.6517365",
"0.64679474",
"0.64604974",
"0.6420236",
"0.6411107",
"0.63475305",
"0.6322858",
"0.63099974",
"0.63018227",
"0.6262167",
"0.6238369",
"0.62... | 0.711315 | 1 |
Compute MVC from several mvc_trials. | def compute_mvc(
nb_muscles: int,
mvc_trials: np.ndarray,
window_size: int,
tmp_file: str = None,
output_file: str = None,
save_file: bool = False,
) -> list:
mvc_list_max = []
for i in range(nb_muscles):
mvc_temp = -np.sort(-mvc_trials, ax... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(cfg: DictConfig):\n\n experiments = cfg.get('experiment_type', f'{cfg.model.name}_only')\n fixed_t0 = cfg.get('fixed_t0', False)\n ext = '_fixedT0' if fixed_t0 else ''\n\n base_dir = cfg.device.root\n datasource = cfg.datasource.name\n\n if experiments == 'ablations':\n models... | [
"0.5545384",
"0.5365183",
"0.53412914",
"0.52675617",
"0.5252825",
"0.52142614",
"0.5210786",
"0.5191421",
"0.5145621",
"0.5120124",
"0.5053513",
"0.5046397",
"0.5045741",
"0.5001172",
"0.4999463",
"0.49868155",
"0.49839026",
"0.49817446",
"0.49579707",
"0.49385127",
"0.49382... | 0.61508936 | 0 |
Batch the graphs and their labels | def collate(samples):
graphs, labels = map(list, zip(*samples))
batched_graphs = dgl.batch(graphs)
labels = torch.tensor(labels) - 1 # correct indexing for loss function
return batched_graphs, torch.tensor(labels) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_num_classes_graphs():\n values = [10, 50, 100, 250, 1000, 4000]\n for num_classes in values:\n print(\"Training model on {} most common classes.\".format(num_classes))\n model = create_pretrained_model(num_classes=num_classes)\n histories = train(model, num_classes, epochs=50)\n... | [
"0.6137908",
"0.6090466",
"0.60618484",
"0.6051165",
"0.60128903",
"0.5991099",
"0.59111774",
"0.59085894",
"0.58944935",
"0.58806723",
"0.5811794",
"0.5777245",
"0.5748763",
"0.57090044",
"0.5706164",
"0.5692337",
"0.56865823",
"0.5674395",
"0.5671464",
"0.56317866",
"0.5592... | 0.0 | -1 |
Calculate weights for imbalanced classes | def calculate_class_weights(labels):
class_counts = sorted(Counter(labels).items())
num_items = [x[1] for x in class_counts]
weights = [min(num_items)/x for x in num_items]
return torch.tensor(weights) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_weights_for_balanced_classes(self):\n\n count = [0] * self.get_num_classes()\n\n # label = self.class_map_dict[self.meta_data.loc[image_id]['dx']]\n # labels = [self.class_map_dict[l] for l in self.get_labels()]\n\n labels = self.get_labels()\n\n # Count how many instanc... | [
"0.81178117",
"0.7981136",
"0.7888464",
"0.7566412",
"0.755265",
"0.74757576",
"0.74142075",
"0.7323989",
"0.72968197",
"0.72783875",
"0.7191527",
"0.7188369",
"0.7066407",
"0.70108426",
"0.68984616",
"0.6767867",
"0.6734354",
"0.6726656",
"0.66751343",
"0.66751343",
"0.66481... | 0.7284698 | 9 |
Delete the minority class, assign its label to the nearest majority class | def handle_imbalance(dataset, minority_class):
for i, l in enumerate(dataset):
if l == minority_class:
dataset[i] = 2
return dataset | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_classification_head(self) -> None:\n del self.model.classifier",
"def majority_class(classes):\n num_pos = len(classes[np.where(classes == 1)])\n num_neg = len(classes) - num_pos\n return 1 if num_pos > num_neg else 0",
"def majority_voting(distances, labels, k):\n nearest_index =... | [
"0.6377702",
"0.5918562",
"0.58172894",
"0.5726421",
"0.56754035",
"0.5635833",
"0.55105144",
"0.55105144",
"0.5506352",
"0.5470802",
"0.54528326",
"0.5444725",
"0.5436435",
"0.5425838",
"0.54167604",
"0.5402758",
"0.53571814",
"0.5312206",
"0.5306321",
"0.5279353",
"0.524258... | 0.61863196 | 1 |
Train and evaluate the model | def main(train, val, test):
wandb.init(project="arg-qual", tags=[args.node_feat, args.quality_dim, str(args.epochs), str(args.lr)])
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
dataloader_train = DataLoader(
trainset,
batch_size=10,
collate_fn=collate,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n\t\tself.model.fit(self.training_data, self.training_labels)",
"def train_and_eval(self):\n self.__create_indexes()\n model = None\n model = None\n if self.model == 'OMult':\n model = OMult(self.kwargs)\n elif self.model == 'ConvO':\n mod... | [
"0.79048234",
"0.7742273",
"0.76403296",
"0.7620212",
"0.75824326",
"0.75720584",
"0.7564726",
"0.75543934",
"0.7538268",
"0.75311756",
"0.7518056",
"0.7497667",
"0.7475786",
"0.745185",
"0.7444781",
"0.74335915",
"0.74037987",
"0.7389051",
"0.73683375",
"0.7365661",
"0.73541... | 0.0 | -1 |
Compute the t statistic and pvalue given the flow results from the neural network and the reference results from Segment. | def t_test(result, reference):
# Check that result and reference are 1D and that they have the same length
print('\nChecking that result and reference are 1D and that they have the same length\n')
if (len(result.shape) == 1) and (len(reference.shape) == 1):
if len(result) == ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_statistics(self):",
"def compute(self) -> Tuple[float, float, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[float] = all_gather(self.statistics[key])\n value: float = sum(value)... | [
"0.62979054",
"0.6090692",
"0.5972948",
"0.57982653",
"0.5781421",
"0.57796174",
"0.57675654",
"0.57660323",
"0.57544434",
"0.57116395",
"0.56900597",
"0.56817675",
"0.5671833",
"0.56601024",
"0.5622097",
"0.5606627",
"0.5601511",
"0.55909044",
"0.55909044",
"0.5583507",
"0.5... | 0.5622872 | 14 |
Compute the sum of rank differences and pvalue given the flow results from the neural network and the reference results from Segment. | def wilcoxon_test(result, reference):
print('\nChecking that result and reference are 1D and that they have the same length\n')
if (len(result.shape) == 1) and (len(reference.shape) == 1):
if len(result) == len(reference):
print('Performing Wilcoxon test\n')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )",
"def _estimate_stats_with_rel_info(self):\r\n ... | [
"0.5938969",
"0.5851452",
"0.576755",
"0.575818",
"0.5751947",
"0.57292646",
"0.5664509",
"0.5663217",
"0.56571037",
"0.5621387",
"0.5558706",
"0.5553662",
"0.5533289",
"0.5519998",
"0.5507834",
"0.5492306",
"0.5474098",
"0.5470863",
"0.54586834",
"0.5452838",
"0.54334104",
... | 0.0 | -1 |
Saves figure in specified folder with a given file name | def figure_saving(dest_path, filename, figure):
print('Checking that a destination path has been given\n')
if dest_path is not None:
if filename[-3:] == 'png' or filename[-3:] == 'PNG':
print('Saving figure as PNG in: {}'.format(dest_path))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(file_name):\n setup()\n plt.savefig(file_name)",
"def save_plot(directory, name = None):\n global global_figure_count \n if directory[-1]!=\"/\":\n directory = directory + \"/\"\n directory_paths = directory.split(\"/\")\n prefix = directory_paths[0]\n for i in directory_p... | [
"0.7718799",
"0.76871973",
"0.76591367",
"0.76588595",
"0.74072856",
"0.73765945",
"0.7316014",
"0.7292513",
"0.7270031",
"0.7248531",
"0.7195906",
"0.71886367",
"0.71471447",
"0.70390975",
"0.7030412",
"0.7016384",
"0.7014492",
"0.69352424",
"0.69344157",
"0.6902748",
"0.690... | 0.7174618 | 12 |
Compute a scatter plot with points and with linear regression equation given the flow results from the neural network and the reference results from Segment or QFLOW software. | def linear_regression_test(result, reference, plotting = True, save = False, dest_path = os.getcwd() + '/', filename = 'regression_plot.png'):
print('\nChecking that result and reference are 1D and that they have the same length\n')
if (len(result.shape) == 1) and (len(reference.shape) == 1):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_scatter(self):\n if Trainer.y_pred is None or Trainer.y_true is None:\n messagebox.showerror(\"Information\", \"Please train the model first before plotting\")\n return\n\n fig = plt.figure(figsize=(8, 4))\n plt.xlabel(\"Prediction\")\n plt.ylabel(\"Target... | [
"0.6615068",
"0.6611525",
"0.6609644",
"0.66071516",
"0.64990884",
"0.63859683",
"0.6262151",
"0.6236126",
"0.621933",
"0.6182744",
"0.6111916",
"0.6104931",
"0.6097538",
"0.60893935",
"0.6044467",
"0.6041235",
"0.60270923",
"0.6026488",
"0.59985936",
"0.5996753",
"0.5991206"... | 0.65941626 | 4 |
Compute the BlandAltman plot for the flow results from the neural network and the reference results from Segment. | def bland_altman_plot(result, reference, save = False, dest_path = os.getcwd() + '/', filename = 'bland_altman_plot.png'):
print('\nChecking that result and reference are 1D and that they have the same length\n')
if (len(result.shape) == 1) and (len(reference.shape) == 1):
if len(resu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualise_dataset_balancer_results(results, range=(-0.5, 0.5),\n colors=(\"#64B3DE\", \"#1f78b4\", \"#B9B914\", \"#FBAC44\", \"#bc1659\", \"#33a02c\", \"grey\", \"#b15928\", \"#6a3d9a\", \"#e31a1c\", \"#6ABF20\", \"#ff7f00\", \"#6a3d9a\"),\n ... | [
"0.63131994",
"0.61638975",
"0.60450023",
"0.5963564",
"0.5949459",
"0.58739024",
"0.5803001",
"0.57943153",
"0.57097024",
"0.5674428",
"0.5670437",
"0.5666262",
"0.56224895",
"0.5605114",
"0.56042796",
"0.5596361",
"0.55910486",
"0.5591017",
"0.55787",
"0.5563748",
"0.555826... | 0.69851726 | 0 |
Compute Pearson correlation coefficient (r) between network result and groundtruth | def correlation(result, reference):
r = np.corrcoef(result, reference)[0,1]
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_correlation(self):\n self.network.index_nodes()\n self._calculate_dist()\n pearson_correlation, pearson_pvalue = scipy.stats.pearsonr(self.dist[:,0], self.dist[:,1])\n spearman_correlation, spearman_pvalue = scipy.stats.spearmanr(self.dist[:,0], self.dist[:,1])\n re... | [
"0.7345685",
"0.6861322",
"0.6818759",
"0.6698538",
"0.66438806",
"0.6590125",
"0.6581691",
"0.65602005",
"0.65509814",
"0.6521111",
"0.65055865",
"0.64997494",
"0.6487084",
"0.64761126",
"0.64340806",
"0.64340806",
"0.64340806",
"0.6431436",
"0.6431436",
"0.6431436",
"0.6431... | 0.655468 | 8 |
Moving average filter that takes in any curve as an input and returns the smoothed version of the curve. | def movingAverage(curve, radius):
window_size = 2 * radius + 1
# Define the filter
f = np.ones(window_size)/window_size
# Add padding to the boundaries
curve_pad = np.lib.pad(curve, (radius, radius), 'edge')
# Apply convolution
curve_smoothed = np.convolve(curve_pad, f, mode='same')
# Re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def moving_average_filter(val, filtered_val_prev, zeta):\n filtered_val = (1-zeta)*filtered_val_prev + zeta*val\n return filtered_val",
"def moving_avg_filter(data, filter_size=filter_size):\n filter_size = int(filter_size)\n smoothed = np.zeros(len(data))\n for n in range(filter_size, len(data) -... | [
"0.7339928",
"0.72752964",
"0.65571386",
"0.6282777",
"0.6279526",
"0.6273056",
"0.6229946",
"0.6214437",
"0.6205291",
"0.616007",
"0.61384493",
"0.612138",
"0.61037254",
"0.60738504",
"0.60179627",
"0.59666866",
"0.59634",
"0.59460336",
"0.59332263",
"0.59112227",
"0.5901501... | 0.72439873 | 2 |
Smooth x, y and angles individually | def smooth(trajectory, smoothing_radius):
smoothed_trajectory = np.copy(trajectory)
# Filter the x, y and angle curves
for i in range(3):
smoothed_trajectory[:, i] = movingAverage(trajectory[:, i],
radius=smoothing_radius)
return smoothed_trajec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def smooth(o_l, o_r, c_l, c_r, AMT):\n l = o_l * AMT + (1-AMT) * c_l\n r = o_r * AMT + (1-AMT) * c_r\n return (l, r)",
"def smooth(*args, numiter=1) -> core.Smooth:\n X, Y, kws = util.parseargs(*args)\n return core.Smooth(X, Y, numiter=numiter)",
"def _smooth(self):\n self.te = self... | [
"0.6069272",
"0.6052654",
"0.58253056",
"0.5748677",
"0.5660876",
"0.542666",
"0.54207605",
"0.5390675",
"0.5384229",
"0.53786594",
"0.5338627",
"0.5325628",
"0.53239113",
"0.5315032",
"0.5307407",
"0.52987885",
"0.52389336",
"0.5235801",
"0.5194192",
"0.51899594",
"0.5166681... | 0.57049793 | 4 |
Adjust border to remove as much of black borders as possible | def fixBorder(frame):
s = frame.shape
# Scale the image 2% without moving the center
T = cv2.getRotationMatrix2D((s[1]/2, s[0]/2), 0, 1.02)
frame = cv2.warpAffine(frame, T, (s[1], s[0]))
return frame | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def border(self):\n ...",
"def reduce_whitespace(self, border: int = 5) -> None:\n if self.img is None:\n raise FileExistsError(\"Load an image first with from_url.\")\n\n pix = np.asarray(self.img)\n\n pix = pix[:, :, 0:3] # Drop the alpha channel\n idx = np.where(... | [
"0.7338723",
"0.7335545",
"0.6950881",
"0.68227065",
"0.677218",
"0.66420734",
"0.6601155",
"0.6601155",
"0.65928864",
"0.6508886",
"0.6455222",
"0.6428991",
"0.6381604",
"0.6376463",
"0.6366828",
"0.63566816",
"0.63566476",
"0.62430286",
"0.62430286",
"0.6230813",
"0.6217119... | 0.57792115 | 52 |
Stabilization of a video. Saved at the same directory as the original video. Using fixed_area it is possible to adress an area in which fixed spots are located. | def stabilization(videopath,
smoothing_radius=50,
fixed_area=[0, -1, 0, -1],
stab_points=200):
# Read original video
# Extract directory and videoname for saving purposes
capture = cv2.VideoCapture(videopath)
directory, videoname = os.path.split(vid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def video_stabilizer(self, video=None):\r\n def in_roi(roi, p):\r\n x, y = p\r\n return roi['x1'] < x < roi['x2'] and roi['y1'] < y < roi['y2']\r\n\r\n \r\n if video is None:\r\n video = self.video_buffer\r\n stab_video = np.zeros_like(video)\r\n ... | [
"0.59573704",
"0.5611474",
"0.5611474",
"0.55306906",
"0.54804987",
"0.543196",
"0.54163516",
"0.5396492",
"0.53075343",
"0.530261",
"0.5296827",
"0.529461",
"0.5270649",
"0.5267028",
"0.5228373",
"0.5218529",
"0.5175246",
"0.51592225",
"0.51358426",
"0.5133068",
"0.5116132",... | 0.6866042 | 0 |
Creates a DataLoader from given source and its open/transform params. | def get_loader(
data_source: Iterable[dict],
open_fn: Callable,
dict_transform: Callable = None,
sampler=None,
collate_fn: Callable = default_collate_fn,
batch_size: int = 32,
num_workers: int = 4,
shuffle: bool = False,
drop_last: bool = False,
):
from catalyst.data.dataset impo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_DataLoader(self, **kwargs):\r\n return DataLoader(self, **kwargs)",
"def get_dataloader(params, format_name='hdf5', **kwargs):\n \n Provider = get_proper_provider(format_name)(params.modality)\n \n return DataLoader(Provider(params.dataset_path,\n seq_len... | [
"0.67652076",
"0.6572773",
"0.6279626",
"0.61619353",
"0.61383015",
"0.61090654",
"0.60896605",
"0.60315233",
"0.6029367",
"0.60176903",
"0.5900374",
"0.58815914",
"0.5844954",
"0.584316",
"0.5832388",
"0.5825662",
"0.58236927",
"0.58061033",
"0.58045447",
"0.5799926",
"0.577... | 0.73296386 | 0 |
Returns a batch from experiment loader | def get_native_batch_from_loader(loader: DataLoader, batch_index: int = 0):
dataset = loader.dataset
collate_fn = loader.collate_fn
return collate_fn([dataset[batch_index]]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_batch(batch, ctx):\n if isinstance(batch, mx.io.DataBatch):\n data = batch.data[0]\n label = batch.label[0]\n else:\n data, label = batch\n return (gluon.utils.split_and_load(data, ctx),\n gluon.utils.split_and_load(label, ctx),\n data.shape[0])",
"def... | [
"0.70499706",
"0.66965586",
"0.65072715",
"0.63480055",
"0.63115305",
"0.62328964",
"0.6215692",
"0.6208522",
"0.6193537",
"0.61932385",
"0.61918086",
"0.61496",
"0.61396766",
"0.6139635",
"0.6120947",
"0.60812145",
"0.6053506",
"0.60499865",
"0.60434055",
"0.598307",
"0.5957... | 0.6029509 | 19 |
Returns a batch from experiment loaders by its index or name. | def get_native_batch_from_loaders(
loaders: Dict[str, DataLoader],
loader: Union[str, int] = 0,
batch_index: int = 0,
):
if isinstance(loader, str):
loader_instance = loaders[loader]
elif isinstance(loader, int):
loader_instance = list(loaders.values())[loader]
else:
rais... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_native_batch_from_loader(loader: DataLoader, batch_index: int = 0):\n dataset = loader.dataset\n collate_fn = loader.collate_fn\n return collate_fn([dataset[batch_index]])",
"def get_batch(self, name):\n batches = self._meta['sets'].get('batches', {})\n if batches.get(name):\n ... | [
"0.62770796",
"0.6147377",
"0.6142249",
"0.5965098",
"0.5944489",
"0.58695436",
"0.58550024",
"0.5844343",
"0.57876563",
"0.57487893",
"0.5744385",
"0.56675255",
"0.56562734",
"0.56562734",
"0.5644203",
"0.56192917",
"0.56192917",
"0.561557",
"0.55952257",
"0.557245",
"0.5514... | 0.6902564 | 0 |
Transfers loader to distributed mode. Experimental feature. | def _force_make_distributed_loader(loader: DataLoader) -> DataLoader:
from catalyst.data.sampler import DistributedSamplerWrapper
sampler = (
DistributedSampler(dataset=loader.dataset)
if getattr(loader, "sampler", None) is not None
else DistributedSamplerWrapper(sampler=loader.sampler)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_cluster(self):",
"def _load_disk(self):\r\n pass",
"def _load_disk(self):",
"def _load_disk(self):",
"def train(self, train_loader):\n pass",
"def load_fileclient_dist(filename, backend, map_location):\n rank, world_size = get_dist_info()\n rank = int(os.environ.get('LOCAL_RANK'... | [
"0.59361863",
"0.5920277",
"0.59072095",
"0.59072095",
"0.56024635",
"0.5458916",
"0.5377288",
"0.5368101",
"0.5337646",
"0.5314456",
"0.5306029",
"0.53045654",
"0.5274331",
"0.52272767",
"0.5219852",
"0.5215269",
"0.5144504",
"0.5126292",
"0.51216847",
"0.51074153",
"0.51073... | 0.6326774 | 0 |
Check pytorch dataloaders for distributed setup. Transfers them to distirbuted mode if necessary. (Experimental feature) | def validate_loaders(loaders: Dict[str, DataLoader]) -> Dict[str, DataLoader]:
from catalyst.data.sampler import DistributedSamplerWrapper
rank = get_rank()
if rank >= 0:
for key, value in loaders.items():
if not isinstance(
value.sampler, (DistributedSampler, Distribute... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dataloaders(args):\n if args.dataset == 'heat':\n dataset_class = heat.HeatDiffusionDataset\n else:\n raise ValueError(f'Unknown dataset {args.dataset}')\n train_dataset = dataset_class(\n dataset_class.get_train_path(args.data_path), args, train=True)\n if args.dist:\n ... | [
"0.6899112",
"0.6226834",
"0.6168277",
"0.6168277",
"0.61057776",
"0.6086646",
"0.60528105",
"0.5985111",
"0.5980284",
"0.5944964",
"0.593367",
"0.5921929",
"0.5912628",
"0.5857826",
"0.5853588",
"0.5849491",
"0.5820345",
"0.57989067",
"0.57894933",
"0.57853943",
"0.57713866"... | 0.5795563 | 18 |
Creates pytorch dataloaders from datasets and additional parameters. | def get_loaders_from_params(
batch_size: int = 1,
num_workers: int = 0,
drop_last: bool = False,
per_gpu_scaling: bool = False,
loaders_params: Dict[str, Any] = None,
samplers_params: Dict[str, Any] = None,
initial_seed: int = 42,
get_datasets_fn: Callable = None,
**data_params,
) ->... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dataloaders(params):\r\n transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4),\r\n transforms.RandomHorizontalFlip(),\r\n transforms.ToTensor(),\r\n transform... | [
"0.79882824",
"0.7873911",
"0.77523524",
"0.7489144",
"0.7423688",
"0.74065715",
"0.7383054",
"0.73766834",
"0.73579735",
"0.735641",
"0.7308889",
"0.72247446",
"0.7185362",
"0.71817666",
"0.7140771",
"0.71166503",
"0.711527",
"0.7087059",
"0.7068981",
"0.7030009",
"0.7026917... | 0.0 | -1 |
Insert mpc values into vector bc | def backsubstitution_numba(b, dofmap, num_dofs_per_element, mpc,
global_indices):
(slaves, slave_cells, cell_to_slave, cell_to_slave_offset,
masters_local, coefficients, offsets) = mpc
slaves_visited = numpy.empty(0, dtype=numpy.float64)
# Loop through slave cells
for (i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assemble_vector(form: _forms, constraint: MultiPointConstraint, b: Optional[_PETSc.Vec] = None) -> _PETSc.Vec:\n\n _log.log(_log.LogLevel.INFO, \"Assemble MPC vector\")\n timer_vector = Timer(\"~MPC: Assemble vector (numba)\")\n\n # Unpack Function space data\n V = form.function_spaces[0]\n x_do... | [
"0.6082489",
"0.5575862",
"0.5575201",
"0.54895455",
"0.5469619",
"0.54367906",
"0.5396512",
"0.5330801",
"0.53306586",
"0.53206575",
"0.5290812",
"0.5254805",
"0.5217282",
"0.52065116",
"0.5203687",
"0.51997477",
"0.5193619",
"0.51802784",
"0.5180166",
"0.51514554",
"0.51511... | 0.47996634 | 90 |
Returns the data structures required to build a multipoint constraint. Given a nested dictionary, where the first keys are functions for geometrically locating the slave degrees of freedom. The values of these keys are another dictionary, containing functions for geometrically locating the master degree of freedom. The... | def slave_master_structure(V: function.FunctionSpace, slave_master_dict:
typing.Dict[types.FunctionType,
typing.Dict[
types.FunctionType, float]],
subspace_slave=None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_mixture_parameters(param_dict):\n compound1 = param_dict['compound1_name']\n compound2 = param_dict['compound2_name']\n compound1_mw = param_dict[compound1]['mw']\n compound2_mw = param_dict[compound2]['mw']\n n_fractions = param_dict['n_fractions']\n compound1_frac_range = np.linspace(0... | [
"0.5444125",
"0.5406418",
"0.5294767",
"0.52280223",
"0.5195249",
"0.5088805",
"0.50730544",
"0.50400007",
"0.49896812",
"0.49793857",
"0.4948449",
"0.49242276",
"0.49029934",
"0.48890132",
"0.48779187",
"0.48230854",
"0.4778732",
"0.4759802",
"0.47489172",
"0.473061",
"0.472... | 0.5465718 | 0 |
Convenience function for locating a dof close to a point use numpy and lambda functions. | def dof_close_to(x, point):
if point is None:
raise ValueError("Point must be supplied")
if len(point) == 1:
return numpy.isclose(x[0], point[0])
elif len(point) == 2:
return numpy.logical_and(numpy.isclose(x[0], point[0]),
numpy.isclose(x[1], point[1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def FindClosestPointWithinRadius(self, p_float, , p_float_4):\n ...",
"def closest_point(point, points):\n return points[cdist([point], points).argmin()]",
"def FindClosestPoint(self, ):\n ...",
"def locate_source(p,d):\n # M = sensors, n = dimensions\n M, n = p.shape\n p = np.m... | [
"0.5620192",
"0.5540381",
"0.5476292",
"0.5463289",
"0.53948784",
"0.52953845",
"0.52639014",
"0.515784",
"0.5153333",
"0.5147639",
"0.5111826",
"0.50957406",
"0.5084647",
"0.5053538",
"0.5044675",
"0.5013717",
"0.5011052",
"0.49993494",
"0.4937481",
"0.49339086",
"0.492871",... | 0.6613694 | 0 |
Find all rows in a matrix that is zero, and add a 1 on the diagonal | def ident_zeros(A):
assert A.size[0] == A.size[1]
A.assemble()
o_range = A.getOwnershipRange()
rows = []
for i in range(o_range[1]-o_range[0]):
indices, values = A.getRow(o_range[0]+i)
absrow = sum(abs(values))
if absrow < 1e-6:
rows.append(o_range[0] + i)
add... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zero_matrix(matrix):\n rows = set()\n columns = set()\n m = len(matrix)\n n = len(matrix[0])\n for i in range(m):\n for j in range(n):\n if matrix[i][j] == 0:\n rows.add(i)\n columns.add(j)\n\n for i in range(m):\n for j in range(n):\n ... | [
"0.73189586",
"0.7197821",
"0.7129083",
"0.70978343",
"0.7078936",
"0.68751305",
"0.68057173",
"0.6782833",
"0.67469335",
"0.66681945",
"0.6666137",
"0.66429776",
"0.6623435",
"0.6621061",
"0.6620543",
"0.6616192",
"0.66147125",
"0.66110265",
"0.66069096",
"0.65960264",
"0.65... | 0.64289784 | 36 |
Loads the network from the model_file | def load(model_file):
return pickle.load(open(model_file)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __load_Model(self):\r\n PrintsForUser.printProcess(\"[INFO] Loading network...\")\r\n \r\n self.__model = load_model(self.__model_path)\r\n self.__lb = pickle.loads(open(self.__labels_path, \"rb\").read())",
"def load_model(self, filename):\r\n pass",
"def load_model(self):\n... | [
"0.80785453",
"0.78836066",
"0.78565896",
"0.7795077",
"0.7740179",
"0.77031296",
"0.7660467",
"0.7653963",
"0.75833833",
"0.7533862",
"0.7531292",
"0.7489834",
"0.7480979",
"0.74483097",
"0.7429411",
"0.7424033",
"0.74155533",
"0.7393638",
"0.7388102",
"0.7344858",
"0.731060... | 0.7147446 | 35 |
Initialize the network with input, output sizes, weights, biases, learning_rate and regularization parameters | def __init__(self, input_dim, hidden_size, output_dim, learning_rate=0.01, reg_lambda=0.01):
self.input_dim = input_dim
self.output_dim = output_dim
self.hidden_size = hidden_size
self.Wxh = np.random.randn(384, 4) * 0.01 # Weight matrix for input to hidden
self.Why = np.random.r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, layerNeurons, numberOfLayers, initialWeights = None, lowerBound = None, upperBound = None):\r\n \r\n # Ensure that there is at-least one input and one output layer in the network\r\n assert len(layerNeurons) > 1, \"At least one input layer and one output layer is... | [
"0.74209976",
"0.7396114",
"0.7373526",
"0.73277473",
"0.73184055",
"0.7301008",
"0.7296244",
"0.725816",
"0.7257238",
"0.72496414",
"0.72361547",
"0.72089535",
"0.7180864",
"0.71519685",
"0.71486765",
"0.71280986",
"0.71126556",
"0.7108435",
"0.7079199",
"0.7075433",
"0.7041... | 0.0 | -1 |
Performs forward pass of the ANN | def _feed_forward(self, X):
# Add code to calculate a1 and probs
z1 = X.dot(self.Wxh) + self.bh
a1 = np.tanh(z1)
z2 = a1.dot(self.Why) + self.by
exp_scores = np.exp(z2)
probs = exp_scores/np.sum(exp_scores, axis=1, keepdims=True)
return a1, probs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_train(self, *args, **kwargs):\n pass",
"def forward(self, X, training=False):\n pass",
"def feedForward(self):\n # Calculate the current values of the first layer\n self.layer1 = sigmoid(np.dot(self.input, self.weights1))\n\n # Calculate the sigmoid of the second ... | [
"0.73296845",
"0.7058033",
"0.7054047",
"0.6995982",
"0.69711787",
"0.6962721",
"0.6869112",
"0.68467736",
"0.68006057",
"0.67674667",
"0.6741799",
"0.6737499",
"0.67266357",
"0.6712976",
"0.67003626",
"0.67003626",
"0.6699479",
"0.6699304",
"0.668508",
"0.6673779",
"0.665580... | 0.0 | -1 |
Add regularization terms to the weights | def _regularize_weights(self, dWhy, dWxh, Why, Wxh):
# Add code to calculate the regularized weight derivatives
return dWhy, dWxh | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_regularization(self, w, loss, gradient, regularization, lambda_, m):\n if regularization == 'l2':\n loss += lambda_ / (2 * m) * np.squeeze(w.T.dot(w))\n gradient += lambda_ / m * w\n elif regularization == 'l1':\n loss += lambda_ / (2 * m) * np.sum(np.abs(w)... | [
"0.7179892",
"0.7145785",
"0.6990459",
"0.6630686",
"0.65943927",
"0.6463276",
"0.6454973",
"0.64209753",
"0.6366239",
"0.6327552",
"0.6272369",
"0.6243218",
"0.6200595",
"0.61773133",
"0.6166511",
"0.61557037",
"0.6152536",
"0.6141911",
"0.61305684",
"0.6111044",
"0.61042017... | 0.7018406 | 2 |
Update the weights and biases during gradient descent | def _update_parameter(self, dWxh, dbh, dWhy, dby):
# Add code to update all the weights and biases here | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __update_weights_grad_desc(self, x_train, y_train):\n\n predictions = self.__compute_prediction(x_train)\n weights_delta = np.dot(x_train.T, y_train - predictions)\n\n m = y_train.shape[0]\n self.__weights += self.__learning_rate / float(m) * weights_delta",
"def update_weights(se... | [
"0.80361515",
"0.7598971",
"0.75904953",
"0.7497646",
"0.7484387",
"0.73378307",
"0.7328388",
"0.72507805",
"0.72425085",
"0.71753126",
"0.71582067",
"0.70501596",
"0.7045166",
"0.70064026",
"0.6990169",
"0.69767416",
"0.69753116",
"0.69537646",
"0.6943432",
"0.691215",
"0.68... | 0.6541168 | 66 |
Implementation of the backpropagation algorithm | def _back_propagation(self, X, t, a1, probs,length):
# Add code to compute the derivatives and return
delta3 = probs
delta3[range(length),t] -= 1
dWhy = (a1.T).dot(delta3)
dby = np.sum(delta3, axis=0, keepdims=True)
delta2 = delta3.dot(dWhy.T) * (1 - np.power(a1, 2))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backprop(self, x, y):\n \n #Building an empty networks filled with empty 0 \n updated_bias = []\n for b in self.biases:\n updated_bias.append(np.zeros(b.shape)) \n \n updated_weight = []\n for w in self.weights:\n updated_weight.appe... | [
"0.7893654",
"0.7775679",
"0.77610594",
"0.7709016",
"0.7621128",
"0.7585972",
"0.7565034",
"0.74838185",
"0.74370015",
"0.7416354",
"0.7389637",
"0.7382596",
"0.7374434",
"0.736721",
"0.7365797",
"0.7363849",
"0.73629916",
"0.7333083",
"0.7329341",
"0.7325105",
"0.731928",
... | 0.75821644 | 6 |
Calculate the smoothened loss over the set of examples | def _calc_smooth_loss(self, loss, len_examples, regularizer_type=None):
if regularizer_type == 'L2':
# Add regulatization term to loss
return 1./len_examples * loss
else:
return 1./len_examples * loss | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pseudo_loss(self, params, batches):\n loss = 0\n for batch in batches:\n states = batch[\"states\"]\n actions = batch[\"actions\"]\n returns = batch[\"returns\"]\n\n preds = self.predict_jax(params, states)\n\n baseline = jnp.mean(returns, ax... | [
"0.7046122",
"0.6933266",
"0.67758876",
"0.6710177",
"0.67039424",
"0.65970236",
"0.6579602",
"0.65749127",
"0.65639144",
"0.65343916",
"0.6528188",
"0.6524744",
"0.65166056",
"0.65154487",
"0.6511314",
"0.6507151",
"0.64965415",
"0.6463061",
"0.6462403",
"0.6458007",
"0.6445... | 0.0 | -1 |
Trains the network by performing forward pass followed by backpropagation | def train(self, inputs, targets, validation_data, num_epochs, regularizer_type=None):
for k in xrange(num_epochs):
loss = 0
# Forward pass
a1, probs = self._feed_forward(inputs)
# Backpropagation
dWxh, dWhy, dbh, dby = self._back_propagati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_train(self, *args, **kwargs):\n pass",
"def feedForward(self):\n # Calculate the current values of the first layer\n self.layer1 = sigmoid(np.dot(self.input, self.weights1))\n\n # Calculate the sigmoid of the second layer which is the output\n self.output = sigmoid(... | [
"0.6965216",
"0.6921678",
"0.6789786",
"0.6776324",
"0.6767226",
"0.67588675",
"0.6663136",
"0.6638087",
"0.6580595",
"0.6559318",
"0.65537626",
"0.65397984",
"0.6535671",
"0.65028805",
"0.65024525",
"0.64893365",
"0.6480598",
"0.6480408",
"0.647741",
"0.64655685",
"0.6463688... | 0.0 | -1 |
Given an input X, emi | def predict(self, X, y):
# Implement the forward pass and return the output class (argmax of the softmax outputs)
a1, probs = self._feed_forward(X)
hits = 0
for i in xrange(len(y)):
if np.where(probs[i]==max(probs[i]))[0][0] == y[i]: hits+=1
print hits,len(X... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __em(self, x):\n _, log_resp = self._e_step(x)\n\n pi, mu, var = self._m_step(x, log_resp)\n\n self.__update_pi(pi)\n self.__update_mu(mu)\n self.__update_var(var)",
"def test_support_INVEX(self):\n self.assertEqual(self._parseFeature(\"INVEX\", \"Z\"), \"Z\")\n ... | [
"0.5687068",
"0.5627485",
"0.5571878",
"0.5418379",
"0.54145116",
"0.5318582",
"0.52997404",
"0.5267728",
"0.52024394",
"0.51604664",
"0.5143021",
"0.51003444",
"0.50619334",
"0.50566435",
"0.50231236",
"0.49777362",
"0.49734622",
"0.49568754",
"0.495462",
"0.49533582",
"0.49... | 0.0 | -1 |
Saves the network to a file | def save(self, model_file):
pickle.dump(self, open(model_file, 'wb')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_network(network, fpath):\n\twith open(fpath, \"wb\") as f:\n\t\tpickle.dump(network, f)",
"def save_net(net, filepath):\n\twith open(filepath, 'wb+') as fh:\n\t\tdump(obj = net, file = fh, protocol = -1)",
"def export_network(file_name, net) -> None:\r\n file = open(file_name, 'wb')\r\n file.wri... | [
"0.8235571",
"0.80835664",
"0.75442106",
"0.75003153",
"0.7487173",
"0.7381429",
"0.727793",
"0.7240167",
"0.72368324",
"0.7173263",
"0.71639335",
"0.69699883",
"0.6954969",
"0.6909733",
"0.69001526",
"0.68852276",
"0.68837154",
"0.68791676",
"0.68103606",
"0.6777189",
"0.676... | 0.0 | -1 |
predictGame is a function and is invoked in dispatch when the operation to be performed is predict high score, low score & average score for lookahead moves. | def predictGame(messageDictionary):
#output dictionary is returned to dispatch after the calculations are done
outputDictionary = {}
outputDictionary["gameStatus"] = "underway"
#call to validatePredict to validate the input dictionary
outputDictionary = validatePredict(messageDictionary, outputDic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, game:'Game'): # noqa: E0602, F821\n response = self.__send_game(game)\n return response",
"def predict_outcome(self, game:'Game') -> float: # noqa: E0602, F821\n response = self.__send_game(game)\n return response[1]",
"def predict_Keras():\n #read future game... | [
"0.7299662",
"0.6904139",
"0.6807237",
"0.6549272",
"0.64293885",
"0.63504833",
"0.6344803",
"0.63210434",
"0.6296399",
"0.6229284",
"0.6220852",
"0.6206481",
"0.6205331",
"0.61918354",
"0.6151533",
"0.6146176",
"0.614611",
"0.6118504",
"0.6116085",
"0.6094616",
"0.60856265",... | 0.6895396 | 2 |
update grad related data in full resolution | def update_grad_data():
t_file = 'hcapgrd1_full_data_*.fits*'
out_dir = deposit_dir + '/Grad_save/'
tdir = out_dir + 'Gradcap/'
#
#--- read grad group name
#
gfile = house_keeping + 'grad_list'
grad_list = mcf.read_data_file(gfile)
[tstart, tstop, year] = ecf.find_data_collecting_period... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _UpdateGradient(self):\n self.mol.GetGradient('analytic')",
"def update(self):\n self.arest.update()",
"def update():",
"def update():",
"def updateG(self, dt):\n\t\tself.tissue.G.project( (self.initial * dt + Identity(3)) * self.tissue.G )",
"def force_update_graph(self):\n self.upd... | [
"0.64381087",
"0.6039294",
"0.60320777",
"0.60320777",
"0.59506106",
"0.5820663",
"0.5819838",
"0.58146644",
"0.5809392",
"0.5805305",
"0.5803003",
"0.57782805",
"0.5775283",
"0.5766644",
"0.5766644",
"0.5766644",
"0.57610506",
"0.5724304",
"0.572347",
"0.57166773",
"0.570517... | 0.7163576 | 0 |
update msid data in msid_list for the given data period | def get_data(tstart, tstop, year, grad_list, out_dir):
print("Period: " + str(tstart) + '<-->' + str(tstop) + ' in Year: ' + str(year))
#
#--- extract ecach group data
#
for group in grad_list:
print(group)
line = 'operation=retrieve\n'
line = line + 'dataset = mta\n'
line = lin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generator_place_update_pids(ms, new_pid_dict):\n # print \">>> \", new_pid_dict\n new_ms = multiset()\n for pid, n in ms:\n new_pid = Pid.from_list(new_pid_dict[tuple(pid.data)])\n new_n = Pid.from_list(new_pid_dict[ tuple(pid.next(n).data) ]).ends_with() - 1\n new_ms.add((new_pid... | [
"0.5456846",
"0.52601284",
"0.5259704",
"0.5156615",
"0.5082855",
"0.50776327",
"0.50758034",
"0.5069569",
"0.50444466",
"0.5033247",
"0.5029289",
"0.50191236",
"0.4987042",
"0.4984111",
"0.49803722",
"0.49793786",
"0.49717724",
"0.49439514",
"0.4932616",
"0.4929739",
"0.4926... | 0.0 | -1 |
Set up the PACS instrument. | def __init__(self, band, active_fraction=0, fine_sampling_factor=1,
policy_bad_detector='mask', reject_bad_line=True,
comm=MPI.COMM_WORLD):
band = band.lower().strip()
expected = 'blue', 'green', 'red'
if band not in expected:
raise ValueError("Inval... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_setup_pocs(self, *arg):\n args, kwargs = string_to_params(*arg)\n simulator = kwargs.get('simulator', [])\n print_info(\"Simulator: {}\".format(simulator))\n\n try:\n self.pocs = POCS(simulator=simulator)\n self.pocs.initialize()\n except error.PanErr... | [
"0.67579174",
"0.66947913",
"0.65121156",
"0.64911264",
"0.6412101",
"0.6392717",
"0.63770014",
"0.6237447",
"0.6133334",
"0.6107687",
"0.6104067",
"0.6046922",
"0.6025208",
"0.6009841",
"0.5974992",
"0.58549696",
"0.58441997",
"0.5822551",
"0.57593024",
"0.56885356",
"0.5681... | 0.0 | -1 |
Convert coordinates in the (u,v) plane into the (y,z) plane, assuming a chop angle. | def uv2yz(self, coords, chop=0):
coords = np.array(coords, float, order='c', copy=False)
yz = np.empty_like(coords)
distortion = self.distortion_yz.base.base.base
tmf.pacs_uv2yz(coords.reshape((-1,2)).T, distortion, chop,
yz.reshape((-1,2)).T)
yz *= 3600
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uv_to_coord(uv):\n transposed_uv = np.transpose(uv)\n x = transposed_uv[0] \n y = transposed_uv[1] \n z = transposed_uv[2]\n \n c = SkyCoord(x, y, z, unit = 'mpc', representation_type = 'cartesian',\n frame = 'icrs')\n\n return c",
"def proyZm1(u, v, t1):\n ... | [
"0.61944693",
"0.6185099",
"0.6060304",
"0.60305244",
"0.6014021",
"0.59566766",
"0.5864326",
"0.5781212",
"0.5732748",
"0.57312196",
"0.5688741",
"0.5502812",
"0.54883116",
"0.5481512",
"0.5480482",
"0.5480482",
"0.5473742",
"0.54688644",
"0.54560274",
"0.5441397",
"0.542247... | 0.69537777 | 0 |
Convert coordinates in the (u,v) plane into celestial coordinates, assuming a pointing direction and a position angle. | def uv2ad(self, coords, pointing):
coords = np.array(coords, float, order='c', copy=False)
ad = np.empty(pointing.shape + coords.shape, float)
coords = coords.reshape((-1,2))
distortion = self.distortion_yz.base.base.base
tmf.pacs_uv2ad(coords.T, pointing['ra'].ravel(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 += p... | [
"0.56984663",
"0.56822234",
"0.55598813",
"0.55472475",
"0.54942214",
"0.5481065",
"0.5419634",
"0.5416382",
"0.5416128",
"0.5368024",
"0.53565735",
"0.53381264",
"0.53367597",
"0.53355867",
"0.53273153",
"0.5312171",
"0.52980036",
"0.52692777",
"0.5258552",
"0.5238669",
"0.5... | 0.0 | -1 |
Convert coordinates in the (y,z) plane into celestial coordinates, assuming a pointing direction and a position angle. | def yz2ad(self, coords, pointing):
return super(PacsInstrument, self).instrument2ad(coords, pointing) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fromECEFtoLatLongDegrees(x, y, z):\n ret = fromECEFtoLatLong(x, y, z)\n return math.degrees(ret[0]), math.degrees(ret[1]), ret[2]",
"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 +... | [
"0.59502137",
"0.5758122",
"0.57307214",
"0.5723314",
"0.5712086",
"0.57021403",
"0.570138",
"0.5659975",
"0.56141365",
"0.5574885",
"0.555042",
"0.5529116",
"0.55197024",
"0.5510846",
"0.54765266",
"0.5473403",
"0.54644954",
"0.544101",
"0.54239607",
"0.5413395",
"0.5404595"... | 0.0 | -1 |
Return the minimum and maximum sky pixel coordinate values for a set of coordinates specified in the (u,v) frame. | def instrument2xy_minmax(self, coords, pointing, header):
coords = np.array(coords, float, order='c', copy=False)
xmin, ymin, xmax, ymax, status = tmf.pacs.uv2xy_minmax(
coords.reshape((-1,2)).T, pointing['ra'].ravel(),
pointing['dec'].ravel(), pointing['pa'].ravel(),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in se... | [
"0.6924671",
"0.6424969",
"0.61948615",
"0.6065038",
"0.6032333",
"0.6032219",
"0.60068566",
"0.59866816",
"0.59852475",
"0.59732544",
"0.5918796",
"0.59173995",
"0.5916899",
"0.5839536",
"0.583425",
"0.5826967",
"0.5785621",
"0.5769795",
"0.57387286",
"0.5735453",
"0.5700758... | 0.63084406 | 2 |
Return the dense pointing matrix whose values are intersection between detectors and map pixels. | def instrument2pmatrix_sharp_edges(self, coords, pointing, header, pmatrix,
npixels_per_sample):
coords = coords.reshape((-1,2))
ra = pointing['ra'].ravel()
dec = pointing['dec'].ravel()
pa = pointing['pa'].ravel()
chop = pointing['chop'].ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_map_offsets(self):\n map = self.map.copy()\n map_up = np.zeros((self.h + 1, self.w), np.uint8) # create 4-neighbor connectivity comparision\n map_down = np.zeros((self.h + 1, self.w), np.uint8)\n map_right = np.zeros((self.h, self.w + 1), np.uint8)\n map_left = np.zero... | [
"0.6341654",
"0.5626789",
"0.54947454",
"0.5472413",
"0.5406649",
"0.5348741",
"0.5346484",
"0.5309716",
"0.5248718",
"0.52088153",
"0.51692873",
"0.5168997",
"0.51670337",
"0.5137343",
"0.5128474",
"0.51215345",
"0.5109295",
"0.508304",
"0.5081762",
"0.50795776",
"0.50782424... | 0.0 | -1 |
Return the PACSspecific pointing matrix for a given set of pointings. | def get_pointing_matrix(self, pointing, header, npixels_per_sample=0,
method='sharp', downsampling=False,
compression_factor=None, delay=0., units=None,
derived_units=None, comm=MPI.COMM_WORLD):
if method is None:
me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_matrix(self, source_points, destination_points):\n return [\n [self.measure_between_two_points(point_a, point_b) for point_b in destination_points]\n for point_a in source_points\n ]",
"def afficher_points_2D(set_points):\n X, Y = [p[0][0] for p in set_points], [p[... | [
"0.604874",
"0.58545774",
"0.57588595",
"0.5698002",
"0.56862795",
"0.5661911",
"0.5608424",
"0.5517443",
"0.54482424",
"0.543538",
"0.54151875",
"0.535561",
"0.5343261",
"0.53388506",
"0.53377056",
"0.533229",
"0.5297682",
"0.5295389",
"0.5288998",
"0.52772486",
"0.5275723",... | 0.5378749 | 11 |
Return data from the calibration file set. Parameter | def get_calibration(self, name):
name = name.lower()
expected = ('absorption', 'badpixel', 'filter transmission',
'total transmission', 'gain', 'invntt', 'responsivity',
'timeconstant', 'stddev')
if name not in expected:
raise ValueError("Inva... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_calibration_data(self):\n #Declare global variables.\n global calT1\n global calT2\n global calT3\n global calP1\n global calP2\n global calP3\n global calP4\n global calP5\n global calP6\n global calP7\n global calP8\n ... | [
"0.6856678",
"0.6759978",
"0.6588898",
"0.657393",
"0.6475413",
"0.63763416",
"0.63673043",
"0.6318859",
"0.6295693",
"0.62789935",
"0.61824745",
"0.6178913",
"0.6153914",
"0.61184597",
"0.6115963",
"0.6085561",
"0.6019218",
"0.6009292",
"0.59900814",
"0.5972511",
"0.59663045... | 0.67558 | 2 |
Return FITS file as an HDU list and check format version. | def _get_calfile(self, filename, versions):
if isscalar(versions):
versions = (versions,)
if not os.path.isfile(filename):
raise IOError("The calibration file '{0}' does not exist or is "
"not a valid file.".format(filename))
hdus = pyfits.open(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extractFIESHeader(file):\n\n try:\n\n hdulist = pyfits.open(file)\n hdulist.close()\n\n if len(hdulist) > 0:\n prihdr = hdulist[0].header\n a = ['fies','FI',prihdr]\n for i in range(1, len(hdulist)):\n a.append(hdulist[i].header)\n return a\n else:\n return ['ERROR'... | [
"0.6485853",
"0.64821184",
"0.6438226",
"0.6303294",
"0.6199642",
"0.5962726",
"0.5960119",
"0.59521914",
"0.59498054",
"0.5893513",
"0.579941",
"0.5769727",
"0.57492995",
"0.5719023",
"0.5696674",
"0.56947064",
"0.56870055",
"0.56564265",
"0.5642543",
"0.5641584",
"0.5638401... | 0.5912471 | 9 |
Return the inverse noise timetime correlation coefficients. | def get_filter_uncorrelated(self):
return self.instrument.get_calibration('invntt') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inv(siso):\n num = siso.num[0][0]\n den = siso.den[0][0]\n return ctrl.tf(den,num,siso.dt)",
"def _normed_concentration_cached(self, time: float) -> _VectorisedFloat:\n return self._normed_concentration(time)",
"def get_thermal_covariance(self):\n cov = []\n for var in self.no... | [
"0.52399397",
"0.5231864",
"0.5214214",
"0.52137434",
"0.5204542",
"0.51780665",
"0.51361746",
"0.5107085",
"0.51048934",
"0.5077943",
"0.5031787",
"0.50150627",
"0.49865398",
"0.4968587",
"0.49233326",
"0.49120158",
"0.49117133",
"0.4911661",
"0.49081445",
"0.4901266",
"0.48... | 0.5075607 | 10 |
Return the PACSspecific pointing matrix for the observation. If the observation has several slices, as many pointing matrices are returned in a list. | def get_pointing_matrix(self, header, npixels_per_sample=0, method=None,
downsampling=False, section=None,
comm=MPI.COMM_WORLD):
if section is None:
return super(PacsBase, self).get_pointing_matrix(header,
npixels_per_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_neighbors(point):\n pt = point.copy()\n output= [point.copy() for i in range(4)]\n output[0:2] = map(Point.setY, output[0:2], [pt.getY()+ i for i in range(-1,2,2)])\n output[2:4]= map(Point.setX, output[2:4], [pt.getX()+ i for i in range(-1,2,2)])\n return output",
"def get_pointer_section... | [
"0.54192126",
"0.5042742",
"0.50278944",
"0.4957887",
"0.49473453",
"0.49380195",
"0.49365938",
"0.49317816",
"0.49207887",
"0.49150553",
"0.49030608",
"0.48919055",
"0.4853464",
"0.48280665",
"0.47937012",
"0.47761717",
"0.47713685",
"0.47575518",
"0.4756305",
"0.47314298",
... | 0.54859775 | 0 |
Return noise data from a random slice of a real pointed observation. Currently, the required duration must be less than that of the real observation (around 3 hours). | def get_random(self, flatfielding=True, subtraction_mean=True):
if any([slice.compression_factor not in [4,8] for slice in self.slice]):
raise NotImplementedError('The compression factor must be 4 or 8.')
path = os.path.join(var.path, 'pacs')
files = {
'blue' : ('1342182... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def noise(self):\r\n if self.buffer_offset + self.frames_per_buffer - 1 > self.x_max:\r\n #relleno con ceros al final si es necesario\r\n xs = np.arange(self.buffer_offset, self.x_max)\r\n tmp = np.random.random_sample(len(xs)) #ruido\r\n out = np.append(tmp, np.z... | [
"0.65129423",
"0.62532187",
"0.62303597",
"0.6103324",
"0.6097016",
"0.6078385",
"0.6068334",
"0.60188043",
"0.59746003",
"0.594265",
"0.59147614",
"0.5889064",
"0.5827273",
"0.5821273",
"0.57901174",
"0.57543117",
"0.5745692",
"0.5664459",
"0.5642329",
"0.5640243",
"0.561457... | 0.0 | -1 |
Returns detector's standard deviation from calibration file | def get_detector_stddev(self, length=0):
lengths, stddevs = self.instrument.get_calibration('stddev')
if length == 0:
return self.pack(stddevs[...,-1])
if length < lengths[0]:
raise ValueError('The value of the median filtering length should b'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def standard_deviation(self):\r\n\t\treturn self.variance()**(1/2)",
"def standard_deviation(self):\n clean, total = self._prepare_for_stats()\n if not total:\n return None\n\n return math.sqrt(clean.variance())",
"def standard_dev(self):\n return self.variance()**0.5",
... | [
"0.671013",
"0.6672784",
"0.6658662",
"0.6571934",
"0.6443426",
"0.6416653",
"0.64020526",
"0.6386533",
"0.6386533",
"0.6369035",
"0.6362797",
"0.63555735",
"0.6283316",
"0.62243253",
"0.6156727",
"0.61470175",
"0.61222863",
"0.6119557",
"0.609404",
"0.60737365",
"0.6066622",... | 0.57772005 | 54 |
Return the number of valid samplings for each slice, by taking into account compression factor and fine sampling. They are those whose self.pointing is not removed. | def get_nfinesamples(self):
return tuple(np.asarray(self.get_nsamples()) * \
self.slice.compression_factor * \
self.instrument.fine_sampling_factor) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample_count(self):\n assert len(self.decay_x) == len(self.decay_y)\n return len(self.decay_x)",
"def _count_block_perm(orig_vals, perm_ds, nbs, tail, rng, return_null, clip_min_value):\n orig_vals = np.atleast_2d(orig_vals)\n # uniform perm_ds for both single and paired test\n if perm... | [
"0.6506231",
"0.6302611",
"0.62566555",
"0.6216657",
"0.61590683",
"0.61199486",
"0.60595316",
"0.6048185",
"0.60077083",
"0.59875214",
"0.59564877",
"0.5913218",
"0.5910656",
"0.5910656",
"0.5904776",
"0.5903784",
"0.587871",
"0.58774364",
"0.58659023",
"0.585209",
"0.583657... | 0.6644689 | 0 |
Return a sky scan for the PACS instrument. The output is a Pointing instance that can be handed to PacsSimulation to create a simulation. | def create_scan(cls, center, length, step=148, sampling_period=None,
speed=20, acceleration=ACCELERATION, nlegs=3,
angle=0, instrument_angle=45, compression_factor=4,
cross_scan=True):
if sampling_period is None:
if int(compression_factor)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _scan(self):\n\n return self._scan_factory.make_scan(\n image_range=(1, 1),\n # dummy value--return to this later please\n exposure_time=1,\n oscillation=(\n self.detectorbase.osc_start,\n self.detectorbase.osc_start + self.detect... | [
"0.5746266",
"0.506474",
"0.49583694",
"0.4863261",
"0.48469698",
"0.48300648",
"0.48104277",
"0.47972572",
"0.47229928",
"0.47021076",
"0.46826926",
"0.46820483",
"0.46613055",
"0.46553722",
"0.4640871",
"0.46237504",
"0.46197218",
"0.45881274",
"0.4583141",
"0.4549301",
"0.... | 0.5223673 | 1 |
Returns the signal and mask timelines. By default, all activated masks will be combined. | def get_tod(self,
unit='Jy/detector',
flatfielding=False,
subtraction_mean=False,
no_unit_conversion=False,
masks='activated'):
act_masks = set([m for slice in self.slice \
for i, m in enumerate(slice.mask_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_dtv_flagging2(data, freqs):\n \n mask = data.mask*1\n dtv_times = []\n \n for ledge in (54, 60, 66, 76, 82):\n uedge = ledge + 6\n band = np.where( (freqs>=ledge) & (freqs<=uedge) )[0]\n trns = np.where( (freqs>=ledge+0.25) & (freqs<=uedge-0.25) )[0]\n empt = np.w... | [
"0.55140257",
"0.5493659",
"0.5428292",
"0.5308234",
"0.52128303",
"0.5205367",
"0.5183682",
"0.5136684",
"0.51366",
"0.5112739",
"0.50524056",
"0.49903628",
"0.4921",
"0.49115276",
"0.48796055",
"0.48743868",
"0.4853973",
"0.4848935",
"0.48420635",
"0.48420346",
"0.48336473"... | 0.0 | -1 |
Returns the operator which converts PACS timelines from Volts to ADU. | def PacsConversionAdu(obs, gain='nominal', offset='direct'):
if gain not in obs.instrument.adu_converter_gain:
raise ValueError("Invalid gain. Expected values are 'low', 'high' or 'n"
"ominal'.")
if offset not in obs.instrument.adu_converter_offset:
raise ValueError("Inv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eta2abc(parameter):\r\n # PV2AC conversion pathway TODO\r\n if parameter['Top'] == 'DC' or parameter['Top'] == 'PVINV' or parameter['Top'] == 'PV' and parameter['P_PV2AC_out'] is not None or parameter['Top'] == 'AC' and parameter['P_PV2AC_out'] is not None:\r\n \r\n # Create variables for t... | [
"0.5218613",
"0.51823133",
"0.50914484",
"0.48762998",
"0.4860368",
"0.48171657",
"0.47890833",
"0.47625923",
"0.4752423",
"0.47399518",
"0.4712024",
"0.46896645",
"0.46873918",
"0.46873918",
"0.4650318",
"0.4644534",
"0.46405387",
"0.46370304",
"0.46191022",
"0.4616998",
"0.... | 0.5116109 | 2 |
deglitch, filter and potentially compress if the observation is in transparent mode | def pacs_preprocess(obs, tod,
projection_method='sharp',
header=None,
downsampling=False,
npixels_per_sample=0,
deglitching_hf_length=20,
deglitching_nsigma=5.,
hf_length=30000,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_denoise(self, x):\n b, a = self.c_notch\n return filtfilt(b, a, x)",
"def filter_out_flickers(total_buffer,index_disappeared):\n \n wait_for_disparition = False\n candidate_for_disparition = -1\n to_destroy = [] #List of 3D tuples (value,first_index,last_index) of segmented... | [
"0.5940264",
"0.57888854",
"0.56609976",
"0.5598279",
"0.5571579",
"0.5547801",
"0.5547801",
"0.55289155",
"0.5483978",
"0.54816383",
"0.5425529",
"0.54046345",
"0.5402441",
"0.5388734",
"0.53727907",
"0.53614545",
"0.5357019",
"0.5333438",
"0.5318575",
"0.5286538",
"0.527774... | 0.5555929 | 5 |
Return gaussian, airy or calibration PSFs Calibration PSFs are rescaled to the required pixel resolution by a bilinear interpolation. | def pacs_get_psf(band, resolution, kind='calibration'):
band = band.lower()
choices = ('blue', 'green', 'red')
if band not in choices:
raise ValueError("Invalid band '" + band + "'. Expected values are " + \
strenum(choices) + '.')
kind = kind.lower()
choices = ('a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _scale_psf(self, input_irf_file, config):\n\n # Find all \"sigma\" values - tells how many PSF components we have in the IRF file\n column_names = [col.name.lower() for col in input_irf_file['POINT SPREAD FUNCTION'].columns]\n sigma_columns = list(filter(lambda s: \"sigma\" in s.lower(), c... | [
"0.5934714",
"0.59323114",
"0.56692666",
"0.56136227",
"0.5515017",
"0.55022854",
"0.5450474",
"0.5448875",
"0.541764",
"0.53971016",
"0.53850543",
"0.5371395",
"0.5353867",
"0.53373635",
"0.53324974",
"0.5330355",
"0.52796024",
"0.5279098",
"0.52602744",
"0.52514803",
"0.524... | 0.0 | -1 |
Compute temporal offset between the PACS counter and the spacecraft clock. | def pacs_compute_delay(obs, tod, model, invntt=None, tol_delay=1.e-3,
tol_mapper=1.e-3, hyper=1., brack=(-60.,-30.,0.),
full_output=False):
global map_rls
def func_model(obs, tod, model):
def substitute_projection(model):
for i, c in enumerate(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _clock_time(self):\n return self._shifted_time % (24*3600)",
"def _prev_shifted_time(self):\n return self._prev_sim_time + self.options.time.start_clocktime",
"def _shifted_time(self):\n return self.sim_time + self.options.time.start_clocktime",
"def GetDeviceHostClockOffset(self):\n... | [
"0.62899196",
"0.60005045",
"0.59686583",
"0.5939301",
"0.5939301",
"0.58321625",
"0.5753285",
"0.574835",
"0.5717388",
"0.5690558",
"0.5614201",
"0.5609203",
"0.56034964",
"0.5539353",
"0.55265343",
"0.5476326",
"0.54753363",
"0.5435063",
"0.54001856",
"0.5394224",
"0.539154... | 0.0 | -1 |
Return FITS keyword, according to HCSS handling. | def _hcss_fits_keyword(header, keyword, *args):
if len(args) > 1:
raise ValueError('Invalid number of arguments.')
for k in header.keys():
if not k.startswith('key.'):
continue
if header[k] == keyword:
return header[k[4:]]
if len(args) == 1:
return arg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cached_dm_find_fits_keyword(key):\n return MODEL.find_fits_keyword(key.upper(), return_result=True)",
"def getKeyword(self, key):\n try:\n return self.raw[0].header[key]\n except:\n return self.raw[0].header['HIERARCH ESO '+key]",
"def translate_keyword(keyword):\n ... | [
"0.61742735",
"0.5731916",
"0.5624878",
"0.5479709",
"0.5469909",
"0.536184",
"0.5338029",
"0.53282803",
"0.53036934",
"0.52704316",
"0.52200615",
"0.51690644",
"0.51421887",
"0.51387876",
"0.5137836",
"0.51041573",
"0.5076539",
"0.50673413",
"0.5035812",
"0.50308436",
"0.502... | 0.62036276 | 0 |
Mask everything up to the n_scanline scan line of the n_repetition repetition. If n_scanline is None, mask the whole repetition. Arguments | def step_scanline_masking(obs, n_repetition=0, n_scanline=None):
if n_scanline == None:
for i in xrange(n_repetition):
obs.pointing.masked[obs.status.Repetition == i] = True
else:
for i in xrange(n_repetition - 1):
obs.pointing.masked[obs.status.Repetition == i] = True
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maskgroup(x, n):\n # create running lists\n index = []\n length = []\n count = 0\n\n # count indices and lengths of unmasked data groups\n for i in range(x.mask.size):\n if i==0:\n if not x.mask[i]:\n index += [i]\n count = 1\n if i>0:... | [
"0.5703053",
"0.5262323",
"0.5123203",
"0.51200473",
"0.5092291",
"0.49722835",
"0.49684605",
"0.49445692",
"0.49437836",
"0.491899",
"0.4886753",
"0.48616335",
"0.48601496",
"0.48428234",
"0.48108998",
"0.48108998",
"0.4792055",
"0.4777932",
"0.47722837",
"0.4742274",
"0.473... | 0.77437854 | 0 |
The mask of a 3d image should be 2d | def test_05_01_mask_of3D(self):
x=cpi.Image()
x.image = np.ones((10,10,3))
self.assertTrue(x.mask.ndim==2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mask(self):\n\t\treturn pygame.mask.from_surface(self.img)",
"def getHitmask(self,image):\n\t\tmask = []\n\t\tfor x in range(image.get_width()):\n\t\t\tmask.append([])\n\t\t\tfor y in range(image.get_height()):\n\t\t\t\tmask[x].append(bool(image.get_at((x,y))[3]))\n\t\treturn mask",
"def get_mask(self,... | [
"0.688976",
"0.68292147",
"0.68080103",
"0.67995906",
"0.6752144",
"0.6688653",
"0.66669863",
"0.661741",
"0.6568836",
"0.6568836",
"0.6568836",
"0.6547132",
"0.65295583",
"0.6466821",
"0.6449835",
"0.64433336",
"0.6434398",
"0.64335746",
"0.6432887",
"0.6421492",
"0.64210224... | 0.8106994 | 0 |
test that an 'is_disconnect' condition will invalidate the connection, and additionally dispose the previous connection pool and recreate. | def test_reconnect(self):
# make a connection
conn = self.db.connect()
# connection works
conn.execute(select(1))
# create a second connection within the pool, which we'll ensure
# also goes away
conn2 = self.db.connect()
conn2.close()
# two... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_already_disconnected(connection, events, schedule, flush):\n schedule(connection.connect(),\n connection.disconnect(),\n connection.disconnect())\n flush()\n assert events.triggered(\"CLIENT_CONNECT\")\n assert events.triggered(\"CLIENT_DISCONNECT\")",
"def test_disco... | [
"0.71215147",
"0.7030726",
"0.70195895",
"0.6962915",
"0.6929336",
"0.68194956",
"0.6759856",
"0.6750204",
"0.6691207",
"0.6621002",
"0.6536765",
"0.64876175",
"0.64719003",
"0.6469791",
"0.6457137",
"0.6449306",
"0.640901",
"0.63973737",
"0.6388318",
"0.6374561",
"0.6314033"... | 0.7141908 | 0 |
test the fixture raises on connect | def test_control(self, ping_fixture):
engine = ping_fixture
with expect_raises_message(
exc.DBAPIError, "unhandled disconnect situation"
):
engine.connect() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connection_fail(context_fixture):\n with pytest.raises(SystemExit):\n context_fixture('RequestException')",
"def test_passing_bad_connection(self):\n self.assertRaises(\n ConnectionError, Pet.init_db, Redis(host=\"127.0.0.1\", port=6300)\n )\n self.assertIsNone(... | [
"0.7074696",
"0.6893949",
"0.68652934",
"0.6857744",
"0.683198",
"0.6786823",
"0.6782504",
"0.6678462",
"0.6664294",
"0.66146845",
"0.64933455",
"0.648083",
"0.64726126",
"0.64562",
"0.6455107",
"0.64305156",
"0.6425814",
"0.6402725",
"0.6401104",
"0.6391827",
"0.63894486",
... | 0.68847454 | 2 |
test the disconnect fixture doesn't raise, since it considers all errors to be disconnect errors. | def test_downgrade_control(self, ping_fixture_all_errs_disconnect):
engine = ping_fixture_all_errs_disconnect
conn = engine.connect()
conn.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_di... | [
"0.8239868",
"0.8152695",
"0.77598417",
"0.7655665",
"0.75864327",
"0.7565692",
"0.75071055",
"0.7395507",
"0.73369473",
"0.72375166",
"0.7187973",
"0.7111573",
"0.7008865",
"0.70034695",
"0.6906625",
"0.686975",
"0.6785399",
"0.67540044",
"0.66884893",
"0.66840935",
"0.66407... | 0.7288089 | 9 |
test that having an event handler that doesn't do anything keeps the behavior in place for a fatal error. | def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):
engine = ping_fixture
@event.listens_for(engine, "handle_error")
def setup_disconnect(ctx):
assert not ctx.is_disconnect
with expect_raises_message(
exc.DBAPIError, "unhandled disconnect situat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_not_implemented(self):\n\n test_handler = EventHandler(self.mock_interruption_event)\n\n with self.assertRaises(NotImplementedError):\n test_handler.handle()",
"def test_sandbox_errors_false(self):\n SignalHook(self.test_extension, self.signal, self._on_signal_exception,\... | [
"0.7467973",
"0.6660555",
"0.65037405",
"0.64326495",
"0.64048284",
"0.63686633",
"0.63043034",
"0.62444484",
"0.62275404",
"0.62135327",
"0.62035763",
"0.6167127",
"0.61608183",
"0.6148361",
"0.6082591",
"0.60748696",
"0.6074616",
"0.6068908",
"0.6063432",
"0.6061368",
"0.60... | 0.6120394 | 14 |
test that having an event handler that doesn't do anything keeps the behavior in place for a disconnect error. | def test_event_handler_didnt_downgrade_disconnect(
self, ping_fixture_all_errs_disconnect
):
engine = ping_fixture_all_errs_disconnect
@event.listens_for(engine, "handle_error")
def setup_disconnect(ctx):
assert ctx.is_pre_ping
assert ctx.is_disconnect
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_event_handler_didnt_upgrade_disconnect(self, ping_fixture):\n engine = ping_fixture\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert not ctx.is_disconnect\n\n with expect_raises_message(\n exc.DBAPIError, \"unhandled d... | [
"0.78867626",
"0.76576835",
"0.73965603",
"0.7263293",
"0.7216937",
"0.7042568",
"0.6785579",
"0.65975875",
"0.6531375",
"0.6502572",
"0.6493144",
"0.64641625",
"0.64185786",
"0.64083093",
"0.6385069",
"0.6377654",
"0.6374116",
"0.63512623",
"0.6334448",
"0.63215125",
"0.6294... | 0.7935945 | 0 |
test that an event hook can receive a fatal error and convert it to be a disconnect error during preping | def test_event_handler_can_upgrade_disconnect(self, ping_fixture):
engine = ping_fixture
@event.listens_for(engine, "handle_error")
def setup_disconnect(ctx):
assert ctx.is_pre_ping
ctx.is_disconnect = True
conn = engine.connect()
# no error
con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_di... | [
"0.70234233",
"0.6971551",
"0.66948354",
"0.6495688",
"0.61916995",
"0.61216474",
"0.6121415",
"0.59488285",
"0.5900851",
"0.5878428",
"0.5877062",
"0.58651876",
"0.58647805",
"0.586168",
"0.58307934",
"0.58160025",
"0.5814683",
"0.579428",
"0.5790778",
"0.5782339",
"0.578072... | 0.6286811 | 4 |
test that an event hook can receive a disconnect error and convert it to be a fatal error during preping | def test_event_handler_can_downgrade_disconnect(
self, ping_fixture_all_errs_disconnect
):
engine = ping_fixture_all_errs_disconnect
@event.listens_for(engine, "handle_error")
def setup_disconnect(ctx):
assert ctx.is_disconnect
if ctx.is_pre_ping:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_event_handler_didnt_downgrade_disconnect(\n self, ping_fixture_all_errs_disconnect\n ):\n engine = ping_fixture_all_errs_disconnect\n\n @event.listens_for(engine, \"handle_error\")\n def setup_disconnect(ctx):\n assert ctx.is_pre_ping\n assert ctx.is_di... | [
"0.75634176",
"0.7460929",
"0.690459",
"0.6380832",
"0.6284205",
"0.61783296",
"0.61361533",
"0.61084944",
"0.6066335",
"0.60619",
"0.59785515",
"0.5976626",
"0.59717333",
"0.594296",
"0.5942044",
"0.59340584",
"0.59147024",
"0.5885476",
"0.58497363",
"0.5848464",
"0.58413315... | 0.73141897 | 2 |
Given a model instance save it to the database. | def save_model(self, request, obj, form, change):
obj.save()
casestudy_id = request.session.get('casestudy', None)
if casestudy_id is not None:
casestudy = CaseStudy.objects.get(pk=casestudy_id)
pic = PublicationInCasestudy.objects.get_or_create(
casestudy... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save_model(self):\n pass",
"def save_model( self, request, obj, form, change ):\n obj.save()",
"def save(self):\n self.presavemodel()\n self.d... | [
"0.77996397",
"0.7456527",
"0.7434235",
"0.7422407",
"0.73011315",
"0.7194706",
"0.7194706",
"0.7194706",
"0.7194706",
"0.71695006",
"0.71580917",
"0.71512944",
"0.7132259",
"0.7122476",
"0.7114611",
"0.7114611",
"0.7114611",
"0.7114611",
"0.7114611",
"0.7114611",
"0.7114611"... | 0.0 | -1 |
NotifyReviewEvent returns comments for a ReviewEvent. | def NotifyReviewEvent(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_review_comments_body(\n self, pull_request_number: int) -> List[Tuple[str, str]]:\n review_comments = get_pull_request_review_comments(\n self._repo_name, pull_request_number, self._auth)\n if not review_comments:\n return []\n review_comments_msg = []... | [
"0.5948147",
"0.5384553",
"0.5373081",
"0.5350771",
"0.53389245",
"0.5330528",
"0.53114086",
"0.53063893",
"0.53036827",
"0.52942955",
"0.5259007",
"0.5222319",
"0.52145696",
"0.5210138",
"0.51832515",
"0.5155651",
"0.5119935",
"0.50863373",
"0.5073527",
"0.5065843",
"0.50623... | 0.523376 | 11 |
NotifyPushEvent is not expected to return any comments. Its purpose for now is to notify the analyzer of a new push to a repository, that could be used to trigger training tasks over new contents. | def NotifyPushEvent(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_push(self, payload):\n pass",
"def notify(self, event):\n\n self.send_json(event[\"payload\"])",
"def push(event):\n _pushedEvents.append(event)",
"def send_notification (event):\n Publisher.sendMessage (event)",
"def notify(self, event):\n raise NotImplementedError",
"def... | [
"0.6505522",
"0.6299715",
"0.62783396",
"0.6245916",
"0.6223001",
"0.5992067",
"0.59633183",
"0.59553176",
"0.59267044",
"0.58976245",
"0.58153737",
"0.5808903",
"0.574537",
"0.5725313",
"0.5693843",
"0.5667237",
"0.5548502",
"0.55202025",
"0.5500606",
"0.54958946",
"0.547965... | 0.62791127 | 2 |
Given K and N, r, w and b are calculated Then, given r, w and b, all generations' value and decision functions are calculated BACKWARD | def IterateValues(self):
agrid = self.agrid
self.w = self.setwage(self.K, self.N)
self.r = self.setrate(self.K, self.N)
self.b = self.benefit(self.N)
for l in range(self.Na):
self.c[-1][l] = agrid[l]*(1+self.r) + self.b
self.v[-1][l] = self.ut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def B(n, k):\n assert 0 < k <= n\n global lookup\n for index_y in range(len(lookup), n + 1):\n lookup.append([1])\n min_value = min(index_y, k)\n for index_x in range(min_value):\n if index_x < len(lookup[index_y - 1]) - 1:\n lookup[index_y].append(lookup[ind... | [
"0.6306666",
"0.6230689",
"0.60974103",
"0.60286343",
"0.6020426",
"0.5946944",
"0.5886355",
"0.5848057",
"0.5817468",
"0.5804055",
"0.57914394",
"0.5780807",
"0.5776807",
"0.5772554",
"0.57718253",
"0.5769636",
"0.5736517",
"0.57279",
"0.572249",
"0.57167286",
"0.5711532",
... | 0.5691289 | 22 |
Find a bracket (a,b,c) such that policy function for next period asset level, a[x;asset[l],y] lies in the interval (a,b) | def GetBracket(self, y, l, m, agrid):
a, b, c = agrid[0], agrid[0]-agrid[1], agrid[0]-agrid[2]
m0 = m
v0 = self.neg
while a > b or b > c:
v1 = self.value(y, agrid[l], agrid[m])
if v1 > v0:
if m == 0:
a, b = agrid[m], agrid[m]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_coeff(depth, period = 2*pi):\n\tfund_feq = 2 * pi / period\n\tAK = []\n\talphaK = []\n\n\tfor n in range(1, depth+1):\n\t\tdef a_function(x, i):\n\t\t\treturn input_function(x) * cos(i * fund_feq * x)\n\t\tdef b_function(x, i):\n\t\t\treturn input_function(x) * sin(i * fund_feq * x)\n\t\t(a, err) = quad(a... | [
"0.5546394",
"0.5514575",
"0.54493105",
"0.54006404",
"0.5219616",
"0.51849455",
"0.5173916",
"0.51624197",
"0.5160456",
"0.5154094",
"0.5153953",
"0.5153",
"0.5130451",
"0.5096638",
"0.5061676",
"0.5000963",
"0.49834117",
"0.49589533",
"0.49504474",
"0.4946693",
"0.49326152"... | 0.5270328 | 4 |
Compute the aggregate capital stock and employment, K and N FORWARD | def CalculatePaths(self):
agrid = self.agrid
self.apath = array([0 for y in range(self.T)], dtype=float)
self.cpath = array([0 for y in range(self.T)], dtype=float)
self.npath = array([0 for y in range(self.T)], dtype=float)
# generate each generation's asset, consumption... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_industry_neutral_nway_return(df, name, sorts, cuts, long_bucket, short_bucket, ind_col='sic1', ret_col='ret'):\n df = df.copy()\n\n # n-way sort\n keys = ['time_idx', ind_col]\n for sort, cut in zip(sorts, cuts):\n df[sort] = df.groupby(keys, as_index=False)[sort].transform(lambda ... | [
"0.5929503",
"0.581313",
"0.5744221",
"0.5742783",
"0.55948293",
"0.5589375",
"0.5517828",
"0.54931015",
"0.5415928",
"0.5380793",
"0.53703797",
"0.53422695",
"0.53379637",
"0.53265834",
"0.5309885",
"0.5304519",
"0.53018254",
"0.5298242",
"0.52609056",
"0.5260335",
"0.526007... | 0.0 | -1 |
Directly solve each generation's optimal a', c and n In this case, apath, cpath and npath store agents' policy functions In the other case of value interation, the above three paths are calculated from each generation's value functions. | def IteratePaths(self):
self.w = self.setwage(self.K, self.N)
self.r = self.setrate(self.K, self.N)
self.b = self.benefit(self.N)
a1, aT = [-1,], []
for q in range(self.Nq):
if q == 0:
self.apath[-1] = 0.2
elif q == 1:
sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_f... | [
"0.645377",
"0.6445745",
"0.63432974",
"0.62200356",
"0.61490154",
"0.6128947",
"0.61050683",
"0.60996634",
"0.5940299",
"0.5918258",
"0.59127754",
"0.59035313",
"0.5874269",
"0.5844865",
"0.5841971",
"0.5836568",
"0.58337045",
"0.5832805",
"0.58261335",
"0.58163935",
"0.5784... | 0.63130635 | 3 |
Directly solve capital and labor supply given next two periods capitals y is given as 2, 3, ..., 60, i.e., through the nexttolast to the first | def DirectSolve(self, y):
if y >= -self.R:
a1 = self.apath[y+1]
if y == -2:
a2 = 0
else:
a2 = self.apath[y+2]
def constraints(a):
c0 = (1+self.r)*a + self.b - a1
c1 = (1+self.r)*a1 + s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve_working(\n assets_this_period,\n assets_next_period,\n hc_this_period,\n hc_next_period,\n interest_rate,\n wage_rate,\n income_tax_rate,\n beta,\n gamma,\n sigma,\n neg,\n continuation_value,\n delta_hc,\n zeta,\n psi,\n n_gridpoints_capital,\n n_gridpo... | [
"0.55686235",
"0.5486277",
"0.524329",
"0.52351224",
"0.5226248",
"0.5210025",
"0.5138276",
"0.5105185",
"0.50864774",
"0.5027095",
"0.5025979",
"0.5024181",
"0.49958742",
"0.49447542",
"0.49234024",
"0.49014944",
"0.48865473",
"0.48819074",
"0.4879534",
"0.48610735",
"0.4859... | 0.0 | -1 |
Return the value at the given generation and asset a0 and corresponding consumption and labor supply when the agent chooses his next period asset a1, current period consumption c and labor n a1 is always within Kmin and Kmax | def value(self, y, a0, a1):
if y >= -self.R: # y = -2, -3, ..., -60
c, n = (1+self.r)*a0 + self.b - a1, 0
else:
c, n = self.solve(a0,a1)
v = self.util(c,n) + self.beta*self.vtilde[y+1](a1)
return v if c > 0 else self.neg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_cooling_output_for_supply_air_estimation(\n a_a: float, q: float, mu_c: float, v_vent: np.ndarray,\n theta_ex: np.ndarray, x_ex: np.ndarray, j: np.ndarray,\n hc_period: np.ndarray, n_p: np.ndarray, q_gen: np.ndarray, w_gen: np.ndarray, v_local: np.ndarray,\n theta_set_c: float, ... | [
"0.59520787",
"0.57533324",
"0.5703326",
"0.56623435",
"0.560426",
"0.5583759",
"0.55615014",
"0.5517298",
"0.5457148",
"0.54422075",
"0.53810215",
"0.53772193",
"0.5371446",
"0.53696233",
"0.5366299",
"0.5357143",
"0.5323624",
"0.53230184",
"0.5311603",
"0.5301882",
"0.52647... | 0.494033 | 74 |
Compute the aggregate capital stock and employment, K and N FORWARD from Chebyshev polynomials | def CalculateChebyPaths(self):
Kmin, Kmax = self.Kmin, self.Kmax
self.apath = array([0 for y in range(self.T)], dtype=float)
self.cpath = array([0 for y in range(self.T)], dtype=float)
self.npath = array([0 for y in range(self.T)], dtype=float)
# generate each generation's asset,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chebyshev_polynomial(X, k):\n print(\"Calculating Chebyshev polynomials up to order {}...\".format(k))\n\n T_k = list()\n T_k.append(sp.eye(X.shape[0]).tocsr())\n T_k.append(X)\n\n def chebyshev_recurrence(T_k_minus_one, T_k_minus_two, X):\n X_ = sp.csr_matrix(X, copy=True)\n retur... | [
"0.5805574",
"0.568245",
"0.5679868",
"0.5634262",
"0.55871993",
"0.54936045",
"0.5484346",
"0.54805106",
"0.5462374",
"0.5451627",
"0.54347575",
"0.54347575",
"0.54025716",
"0.53955644",
"0.5385762",
"0.5380132",
"0.53783524",
"0.53712624",
"0.5367456",
"0.5344546",
"0.53184... | 0.0 | -1 |
returns coefficients of Chebyshev Regression of f with m sample points on the interval [min,max], and n is the order of chebyshev polynomials | def chebcoef(self,f,n,m,Kmin,Kmax):
z = -cos((linspace(1,m,m)*2-1)*pi/(2*m*1.0))
x = (z+1)*(Kmax-Kmin)/2.0 + Kmin
y = f(x)
# print 'x, f(x):', x, y
T0 = ones(m)
T1 = z
a = zeros(n+1)
a[0] = sum(y)/(m*1.0)
a[1] = dot(y,T1)/dot(T1,T1)
for i i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chebyshev_coeffs(f, n):\n extrema = np.cos((np.pi * np.arange(2*n))/n)\n samples = f(extrema)\n coeffs = np.real(np.fft.fft(samples))[:n+1]\n coeffs /= n \n coeffs[0] /= 2\n coeffs[n] /= 2\n\n return coeffs",
"def random_coefficients(self, n=3, max_range = 10):\n return np.random.... | [
"0.7639109",
"0.6433395",
"0.6052176",
"0.60155755",
"0.59195346",
"0.57900774",
"0.57421833",
"0.5741759",
"0.5730309",
"0.56809217",
"0.5661867",
"0.55754876",
"0.5554896",
"0.5551868",
"0.5530003",
"0.5522098",
"0.55102664",
"0.5499079",
"0.54902244",
"0.54771787",
"0.5465... | 0.7481705 | 1 |
This method does NOT work!! except for some parameter values like eco = projectionmethod(N=2,tol=0.01,R=5,W=10,beta=0.98,delta=0.05,ncheb=2) | def projection(e,N=30):
start_time = datetime.now() # records the starting time
for i in range(N):
e.IterateCheby()
e.CalculateChebyPaths()
e.Aggregate()
if e.Converged:
print 'Converged! in',i+1,'iterations with tolerance level',e.tol
break
end_time =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Projection(W, TYPE_PROJ = proj_l11ball, ETA = 100, AXIS = 0, ETA_STAR = 100, device = \"cpu\" ): \n \n #global TYPE_PROJ, ETA, ETA_STAR, AXIS, device \n if TYPE_PROJ == 'No_proj':\n W_new = W\n if (TYPE_PROJ == proj_l1ball or TYPE_PROJ == proj_l11ball or TYPE_PROJ == proj_l11ball_line )... | [
"0.606067",
"0.60375684",
"0.5986863",
"0.5974436",
"0.5932277",
"0.5917319",
"0.5792665",
"0.57505715",
"0.573772",
"0.56984025",
"0.5694427",
"0.5688644",
"0.5684781",
"0.5637021",
"0.562528",
"0.5622044",
"0.55693513",
"0.55580497",
"0.5556933",
"0.55527645",
"0.55185956",... | 0.6673543 | 0 |
Computes a scale matrix. | def scale(v: InputTensor) -> t.Tensor:
v = util.to_tensor(v, dtype=t.float32)
assert len(v.shape) == 1
return t.diag(t.cat([v, v.new_ones([1])], dim=0)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scaleMatrix(self, sx=0, sy=0, sz=0):\n\n return np.array([[sx, 0, 0, 0],\n [0, sy, 0, 0],\n [0, 0, sz, 0],\n [0, 0, 0, 1]])",
"def Scale(*args, **kwargs):\n return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)",
"d... | [
"0.7577946",
"0.7523797",
"0.74303293",
"0.7282001",
"0.7124156",
"0.7081991",
"0.70752174",
"0.7051836",
"0.69150233",
"0.6839642",
"0.6801334",
"0.6769318",
"0.6742835",
"0.66912425",
"0.6654237",
"0.6651771",
"0.65922874",
"0.64853823",
"0.64189833",
"0.6410784",
"0.639885... | 0.0 | -1 |
Computes a translation matrix. | def translate(v: InputTensor) -> t.Tensor:
result = util.to_tensor(v, dtype=t.float32)
assert len(result.shape) >= 1
dimensions = result.shape[-1]
result = result[..., None, :].transpose(-1, -2)
result = t.constant_pad_nd(result, [dimensions, 0, 0, 1])
id_matrix = t.diag(result.new_ones([dimensions + 1]))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TranslationMatrix(x, y, z):\n\treturn np.matrix([ [1., 0., 0., x],\n\t\t\t\t\t\t[0., 1., 0., y],\n\t\t\t\t\t\t[0., 0., 1., z],\n\t\t\t\t\t\t[0., 0., 0., 1.]])",
"def translation_matrix(tx, ty, tz):\n T = np.array([[1, 0, 0, tx],\n [0, 1, 0, ty],\n [0, 0, 1, tz],\n ... | [
"0.7476626",
"0.73376346",
"0.71156037",
"0.70561665",
"0.70042557",
"0.69543445",
"0.68936795",
"0.6859392",
"0.6858805",
"0.6777836",
"0.6776042",
"0.67170495",
"0.6642511",
"0.6580854",
"0.6550882",
"0.6474842",
"0.64231503",
"0.63632214",
"0.6332118",
"0.63255674",
"0.629... | 0.5711762 | 62 |
Transforms a batch of 3D points with a batch of matrices. | def transform_points_homogeneous(points: InputTensor,
matrix: InputTensor, w: float) -> t.Tensor:
points = util.to_tensor(points, dtype=t.float32)
matrix = util.to_tensor(matrix, dtype=t.float32)
assert points.shape[-1] == 3
assert matrix.shape[-2:] == (4, 4)
assert points.sha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_transformation(self, points):\n assert (points.shape[0] == 3)\n n = points.shape[1]\n points_ = np.vstack((points, np.ones((1, n))))\n points_trans_ = np.matmul(self.pose_mat, points_)\n points_transformed = np.true_divide(points_trans_[:3, :], points_trans_[[-1], :])\n... | [
"0.68185866",
"0.6803297",
"0.67199254",
"0.66627663",
"0.63769263",
"0.63079566",
"0.62875766",
"0.62417156",
"0.6226377",
"0.61661714",
"0.6095978",
"0.60583246",
"0.6042413",
"0.6042413",
"0.6038547",
"0.60366297",
"0.5996688",
"0.59671736",
"0.59586704",
"0.59217936",
"0.... | 0.58872557 | 20 |
Transforms a single 3D mesh. | def transform_mesh(mesh: InputTensor, matrix: InputTensor,
vertices_are_points=True) -> t.Tensor:
mesh = util.to_tensor(mesh, dtype=t.float32)
matrix = util.to_tensor(matrix, dtype=t.float32)
assert mesh.shape[-2:] == (3, 3)
assert matrix.shape[-2:] == (4, 4)
assert mesh.shape[:-3] == matr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform(self, data):\n self.cube = self.trf.transform(data)",
"def GetTransform(self, *args) -> \"itkTransformD33 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF3MF3TD33_GetTransform(self, *args)",
"def GetTransform(self, *args) -> \"itkTransformF33 *\":\n return... | [
"0.6724482",
"0.6628377",
"0.6589676",
"0.6446487",
"0.6304848",
"0.6281156",
"0.6236697",
"0.62262785",
"0.61985016",
"0.6182246",
"0.6143696",
"0.6117967",
"0.6096631",
"0.60931605",
"0.6072821",
"0.603262",
"0.6030979",
"0.5999245",
"0.5990135",
"0.5965643",
"0.59506994",
... | 0.66893816 | 1 |
Computes a lefthanded 4x4 lookat camera matrix. | def look_at_lh(eye: InputTensor, center: InputTensor,
up: InputTensor) -> t.Tensor:
eye = util.to_tensor(eye, dtype=t.float32)
center = util.to_tensor(center, dtype=t.float32)
up = util.to_tensor(up, dtype=t.float32)
assert eye.shape == (3,)
assert center.shape == (3,)
assert up.shape == (3,)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass",
"def camera_matrix(self) -> TransformationMatrixType:\n return numpy.matmul(\n self.rotation_matrix(*self.rotation),\n displacement_matrix(*-numpy.array(self.location)),\n )",
"def per... | [
"0.5941741",
"0.5775757",
"0.5662558",
"0.5599011",
"0.5386134",
"0.5304439",
"0.52797616",
"0.5268123",
"0.5224661",
"0.5198523",
"0.5161968",
"0.5151681",
"0.51350677",
"0.51214856",
"0.50689846",
"0.5061132",
"0.5058804",
"0.504136",
"0.50070995",
"0.5004285",
"0.4988299",... | 0.0 | -1 |
Computes a righthanded 4x4 lookat camera matrix. | def look_at_rh(eye: InputTensor, center: InputTensor,
up: InputTensor) -> t.Tensor:
eye = util.to_tensor(eye, dtype=t.float32)
center = util.to_tensor(center, dtype=t.float32)
up = util.to_tensor(up, dtype=t.float32)
assert eye.shape == (3,)
assert center.shape == (3,)
assert up.shape == (3,)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCameraMatrix(self): # real signature unknown; restored from __doc__\n pass",
"def camera_matrix(self) -> TransformationMatrixType:\n return numpy.matmul(\n self.rotation_matrix(*self.rotation),\n displacement_matrix(*-numpy.array(self.location)),\n )",
"def cam... | [
"0.604629",
"0.5690877",
"0.566058",
"0.546934",
"0.5419739",
"0.53992414",
"0.53747255",
"0.53564847",
"0.53442174",
"0.533645",
"0.53151274",
"0.52816457",
"0.52754575",
"0.5259618",
"0.5208826",
"0.5179219",
"0.5169666",
"0.51681334",
"0.51548636",
"0.5148781",
"0.5135079"... | 0.0 | -1 |
Get the ratio of ICX to sICX. | def getRate(self) -> int:
if (self._total_stake.get() + self._daily_reward.get()) == 0:
rate = DENOMINATOR
else:
rate = (self._total_stake.get() + self._daily_reward.get()) * DENOMINATOR // self.sICX_score.totalSupply()
return rate | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csi(self):\n return self.table[0, 0] / (self.table[0, 0] + self.table[0, 1] + self.table[1, 0])",
"def cci(self) -> float:\n return self._cci",
"def coi(self, s):\n return 2 ** 0.5 * s",
"def as_integer_ratio(self): # real signature unknown; restored from __doc__\n pass",
"d... | [
"0.60738033",
"0.5845884",
"0.583743",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.57556456",
"0.56797916",
... | 0.0 | -1 |
Only necessary for the dummy contract. | def setSicxSupply(self) -> None:
self._sICX_supply.set(self.sICX_score.totalSupply()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RequiredContract(self) -> _n_0_t_1:",
"def dummy(self):\n pass",
"def contract_pepo_pbc():\n pass",
"def test_stub(self):\n pass",
"def _dummy(ticket):\r\n return True",
"def test_block_bad_signature(self):\n pass",
"def dummy_fn(self):\n\t\tpass",
"def __call__(self) -... | [
"0.6988934",
"0.6948609",
"0.66215193",
"0.6288151",
"0.606796",
"0.604304",
"0.597733",
"0.5960648",
"0.5929356",
"0.5910414",
"0.5864295",
"0.5847082",
"0.5847082",
"0.5843603",
"0.5816594",
"0.5808959",
"0.58019507",
"0.57961833",
"0.5791844",
"0.57686216",
"0.57359856",
... | 0.0 | -1 |
Get the address of sICX token contract. | def getSicxAddress(self) -> Address:
return self._sICX_address.get() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_address(self):\n if self.address:\n return self.address",
"def get_address(self, ):\n return self.get_parameter('address')",
"def _get_address(self):\n return self.__address",
"def address(self) -> str:\n return pulumi.get(self, \"address\")",
"def address(self) -... | [
"0.6026088",
"0.6024718",
"0.6004629",
"0.5933634",
"0.5933634",
"0.5933634",
"0.5915871",
"0.5914371",
"0.5914371",
"0.59061444",
"0.5879427",
"0.58482677",
"0.5840453",
"0.5836381",
"0.5836381",
"0.5836381",
"0.5836381",
"0.5836381",
"0.5824099",
"0.58240896",
"0.5750373",
... | 0.6808541 | 0 |
Returns the total staked amount stored in a vardb _total_stake. | def getTotalStake(self) -> int:
return self._total_stake.get() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_spent(self):\n total_sum = Order.objects.filter(\n email=self.email).aggregate(\n Sum('total_price')\n ).get('total_price__sum')\n return round(total_sum, 4) if total_sum else 0",
"def total_sold(album):\n return album.total_sold",
"def total(self):\n ... | [
"0.65858716",
"0.6538318",
"0.62111753",
"0.6138218",
"0.6135569",
"0.6123897",
"0.6095115",
"0.60794395",
"0.60766083",
"0.6074283",
"0.6031743",
"0.5965689",
"0.5964389",
"0.59520096",
"0.5926538",
"0.59139526",
"0.590713",
"0.5894734",
"0.58571315",
"0.5856632",
"0.5830383... | 0.8146318 | 0 |
Returns the total rewards earned up to now by the staking contract. | def getLifetimeReward(self) -> int:
return self._total_lifetime_reward.get() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_rewards(self) -> float:\n return self.__total_rewards",
"def getTotalReward(self):\n return self.cumreward",
"def getTotalReward(self):\n return self.cumreward",
"def getTotalReward(self):\n return self.lastFitness",
"def total_reward(self):\n return np.sum(self.rew... | [
"0.74350184",
"0.7319174",
"0.7319174",
"0.6883852",
"0.67559856",
"0.67167974",
"0.6656435",
"0.6656435",
"0.6656435",
"0.66351753",
"0.65298206",
"0.6467578",
"0.6409539",
"0.63020545",
"0.6262705",
"0.6262705",
"0.62345237",
"0.6190423",
"0.6136656",
"0.61360705",
"0.61356... | 0.5873769 | 39 |
Returns the top prep addresses that is set every week. | def getTopPreps(self) -> list:
top_prep_list= []
for x in self._top_preps:
top_prep_list.append(x)
return top_prep_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_top_seven_routes(self):\n df = self.filter_according_to_travel_day('Sunday')\n # Group the dataset according to the frequency of the travel route\n df =df.groupby([\"travel_from\", \"travel_to\"]).size().reset_index(name=\"Frequency\")\n #Sort the dataset according to the frequ... | [
"0.5992419",
"0.5827104",
"0.5596639",
"0.5556763",
"0.5274141",
"0.52575624",
"0.51689905",
"0.5167692",
"0.5102182",
"0.5079598",
"0.50520396",
"0.5037802",
"0.49485672",
"0.4947178",
"0.49291557",
"0.49205166",
"0.49199647",
"0.4886885",
"0.48541108",
"0.48188907",
"0.4788... | 0.5099575 | 9 |
Returns a dictionary that shows wallet address as a key and the request of unstaked amount by that address as a value. | def getUserUnstakeInfo(self) -> list:
unstake_info_list =[]
for items in self._linked_list_var:
unstake_info_list.append([items[1],items[2]])
return unstake_info_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def address_transactions_unspent(self, address):\n res = r.get(self.url + self.address_unspent + str(address))\n return self.execute(res)",
"def address_transactions_unconfirmed(self, address):\n res = r.get(self.url + self.address_unconfirmed + str(address))\n return self.execute(res... | [
"0.6371236",
"0.5843207",
"0.5801892",
"0.5744291",
"0.5730674",
"0.5722021",
"0.57213354",
"0.5651544",
"0.5647592",
"0.5630476",
"0.5613511",
"0.5587668",
"0.553333",
"0.55286324",
"0.5524606",
"0.54863155",
"0.54595",
"0.5434609",
"0.54137826",
"0.5393165",
"0.5364194",
... | 0.0 | -1 |
Sets the sICX address from staking contract. | def setSicxAddress(self, _address: Address) -> None:
self._sICX_address.set(_address) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_contract_addr(self, addr):\n\t\tself.contract_addr = addr\n\t\tself._bank_inst = self._w3.eth.contract(\n\t\t\taddress=self.contract_addr,\n\t\t\tabi=self._iface[\"abi\"],\n\t\t)",
"def set_address(self, address):\n pass",
"def getSicxAddress(self) -> Address:\n return self._sICX_address.... | [
"0.7022209",
"0.668352",
"0.6504335",
"0.60547084",
"0.5994743",
"0.5949447",
"0.59453374",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5931548",
"0.5877724",
"0.58283544",
"0.56609696",
"0.5632742",
"0.5621456",
"0.5613599",
... | 0.76929194 | 0 |
Weekly this function is called to set the top 100 prep address in an arraydb | def _set_top_preps(self) -> None :
prep_dict = self._system.getPReps(1, 20)
prep_address_list = prep_dict['preps']
for each_prep in prep_address_list:
self._top_preps.put(each_prep['address']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def partition_geocode(con: sqlite3.Connection, cur: sqlite3.Cursor, quarter: str, county_cht: str):\n cur.execute('''SELECT 土地區段位置或建物區門牌 FROM \"{0}/TRX\"\n WHERE 縣市 = ?\n GROUP BY 土地區段位置或建物區門牌;'''.format(quarter), (county_cht,))\n for address, in cur.fetchall():\n c... | [
"0.511866",
"0.50577724",
"0.504898",
"0.5036274",
"0.49281853",
"0.48955876",
"0.48717105",
"0.48107842",
"0.47876543",
"0.47528073",
"0.47337833",
"0.4712964",
"0.47108823",
"0.46957618",
"0.46719283",
"0.4665297",
"0.4657939",
"0.46463177",
"0.46462315",
"0.4643902",
"0.46... | 0.6340167 | 0 |
Returns the amount to be minted to a address | def _get_amount_to_mint(self) -> int:
supply = self._sICX_supply.get()
balance = self.getTotalStake()
if balance == self.msg.value:
amount = self.msg.value
else:
amount = supply * self.msg.value // (balance - self.msg.value)
return amount | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mint(amount: int) -> int:\n global total_supply\n\n _assert_is_bank(context.sender)\n total_supply = base.mint(balance_of, total_supply, context.sender, amount)\n return total_supply",
"def get_address_balance(litecoinaddress):\n total_balance = 0\n unspent = list_unspent(litecoinaddress)\n... | [
"0.69586235",
"0.6636571",
"0.64191425",
"0.6284753",
"0.62760067",
"0.62711406",
"0.6152331",
"0.6129017",
"0.6064553",
"0.58940786",
"0.58726585",
"0.5836371",
"0.5781485",
"0.5695222",
"0.5656765",
"0.5585638",
"0.55727005",
"0.5548005",
"0.5546406",
"0.55363196",
"0.55116... | 0.6663697 | 1 |
Sets the new top 100 prep address in an array db weekly after checking the specific conditions. | def _reset_top_preps(self) -> None:
if self._system.getIISSInfo()["nextPRepTerm"] > self._block_height_week.get() + (7 * 43200):
self._block_height_week.set(self._system.getIISSInfo()["nextPRepTerm"])
for i in range(len(self._top_preps)):
self._top_preps.pop()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_top_preps(self) -> None :\n prep_dict = self._system.getPReps(1, 20)\n prep_address_list = prep_dict['preps']\n for each_prep in prep_address_list:\n self._top_preps.put(each_prep['address'])",
"def update_weekly_total(areacode=AREACODE,areaname=AREA):\n start,stop=mo... | [
"0.63330156",
"0.53173107",
"0.49326813",
"0.49134898",
"0.48076132",
"0.47747403",
"0.47253653",
"0.46731806",
"0.46633682",
"0.46196696",
"0.4618803",
"0.46049136",
"0.45915735",
"0.4584027",
"0.45573524",
"0.45506656",
"0.45506567",
"0.45332375",
"0.45256045",
"0.4525433",
... | 0.5096449 | 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.