= 2:\\n rhat_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\\n else:\\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on rhat, setting zero', 'red')\\n rhat_err = np.array([0,0])\\n \\n # --------------------------------------------------------------------\\n ### DELTA2\\n theta_val = np.linspace(delta2/rang, delta2*rang, rang_N)\\n x2LL = np.zeros(len(theta_val))\\n for i in range(len(x2LL)):\\n x2LL[i] = nnl_2logL(rhat=rhat, delta2=theta_val[i], r=r, s2=s2)\\n\\n ind = chi2range(x2LL=x2LL, x2LL_hat=x2LL_hat, alpha=alpha)\\n\\n if len(ind) >= 2:\\n delta2_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\\n else:\\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on delta2, setting zero', 'red')\\n delta2_err = np.array([0,0])\\n\\n # Check for NaN\\n if np.isnan(rhat):\\n cprint(__name__ + f'.nnl_combine: WARNING: rhat is NaN, setting zero', 'red')\\n if np.isnan(delta2):\\n cprint(__name__ + f'.nnl_combine: WARNING: delta2 is NaN, setting zero', 'red')\\n\\n return rhat, delta2, rhat_err, delta2_err\",\n \"def method1(self):\\n cres=0. # Variable for storing Chern number.\\n # The U matrices from Fukui's method; storage...\\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n # ... and calculation of U matrices\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.alleigvecs[:,:,ix ,iy ]\\n if ix<self.kS.Nx:\\n mat2=self.alleigvecs[:,:,ix+1,iy ]\\n else:\\n mat2=self.alleigvecs[:,:,1 ,iy ]\\n if iy<self.kS.Ny:\\n mat3=self.alleigvecs[:,:,ix ,iy+1]\\n else:\\n mat3=self.alleigvecs[:,:,ix ,1 ]\\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\\n \\n # Local estimates of Berry curvature; storage ...\\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\\n # ... and calculation\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\\n\\n return cres.real, ftempall\",\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 compute_ul_ur(self, dt):\\n\\n g = self.grid\\n # compute the piecewise linear slopes\\n # here we define the range cells considered, including 1 ghost cell\\n # on each side\\n ib = g.ng-1\\n ie = g.ng + g.N\\n\\n u = g.u\\n \\n # initialize empty arrays\\n dc = np.zeros((g.N+2*g.ng))\\n dl = np.zeros((g.N+2*g.ng))\\n dr = np.zeros((g.N+2*g.ng))\\n \\n dc[ib:ie+1] = 0.5*(u[ib+1:ie+2] - u[ib-1:ie ])\\n dl[ib:ie+1] = u[ib+1:ie+2] - u[ib :ie+1]\\n dr[ib:ie+1] = u[ib :ie+1] - u[ib-1:ie ]\\n\\n # minmod()\\n # fabs is the absolute value for real valued inputs\\n # where does np.where(condition,if true keep this value, else this)\\n # d1 = 2.0*np.where(np.fabs(dl) < np.fabs(dr), dl, dr)\\n d1 = np.zeros((len(dl)))\\n for i in range(len(dl)):\\n if np.fabs(dl[i]) < np.fabs(dr[i]):\\n d1[i] = dl[i]\\n else:\\n d1[i] = dr[i]\\n d1 = 2.0*d1\\n \\n d2 = np.zeros((len(dc)))\\n for i in range(len(dc)):\\n if np.fabs(dc[i]) < np.fabs(d1[i]):\\n d2[i] = dc[i]\\n else:\\n d2[i] = d1[i] \\n \\n # d2 = np.where(np.fabs(dc) < np.fabs(d1), dc, d1)\\n ldeltau = np.zeros((len(d2)))\\n for i in range(len(d2)):\\n if dl[i]*dr[i] > 0.0:\\n ldeltau[i] = d2[i]\\n else:\\n ldeltau[i] = 0.0\\n # ldeltau = np.where(dl*dr > 0.0, d2, 0.0)\\n\\n # interface states. \\n # Note from hydro_examples:\\n # note that there are 1 more interfaces than zones\\n ul = np.zeros((g.N+2*g.ng))\\n ur = np.zeros((g.N+2*g.ng))\\n\\n ur[ib:ie+2] = u[ib:ie+2] - \\\\\\n 0.5*(1.0 + u[ib:ie+2]*dt/self.grid.dx)*ldeltau[ib:ie+2]\\n\\n ul[ib+1:ie+2] = u[ib:ie+1] + \\\\\\n 0.5*(1.0 - u[ib:ie+1]*dt/self.grid.dx)*ldeltau[ib:ie+1]\\n\\n return ul, ur\",\n \"def method2(self):\\n cres=np.zeros(self.NL,dtype=float) # List of invariants\\n # The U matrices from Fukui's method; storage...\\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n for il in range(self.NL):\\n # ... and calculation of U matrices for each layer\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.LDM[il,ix ,iy ,:,:]\\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\\n \\n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\\n \\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\\n \\n return cres\",\n \"def potentialSolver5(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def illuminator_of_elfes():\\n\\n\\t# Alpha - simplified by taking out the i by multiplying the outerproduct by 2i\\n\\talpha1i = np.matrix([[0, 0, 0, 2], [0, 0, 2, 0], [0, -2, 0, 0], [-2, 0, 0, 0]])\\n\\talpha2i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, 2], [0, 0, -2, 0]])\\n\\talpha3i = np.matrix([[0, 0, 2, 0], [0, 0, 0, -2], [-2, 0, 0, 0], [0, 2, 0, 0]])\\n\\n\\t# Betas - simplified by taking out the i by multiplication of outerprod by 2i\\n\\tbeta1i = np.matrix([[0, 0, 0, 2], [0, 0, -2, 0], [0, 2, 0, 0], [-2, 0, 0, 0]])\\n\\tbeta2i = np.matrix([[0, 0, 2, 0], [0, 0, 0, 2], [-2, 0, 0, 0], [0, -2, 0, 0]])\\n\\tbeta3i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, -2], [0, 0, 2, 0]])\\n\\n\\t# print(\\\"alpha 1\\\")\\n\\t# print(alpha1i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"alpha 2\\\")\\n\\t# print(alpha2i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"alpha 3\\\")\\n\\t# print(alpha3i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 1\\\")\\n\\t# print(beta1i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 2\\\")\\n\\t# print(beta2i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 3\\\")\\n\\t# print(beta3i)\\n\\t# print(\\\"\\\")\\n\\n\\t# abperm_comb = [ np.multiply(alpha1i,-1), np.multiply(alpha2i,-1), np.multiply(alpha3i,-1), np.multiply(beta1i,-1), np.multiply(beta2i,-1), np.multiply(beta3i,-1)]\\n\\n\\tabperm_comb = [alpha1i, alpha2i, alpha3i, beta1i, beta2i, beta3i]\\n\\treturn abperm_comb\",\n \"def test_el_below_lcl():\\n p = [902.1554, 897.9034, 893.6506, 889.4047, 883.063, 874.6284, 866.2387, 857.887,\\n 849.5506, 841.2686, 833.0042, 824.7891, 812.5049, 796.2104, 776.0027, 751.9025,\\n 727.9612, 704.1409, 680.4028, 656.7156, 629.077, 597.4286, 565.6315, 533.5961,\\n 501.2452, 468.493, 435.2486, 401.4239, 366.9387, 331.7026, 295.6319, 258.6428,\\n 220.9178, 182.9384, 144.959, 106.9778, 69.00213] * units.hPa\\n t = [-3.039381, -3.703779, -4.15996, -4.562574, -5.131827, -5.856229, -6.568434,\\n -7.276881, -7.985013, -8.670911, -8.958063, -7.631381, -6.05927, -5.083627,\\n -5.11576, -5.687552, -5.453021, -4.981445, -5.236665, -6.324916, -8.434324,\\n -11.58795, -14.99297, -18.45947, -21.92021, -25.40522, -28.914, -32.78637,\\n -37.7179, -43.56836, -49.61077, -54.24449, -56.16666, -57.03775, -58.28041,\\n -60.86264, -64.21677] * units.degC\\n td = [-22.08774, -22.18181, -22.2508, -22.31323, -22.4024, -22.51582, -22.62526,\\n -22.72919, -22.82095, -22.86173, -22.49489, -21.66936, -21.67332, -21.94054,\\n -23.63561, -27.17466, -31.87395, -38.31725, -44.54717, -46.99218, -43.17544,\\n -37.40019, -34.3351, -36.42896, -42.1396, -46.95909, -49.36232, -48.94634,\\n -47.90178, -49.97902, -55.02753, -63.06276, -72.53742, -88.81377, -93.54573,\\n -92.92464, -91.57479] * units.degC\\n prof = parcel_profile(p, t[0], td[0]).to('degC')\\n el_p, el_t = el(p, t, td, prof)\\n assert_nan(el_p, p.units)\\n assert_nan(el_t, t.units)\",\n \"def _compute_kl(self, lvl):\\n kl = [] # kernal length\\n for n in range(lvl):\\n fct = self.scaling**n # up-sampling factor\\n kl.append(fct*(self.nfreq-1)+1)\\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\\n return kl[::-1]\",\n \"def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\\n #epsx = (1/2)*(eps1+eps2)\\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def hausdorffDistance13(self,id1,id2):\\n #productive #math\\n profprint()\\n node1 = slicer.mrmlScene.GetNodeByID(id1)\\n polydata1=node1.GetPolyData()\\n node2 = slicer.mrmlScene.GetNodeByID(id2)\\n polydata2=node2.GetPolyData()\\n nb1 = polydata1.GetNumberOfPoints()\\n nb2 = polydata2.GetNumberOfPoints()\\n minimum=None\\n maximum=None\\n JJ,jj=None,None\\n II,ii=None,None\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n polydata1.GetPoint(1,pt1)\\n polydata1.GetPoint(nb1-1,pt2)\\n minVal1=min(pt1[2],pt2[2])\\n maxVal1=max(pt1[2],pt2[2])\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n pt1b,pt2b=None,None\\n polydata2.GetPoint(1,pt1)\\n polydata2.GetPoint(nb2-1,pt2)\\n minVal2 = min(pt1[2],pt2[2])\\n maxVal2 = max(pt1[2],pt2[2])\\n valueBase=max(minVal1,minVal2)\\n valueTip=min(maxVal1,maxVal2)\\n cellId=vtk.mutable(1)\\n subid=vtk.mutable(1)\\n dist=vtk.mutable(1)\\n cl2=vtk.vtkCellLocator()\\n cl2.SetDataSet(polydata2)\\n cl2.BuildLocator()\\n # Hausforff 1 -> 2\\n minima=[]\\n for i in range(int(nb1/float(100))):\\n pt=[0,0,0]\\n polydata1.GetPoint(100*i,pt)\\n closest=[0,0,0]\\n cl2.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff12 = max(minima)\\n \\n # Hausforff 2 -> 1\\n minima=[]\\n cl1=vtk.vtkCellLocator()\\n cl1.SetDataSet(polydata1)\\n cl1.BuildLocator()\\n for i in range(int(nb2/float(10))):\\n pt=[0,0,0]\\n polydata2.GetPoint(10*i,pt)\\n closest=[0,0,0]\\n cl1.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff21 = max(minima)\\n return max(hausdorff12,hausdorff21)\",\n \"def _u_kln(self, eTs, protocol, noBeta=False):\\n L = len(protocol)\\n\\n addMM = ('MM' in protocol[0].keys()) and (protocol[0]['MM'])\\n addSite = ('site' in protocol[0].keys()) and (protocol[0]['site'])\\n probe_keys = ['MM','k_angular_ext','k_spatial_ext','k_angular_int'] + \\\\\\n scalables\\n probe_key = [key for key in protocol[0].keys() if key in probe_keys][0]\\n\\n if isinstance(eTs, dict):\\n # There is one configuration per state\\n K = len(eTs[probe_key])\\n N_k = np.ones(K, dtype=int)\\n u_kln = []\\n E_base = np.zeros(K)\\n if addMM:\\n E_base += eTs['MM']\\n if addSite:\\n E_base += eTs['site']\\n for l in range(L):\\n E = 1. * E_base\\n for scalable in scalables:\\n if scalable in protocol[l].keys():\\n E += protocol[l][scalable] * eTs[scalable]\\n for key in ['k_angular_ext', 'k_spatial_ext', 'k_angular_int']:\\n if key in protocol[l].keys():\\n E += protocol[l][key] * eTs[key]\\n if noBeta:\\n u_kln.append(E)\\n else:\\n u_kln.append(E / (R * protocol[l]['T']))\\n elif isinstance(eTs[0], dict):\\n K = len(eTs)\\n N_k = np.array([len(eTs[k][probe_key]) for k in range(K)])\\n u_kln = np.zeros([K, L, N_k.max()], np.float)\\n\\n for k in range(K):\\n E_base = 0.0\\n if addMM:\\n E_base += eTs[k]['MM']\\n if addSite:\\n E_base += eTs[k]['site']\\n for l in range(L):\\n E = 1. * E_base\\n for scalable in scalables:\\n if scalable in protocol[l].keys():\\n E += protocol[l][scalable] * eTs[k][scalable]\\n for key in ['k_angular_ext', 'k_spatial_ext', 'k_angular_int']:\\n if key in protocol[l].keys():\\n E += protocol[l][key] * eTs[k][key]\\n if noBeta:\\n u_kln[k, l, :N_k[k]] = E\\n else:\\n u_kln[k, l, :N_k[k]] = E / (R * protocol[l]['T'])\\n elif isinstance(eTs[0], list):\\n K = len(eTs)\\n N_k = np.zeros(K, dtype=int)\\n\\n for k in range(K):\\n for c in range(len(eTs[k])):\\n N_k[k] += len(eTs[k][c][probe_key])\\n u_kln = np.zeros([K, L, N_k.max()], np.float)\\n\\n for k in range(K):\\n E_base = 0.0\\n C = len(eTs[k])\\n if addMM:\\n E_base += np.concatenate([eTs[k][c]['MM'] for c in range(C)])\\n if addSite:\\n E_base += np.concatenate([eTs[k][c]['site'] for c in range(C)])\\n for l in range(L):\\n E = 1. * E_base\\n for scalable in scalables:\\n if scalable in protocol[l].keys():\\n E += protocol[l][scalable]*np.concatenate([eTs[k][c][scalable] \\\\\\n for c in range(C)])\\n for key in ['k_angular_ext', 'k_spatial_ext', 'k_angular_int']:\\n if key in protocol[l].keys():\\n E += protocol[l][key]*np.concatenate([eTs[k][c][key] \\\\\\n for c in range(C)])\\n if noBeta:\\n u_kln[k, l, :N_k[k]] = E\\n else:\\n u_kln[k, l, :N_k[k]] = E / (R * protocol[l]['T'])\\n\\n if (K == 1) and (L == 1):\\n return u_kln.ravel()\\n else:\\n return (u_kln, N_k)\",\n \"def HaarGOB(treeG):\\n # number of level of the chain (or tree)\\n Ntr = len(treeG)\\n # reorder chain (optional) \\n # reordering each level so that in each level the nodes are in the\\n # descent order of degrees\\n # compute u_l^c for level J_0 (top level)\\n clusterJ0 = treeG[Ntr-1]['clusters']\\n N0 = len(clusterJ0)\\n # generate indicator function on G^c\\n chic = np.identity(N0)\\n uc = [None]*N0\\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\\n for l in np.arange(1, N0):\\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\\n# u = copy.deepcopy(uc)\\n treeG[Ntr-1]['u'] = uc\\n # compute the next level orthonormal basis ulk and stored into u\\n for j_tr in np.arange(0, Ntr-1)[::-1]:\\n N1 = len(treeG[j_tr]['clusters'])\\n u = [None]*N1\\n i = N0\\n for l in range(N0):\\n clusterl = treeG[j_tr+1]['clusters'][l]\\n kl = len(clusterl)\\n #for k==1\\n ucl = uc[l]\\n ul1 = np.zeros(N1)\\n for j in range(N0):\\n idxj = treeG[j_tr+1]['clusters'][j]\\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\\n u[l] = ul1\\n if kl>1:\\n chil = np.zeros((kl,N1))\\n for k in range(kl):\\n idxl = treeG[j_tr+1]['clusters'][l]\\n chil[k,idxl[k]] = 1;\\n \\n for k in np.arange(1,kl):\\n i = i+1\\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\\n u[i-1] = ulk\\n treeG[j_tr]['u'] = u\\n # update uc and N0\\n# uc = copy.deepcopy(u)\\n uc = u\\n N0 = N1\\n return treeG\",\n \"def helical_consistency(p2i, p1):\\n\\tfrom pixel_error import angle_diff\\n\\tfrom math import cos,pi\\n\\tfrom utilities import getvec\\n\\tfrom pixel_error import angle_error\\n\\tfrom EMAN2 import Vec2f\\n\\tn =len(p1[0])\\n\\tprint n\\n\\tqtm = -1.0e10\\n\\tfor lf in xrange(0,181,180):\\n\\t\\tp2 = []\\n\\t\\tp2.extend(p2i)\\n\\t\\tif( lf == 180):\\n\\t\\t\\ttflip = Transform({\\\"type\\\":\\\"spider\\\",\\\"theta\\\":180.0})\\n\\t\\t\\tfor j in xrange(n):\\n\\t\\t\\t\\tt2 = Transform({\\\"type\\\":\\\"spider\\\",\\\"phi\\\":p2[0][j],\\\"theta\\\":p2[1][j],\\\"psi\\\":p2[2][j]})\\n\\t\\t\\t\\tt2.set_trans( Vec2f( -p2[3][j], -p2[4][j] ) )\\n\\t\\t\\t\\tt2 = t2*tflip\\n\\t\\t\\t\\td = t2.get_params(\\\"spider\\\")\\n\\t\\t\\t\\tp2[0][j] = d[\\\"phi\\\"]\\n\\t\\t\\t\\tp2[1][j] = d[\\\"theta\\\"]\\n\\t\\t\\t\\tp2[2][j] = d[\\\"psi\\\"]\\n\\t\\t\\t\\tp2[3][j] = -d[\\\"tx\\\"]\\n\\t\\t\\t\\tp2[4][j] = -d[\\\"ty\\\"]\\n\\t\\ttt1 = [0.0]*n\\n\\t\\ttt2 = [0.0]*n\\n\\t\\tmirror = [False]*n\\n\\t\\tln = 0\\n\\t\\tfor j in xrange( n ):\\n\\t\\t\\tt1 = getvec(p1[0][j],p1[1][j])\\n\\t\\t\\tt2 = getvec(p2[0][j],p2[1][j])\\n\\t\\t\\ttm = getvec(180.0+p2[0][j],180.0-p2[1][j])\\n\\t\\t\\ttt1[j] = t1[0]*t2[0]+t1[1]*t2[1]+t1[2]*t2[2]\\n\\t\\t\\ttt2[j] = t1[0]*tm[0]+t1[1]*tm[1]+t1[2]*tm[2]\\n\\t\\t\\tif(abs(tt1[j])<1.0e-7): tt1[j] = 0.0\\n\\t\\t\\tif(abs(tt2[j])<1.0e-7): tt2[j] = 0.0\\n\\t\\t\\tif(tt1[j]>tt2[j]):\\n\\t\\t\\t\\tmirror[j] = True\\n\\t\\t\\t\\tln+=1\\n\\t\\tprint \\\" FLIP \\\",lf\\n\\t\\tif(ln < n//2):\\n\\t\\t\\tprint \\\"mirror \\\",ln\\n\\t\\t\\tfor j in xrange( n ):\\n\\t\\t\\t\\tp2[0][j] += 180.0\\n\\t\\t\\t\\tp2[1][j] = 180.0-p2[1][j]\\n\\t\\t\\t\\tp2[2][j] = -p2[2][j]\\n\\t\\t\\t\\tp2[4][j] = -p2[4][j]\\n\\t\\t\\t\\tmirror[j] = not(mirror[j])\\n\\t\\telse:\\n\\t\\t\\tprint \\\" straight\\\", ln\\n\\t\\tphi1 = []\\n\\t\\tphi2 = []\\n\\t\\tagree = []\\n\\t\\tfor j in xrange(n):\\n\\t\\t\\tif(mirror[j]):\\n\\t\\t\\t\\tphi1.append(p1[0][j])\\n\\t\\t\\t\\tphi2.append(p2[0][j])\\n\\t\\t\\t\\tagree.append(j)\\n\\t\\tprint len(phi1)\\n\\t\\tdelta_phi = angle_diff( phi2, phi1 )\\n\\t\\tprint \\\"close form diff===\\\", delta_phi\\n\\n\\t\\tphi1 = []\\n\\t\\tphi2 = []\\n\\t\\terrorm = []\\n\\t\\tfor j in xrange( len( p1[0]) ):\\n\\t\\t\\tp2[0][j] = (p2[0][j] + delta_phi + 360)%360.0\\n\\t\\t\\tif(mirror[j]):\\n\\t\\t\\t\\tphi1.append(p1[0][j])\\n\\t\\t\\t\\tphi2.append(p2[0][j])\\n\\t\\t\\t\\terrorm.append(angle_error( [ p2[0][j] ], [ p1[0][j] ]))\\n\\t\\tqt = sum(errorm)/len(errorm)\\n\\t\\tprint len(errorm),qt\\n\\t\\tif(qt > qtm):\\n\\t\\t\\tqtm = qt\\n\\t\\t\\tp2o = []\\n\\t\\t\\tp2o.extend(p2)\\n\\t\\t\\terrormo = []\\n\\t\\t\\tphi1o = []\\n\\t\\t\\tphi2o = []\\n\\t\\t\\terrormo.extend(errorm)\\n\\t\\t\\tphi1o.extend(phi1)\\n\\t\\t\\tphi2o.extend(phi2)\\n\\t\\t\\n\\treturn p2o, errormo, agree, delta_phi, phi1o, phi2o\",\n \"def test_2():\\n\\n # generate two locusts of points\\n npts = 100\\n epsilon = 0.001\\n # #cluster 1\\n coords1 = generate_locus_of_3d_points(npts, 0.1, 0.1, 0.1, epsilon=epsilon)\\n # cluster 2\\n coords2 = generate_locus_of_3d_points(npts, 0.9, 0.9, 0.9, epsilon=epsilon)\\n\\n # generate orientation vectors for cluster 1\\n vectors1 = generate_aligned_vectors(len(coords1))\\n\\n # calculate dot product between vectors1 and cluster 2\\n r = np.sqrt((0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2)\\n # s, vector between coords1 and cluster2\\n s = np.zeros((npts, 3))\\n s[:, 0] = 0.9 - coords1[:, 0]\\n s[:, 1] = 0.9 - coords1[:, 1]\\n s[:, 2] = 0.9 - coords1[:, 2]\\n\\n # calculate dot product between orientation and direction between cluster 1 and 2\\n angles = angles_between_list_of_vectors(vectors1, s)\\n avg_two_costheta_1 = np.mean(np.cos(2.0 * angles))\\n avg_two_costheta_2 = np.mean(2.0 * np.cos(angles) * np.cos(angles) - 1.0)\\n assert np.isclose(\\n avg_two_costheta_1, avg_two_costheta_2\\n ) # test trig identify used in weighting function\\n avg_two_costheta = avg_two_costheta_2\\n\\n # define radial bins\\n rbins = np.array([0.0, 0.1, r + 2.0 * epsilon])\\n\\n # define weights appropiate for weighting function\\n weights1 = np.ones((npts, 4))\\n weights1[:, 1] = vectors1[:, 0]\\n weights1[:, 2] = vectors1[:, 1]\\n weights1[:, 3] = vectors1[:, 2]\\n weights2 = np.ones(npts)\\n\\n # calculate weighted counts\\n weighted_counts, counts = positional_marked_npairs_3d(\\n coords1,\\n coords2,\\n rbins,\\n period=None,\\n weights1=weights1,\\n weights2=weights2,\\n weight_func_id=2,\\n num_threads=1,\\n )\\n\\n msg = \\\"weighted counts do not match expected result given the weighting function\\\"\\n assert np.isclose(\\n weighted_counts[-1], avg_two_costheta * counts[-1], rtol=1.0 / npts\\n ), msg\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def cie_luv(self):\\n K = Fraction(29, 3) ** 3\\n e = Fraction(6, 29) ** 3\\n XYZ = self.cie_xyz\\n yr = XYZ[1] / D65[1]\\n L = 116 * yr ** Fraction(1, 3) - 16 if yr > e else K * yr\\n u = 13 * L * (U(*XYZ) - U(*D65))\\n v = 13 * L * (V(*XYZ) - V(*D65))\\n return (L, u, v)\",\n \"def j2_pert(s):\\n\\n r = np.linalg.norm(s[0:3])\\n K = -3*mu*J2*(Re**2)/2/r**5\\n comp = np.array([1,1,3])\\n comp = comp - 5*(s[2]/r)**2\\n comp = np.multiply(comp,s[0:3])\\n comp = np.multiply(K,comp)\\n\\n return comp\",\n \"def __init__(self, u1=(1,0,0), u2=(0,1,0), u3=(0,0,1)):\\n u1 = vec3(u1)\\n u2 = vec3(u2)\\n u3 = vec3(u3)\\n\\n if triple_scalar_product(u1, u2, u3) != 1:\\n print >> sys.stderr, \\\"!! Invalid lattice vectors: u1 = %s, u2 = %s, u3 = %s\\\" % (u1,u2,u3)\\n self.e1 = vec3(1,0,0)\\n self.e2 = vec3(0,1,0)\\n self.e3 = vec3(0,0,1)\\n else:\\n s1 = square(u1)\\n s2 = square(u2)\\n d12 = dot(u1, u2)\\n d23 = dot(u2, u3)\\n d13 = dot(u1, u3)\\n alpha = -d12/s1\\n gamma = -(alpha*d13 + d23)/(alpha*d12 + s2)\\n beta = -(d13 + gamma*d12)/s1\\n self.e1 = u1\\n self.e2 = u2 + alpha*u1\\n self.e3 = u3 + beta*u1 + gamma*u2\\n\\n if verbose:\\n print(\\\"e1 = %s\\\" % self.e1)\\n print(\\\"e2 = %s\\\" % self.e2)\\n print(\\\"e3 = %s\\\" % self.e3)\\n\\n self.L1 = length(self.e1)\\n self.L2 = length(self.e2)\\n self.L3 = length(self.e3)\\n self.n1 = self.e1/self.L1\\n self.n2 = self.e2/self.L2\\n self.n3 = self.e3/self.L3\\n self.cells = []\\n\\n v0 = vec3(0,0,0)\\n self.v = [v0,\\n v0 + self.e3,\\n v0 + self.e2,\\n v0 + self.e2 + self.e3,\\n v0 + self.e1,\\n v0 + self.e1 + self.e3,\\n v0 + self.e1 + self.e2,\\n v0 + self.e1 + self.e2 + self.e3]\\n\\n # Compute bounding box of cuboid\\n xs = [vk.x for vk in self.v]\\n ys = [vk.y for vk in self.v]\\n zs = [vk.z for vk in self.v]\\n vmin = vec3(min(xs), min(ys), min(zs))\\n vmax = vec3(max(xs), max(ys), max(zs))\\n\\n # Extend to nearest integer coordinates\\n ixmin = int(floor(vmin.x))\\n ixmax = int(ceil(vmax.x))\\n iymin = int(floor(vmin.y))\\n iymax = int(ceil(vmax.y))\\n izmin = int(floor(vmin.z))\\n izmax = int(ceil(vmax.z))\\n if verbose:\\n print(\\\"ixmin, ixmax = %d, %d\\\" % (ixmin,ixmax))\\n print(\\\"iymin, iymax = %d, %d\\\" % (iymin,iymax))\\n print(\\\"izmin, izmax = %d, %d\\\" % (izmin,izmax))\\n\\n # Determine which cells (and which faces within those cells) are non-trivial\\n for ix in range(ixmin, ixmax):\\n for iy in range(iymin, iymax):\\n for iz in range(izmin, izmax):\\n shift = vec3(-ix, -iy, -iz)\\n faces = [Plane(self.v[0] + shift, +self.n1),\\n Plane(self.v[4] + shift, -self.n1),\\n Plane(self.v[0] + shift, +self.n2),\\n Plane(self.v[2] + shift, -self.n2),\\n Plane(self.v[0] + shift, +self.n3),\\n Plane(self.v[1] + shift, -self.n3)]\\n\\n c = Cell(ix, iy, iz)\\n skipcell = False\\n for f in faces:\\n r = UnitCubeTest(f)\\n if r == +1:\\n # Unit cube is completely above this plane; this cell is empty\\n continue\\n elif r == 0:\\n # Unit cube intersects this plane; keep track of it\\n c.faces.append(f)\\n elif r == -1:\\n skipcell = True\\n break\\n\\n if skipcell or len(c.faces) == 0:\\n if verbose:\\n print(\\\"Skipping cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n continue\\n else:\\n self.cells.append(c)\\n if verbose:\\n print(\\\"Adding cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n\\n # For the identity remapping, use exactly one cell\\n if len(self.cells) == 0:\\n self.cells.append(Cell())\\n\\n # Print the full list of cells\\n if verbose:\\n print(\\\"%d non-empty cells\\\" % len(self.cells))\\n for c in self.cells:\\n print(\\\"Cell at (%d,%d,%d) has %d non-trivial planes\\\" % (c.ix,\\n c.iy, c.iz, len(c.faces)))\",\n \"def weyl_coordinates(U: np.ndarray) -> np.ndarray:\\n import scipy.linalg as la\\n\\n pi2 = np.pi / 2\\n pi4 = np.pi / 4\\n\\n U = U / la.det(U) ** (0.25)\\n Up = transform_to_magic_basis(U, reverse=True)\\n # We only need the eigenvalues of `M2 = Up.T @ Up` here, not the full diagonalization.\\n D = la.eigvals(Up.T @ Up)\\n\\n d = -np.angle(D) / 2\\n d[3] = -d[0] - d[1] - d[2]\\n cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)\\n\\n # Reorder the eigenvalues to get in the Weyl chamber\\n cstemp = np.mod(cs, pi2)\\n np.minimum(cstemp, pi2 - cstemp, cstemp)\\n order = np.argsort(cstemp)[[1, 2, 0]]\\n cs = cs[order]\\n d[:3] = d[order]\\n\\n # Flip into Weyl chamber\\n if cs[0] > pi2:\\n cs[0] -= 3 * pi2\\n if cs[1] > pi2:\\n cs[1] -= 3 * pi2\\n conjs = 0\\n if cs[0] > pi4:\\n cs[0] = pi2 - cs[0]\\n conjs += 1\\n if cs[1] > pi4:\\n cs[1] = pi2 - cs[1]\\n conjs += 1\\n if cs[2] > pi2:\\n cs[2] -= 3 * pi2\\n if conjs == 1:\\n cs[2] = pi2 - cs[2]\\n if cs[2] > pi4:\\n cs[2] -= pi2\\n\\n return cs[[1, 0, 2]]\",\n \"def blueschist_felsic():\\n\\n rho = 2970.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 149.85; C[0,1] = 38.7; C[0,2] = 32.59; C[0,3] = -0.15; C[0,4] = -1.; C[0,5] = -0.19\\n C[1,0] = C[0,1]; C[1,1] = 163.55; C[1,2] = 30.03; C[1,3] = 1.05; C[1,4] = -1.81; C[1,5] = -1.78\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 121.62; C[2,3] = 0.22; C[2,4] = -0.95; C[2,5] = -0.13\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 48.03; C[3,4] = -0.63; C[3,5] = -1.14\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 48.62; C[4,5] = -0.01\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 58.42\\n\\n return C, rho\",\n \"def beta_gen_lasso(p):\\n cardi = 0.005\\n return np.array([0]*int(p-int(cardi*p)) + [1]*int(cardi*p))\",\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 prepare_r_uls_r_lus(\\n number_of_levels,\\n number_of_shells,\\n j_blues,\\n excitation_species,\\n nlte_data,\\n ):\\n # number_of_levels = atomic_data_levels.energy.loc[\\n # excitation_species\\n # ].count() do this in the solver\\n lnl = nlte_data.lines_level_number_lower[excitation_species]\\n lnu = nlte_data.lines_level_number_upper[excitation_species]\\n (lines_index,) = nlte_data.lines_idx[excitation_species]\\n\\n try:\\n j_blues_filtered = j_blues.iloc[lines_index]\\n except AttributeError:\\n j_blues_filtered = j_blues\\n A_uls = nlte_data.A_uls[excitation_species]\\n B_uls = nlte_data.B_uls[excitation_species]\\n B_lus = nlte_data.B_lus[excitation_species]\\n r_lu_index = lnu * number_of_levels + lnl\\n r_ul_index = lnl * number_of_levels + lnu\\n r_ul_matrix = np.zeros(\\n (number_of_levels, number_of_levels, number_of_shells),\\n dtype=np.float64,\\n )\\n r_ul_matrix_reshaped = r_ul_matrix.reshape(\\n (number_of_levels**2, number_of_shells)\\n )\\n r_ul_matrix_reshaped[r_ul_index] = (\\n A_uls[np.newaxis].T + B_uls[np.newaxis].T * j_blues_filtered\\n )\\n r_lu_matrix = np.zeros_like(r_ul_matrix)\\n r_lu_matrix_reshaped = r_lu_matrix.reshape(\\n (number_of_levels**2, number_of_shells)\\n )\\n r_lu_matrix_reshaped[r_lu_index] = (\\n B_lus[np.newaxis].T * j_blues_filtered\\n )\\n return (\\n lines_index,\\n r_ul_index,\\n r_ul_matrix,\\n r_lu_index,\\n r_lu_matrix,\\n )\\n # TODO: beta sobolev needs to be recalculated for each iteration, because it depends on number density\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def find_large_separation2(self):\\n\\n ind = (self.modes['l'] == 0).flat\\n n = self.modes['n'].compress(ind)\\n if (len(n) < 2): return np.nan\\n freq = self.modes['freq'].compress(ind)\\n coeff = np.polyfit(n,freq,1)\\n return coeff[0]\",\n \"def TST_LCE(S,N1,N_per,alpha,model_C2ST, w_C2ST, b_C2ST, device,dtype):\\r\\n np.random.seed(seed=1102)\\r\\n torch.manual_seed(1102)\\r\\n torch.cuda.manual_seed(1102)\\r\\n N = S.shape[0]\\r\\n f = torch.nn.Softmax()\\r\\n output = f(model_C2ST(S).mm(w_C2ST) + b_C2ST)\\r\\n # pred_C2ST = output.max(1, keepdim=True)[1]\\r\\n STAT = abs(output[:N1,0].type(torch.FloatTensor).mean() - output[N1:,0].type(torch.FloatTensor).mean())\\r\\n STAT_vector = np.zeros(N_per)\\r\\n for r in range(N_per):\\r\\n ind = np.random.choice(N, N, replace=False)\\r\\n # divide into new X, Y\\r\\n ind_X = ind[:N1]\\r\\n ind_Y = ind[N1:]\\r\\n # print(indx)\\r\\n STAT_vector[r] = abs(output[ind_X,0].type(torch.FloatTensor).mean() - output[ind_Y,0].type(torch.FloatTensor).mean())\\r\\n S_vector = np.sort(STAT_vector)\\r\\n threshold = S_vector[np.int(np.ceil(N_per * (1 - alpha)))]\\r\\n threshold_lower = S_vector[np.int(np.ceil(N_per * alpha))]\\r\\n h = 0\\r\\n if STAT.item() > threshold:\\r\\n h = 1\\r\\n return h, threshold, STAT\",\n \"def lltnum(self,):\\n m = self.m\\n n = self.n\\n diag = self.diag\\n perm = self.perm\\n AAt = self.AAt\\n kAAt = self.kAAt\\n iAAt = self.iAAt\\n mark = self.mark\\n self.denwin\\n\\n m2 = m+n\\n #/*------------------------------------------------------+\\n #| initialize constants */\\n\\n temp = np.zeros(m2)\\n first = np.zeros(m2, dtype=np.int)\\n link = np.empty(m2, dtype=np.int)\\n for i in range(m2):\\n link[i] = -1\\n\\n maxdiag=0.0\\n for i in range(m2):\\n if abs(diag[i]) > maxdiag:\\n maxdiag = abs(diag[i])\\n\\n self.ndep=0\\n\\n #/*------------------------------------------------------+\\n #| begin main loop - this code is taken from George and |\\n #| Liu's book, pg. 155, modified to do LDLt instead |\\n #| of LLt factorization. */\\n\\n for i in range(m2):\\n diagi = diag[i]\\n sgn_diagi = -1 if perm[i] < n else 1\\n j = link[i]\\n while j != -1:\\n newj = link[j]\\n k = first[j]\\n lij = AAt[k]\\n lij_dj = lij*diag[j]\\n diagi -= lij*lij_dj\\n k_bgn = k+1\\n k_end = kAAt[j+1]\\n if k_bgn < k_end:\\n first[j] = k_bgn\\n row = iAAt[k_bgn]\\n link[j] = link[row]\\n link[row] = j\\n if j < self.denwin:\\n for kk in range(k_bgn, k_end):\\n temp[iAAt[kk]] += lij_dj*AAt[kk]\\n else:\\n ptr = row\\n for kk in range(k_bgn, k_end):\\n temp[ptr] += lij_dj*AAt[kk]\\n ptr+=1\\n\\n j=newj\\n\\n k_bgn = kAAt[i]\\n k_end = kAAt[i+1]\\n for kk in range(k_bgn, k_end):\\n row = iAAt[kk]\\n AAt[kk] -= temp[row]\\n\\n if abs(diagi) <= self.epsnum*maxdiag or mark[i] == False:\\n\\n #if (sgn_diagi*diagi <= epsnum*maxdiag || mark[i] == FALSE)\\n\\n self.ndep+=1\\n maxoffdiag = 0.0\\n for kk in range(k_bgn, k_end):\\n maxoffdiag = max( maxoffdiag, abs( AAt[kk] ) )\\n\\n if maxoffdiag < 1.0e+6*self._EPS:\\n mark[i] = False\\n else:\\n diagi = sgn_diagi * self._EPS\\n\\n diag[i] = diagi\\n if k_bgn < k_end:\\n first[i] = k_bgn\\n row = iAAt[k_bgn]\\n link[i] = link[row]\\n link[row] = i\\n for kk in range(k_bgn, k_end):\\n row = iAAt[kk]\\n if mark[i]:\\n AAt[kk] /= diagi\\n else:\\n AAt[kk] = 0.0\\n\\n temp[row] = 0.0\\n\\n del(link)\\n del(first)\\n del(temp)\",\n \"def w3j000(L, l, lp, Fks):\\n\\n J = L + l + lp \\n if (J % 2 == 1) or (l + lp < L) or (np.abs(l - lp) > L):\\n return 0.\\n\\n res = (-1)**(J/2) * (Fks[J/2 - L] * Fks[J/2 - l] * Fks[J/2 - lp]) / (Fks[J/2] * (J + 1.)**0.5)\\n \\n return res\",\n \"def calculate_v6_L(chi_6222, chi_6222_err, chi_633, chi_633_err, vn_array):\\n dN = real(vn_array[:, 0])\\n v2_array = vn_array[:, 2]\\n v3_array = vn_array[:, 3]\\n v6_array = vn_array[:, 6]\\n nev = len(dN)\\n\\n v6_Psi6_sq = mean(abs(v6_array)**2.)\\n v6_Psi6_sq_err = std(abs(v6_array)**2.)/sqrt(nev)\\n v2_6 = mean(abs(v2_array)**6.)\\n v2_6_err = std(abs(v2_array)**6.)/sqrt(nev)\\n v3_4 = mean(abs(v3_array)**4.)\\n v3_4_err = std(abs(v3_array)**4.)/sqrt(nev)\\n v23 = real(mean(v2_array**3.*conj(v3_array)**2.))\\n v23_err = real(std(v2_array**3.*conj(v3_array)**2.))/sqrt(nev)\\n v6_L = (v6_Psi6_sq - chi_6222**2.*v2_6 - chi_633**2.*v3_4\\n - 2.*chi_6222*chi_633*v23)\\n v6_L_err = sqrt(\\n v6_Psi6_sq_err**2.\\n + (2.*chi_6222*chi_6222_err*v2_6)**2. + (chi_6222**2.*v2_6_err)**2.\\n + (2.*chi_633*chi_633_err*v3_4)**2. + (chi_633**2.*v3_4_err)**2.\\n + (2.*chi_6222_err*chi_633*v23)**2.\\n + (2.*chi_6222*chi_633_err*v23)**2.\\n + (2.*chi_6222*chi_633*v23_err)**2.)\\n return(v6_L, v6_L_err)\",\n \"def potentialSolver4(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\\n \\n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\\n# epsx = (1/2)*(eps1+eps2)\\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def _apply_array_spatial12_lowfilling_python(self, h1e: 'Nparray',\\n h2e: 'Nparray') -> 'Nparray':\\n out = self._apply_array_spatial1(h1e)\\n\\n norb = self.norb()\\n nalpha = self.nalpha()\\n nbeta = self.nbeta()\\n lena = self.lena()\\n lenb = self.lenb()\\n nlt = norb * (norb + 1) // 2\\n\\n h2ecomp = numpy.zeros((nlt, nlt), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for k in range(norb):\\n for l in range(k + 1, norb):\\n h2ecomp[ijn, k + l * (l + 1) // 2] = (h2e[i, j, k, l] -\\n h2e[i, j, l, k] -\\n h2e[j, i, k, l] +\\n h2e[j, i, l, k])\\n\\n if nalpha - 2 >= 0:\\n alpha_map, _ = self._core.find_mapping(-2, 0)\\n intermediate = numpy.zeros(\\n (nlt, int(binom(norb, nalpha - 2)), lenb), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n work = self.coeff[source, :] * parity\\n intermediate[ijn, target, :] += work\\n\\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n out[source, :] -= intermediate[ijn, target, :] * parity\\n\\n if self.nalpha() - 1 >= 0 and self.nbeta() - 1 >= 0:\\n alpha_map, beta_map = self._core.find_mapping(-1, -1)\\n intermediate = numpy.zeros((norb, norb, int(binom(\\n norb, nalpha - 1)), int(binom(norb, nbeta - 1))),\\n dtype=self._dtype)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n sign = ((-1)**(nalpha - 1)) * paritya\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = self.coeff[sourcea, sourceb] * sign * parityb\\n intermediate[i, j, targeta, targetb] += 2 * work\\n\\n intermediate = numpy.tensordot(h2e, intermediate, axes=2)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n sign = ((-1)**nalpha) * paritya\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = intermediate[i, j, targeta, targetb] * sign\\n out[sourcea, sourceb] += work * parityb\\n\\n if self.nbeta() - 2 >= 0:\\n _, beta_map = self._core.find_mapping(0, -2)\\n intermediate = numpy.zeros((nlt, lena, int(binom(norb, nbeta - 2))),\\n dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in beta_map[(i, j)]:\\n work = self.coeff[:, source] * parity\\n intermediate[ijn, :, target] += work\\n\\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, sign in beta_map[(min(i, j), max(i,\\n j))]:\\n out[:, source] -= intermediate[ijn, :, target] * sign\\n return out\",\n \"def euc_dist(self, squared=True):\",\n \"def lagrangePoints(mu):\\n \\n # define l = 1-mu\\n l = 1 - mu\\n \\n # collinear points\\n def eqL1(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)+mu-l)*x**2 + (mu**2*l**2+2*(l**2+mu**2))*x + mu**3-l**3\\n #fval = gamma**5 - (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 + 2*mu*gamma - mu\\n return fval\\n sol_l1 = optimize.root(eqL1, 0.5, method='hybr')\\n l1 = np.array([sol_l1.x[0] , 0, 0])\\n \\n def eqL2(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)-(mu+l))*x**2 + (mu**2*l**2+2*(l**2-mu**2))*x - (mu**3+l**3)\\n #fval = gamma**5 + (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 - 2*mu*gamma - mu\\n return fval\\n sol_l2 = optimize.root(eqL2, 1.5, method='hybr')\\n l2 = np.array([sol_l2.x[0] , 0, 0])\\n \\n def eqL3(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*mu*l+mu**2)*x**3 + (2*mu*l*(l-mu)+(l+mu))*x**2 + (mu**2*l**2+2*(mu**2-l**2))*x + l**3+mu**3\\n return fval\\n sol_l3 = optimize.root(eqL3, -1, method='hybr')\\n l3 = np.array([sol_l3.x[0] , 0, 0])\\n \\n # equilateral points\\n # L4\\n l4 = np.array([np.cos(np.pi/3) - mu , np.sin(np.pi/3), 0])\\n # L5\\n l5 = np.array([np.cos(np.pi/3) - mu , -np.sin(np.pi/3), 0])\\n \\n return _lagrangePointsReturn(l1,l2,l3,l4,l5)\",\n \"def prepare_CvD16_for_M2L_calc(templates_lam_range, verbose=False):\\n import glob\\n import os\\n template_glob=os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*.s100')\\n\\n vcj_models=sorted(glob.glob(template_glob))\\n temp_lamdas, x35, x3, x23, kroupa, flat=np.genfromtxt(vcj_models[-1], unpack=True)\\n\\n n_ages=7\\n n_zs=5\\n n_imfs=5\\n\\n \\n\\n\\n Zs=['m1.5', 'm1.0', 'm0.5', 'p0.0', 'p0.2']\\n ages=[1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.5]\\n model_imfs_order=['x35', 'x3', 'x23', 'kroupa', 'flat']\\n\\n t_mask = ((temp_lamdas > templates_lam_range[0]) & (temp_lamdas <templates_lam_range[1]))\\n\\n\\n\\n y=x35[t_mask]\\n x=temp_lamdas[t_mask]\\n\\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\\n interp=si.interp1d(x, y, fill_value='extrapolate')\\n out=interp(new_x)\\n\\n templates=np.empty((len(out), n_ages, n_zs, n_imfs))\\n\\n\\n\\n for a, Z in enumerate(Zs): \\n for b, age in enumerate(ages):\\n model=glob.glob(os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*{}*{}.ssp.s100'.format(Z, age)))[0]\\n if verbose:\\n print 'Loading {}'.format(model)\\n data=np.genfromtxt(model)\\n\\n for c, counter in enumerate(reversed(range(1, data.shape[-1]))):\\n \\n #Interpolate templates onto a uniform wavelength grid and then log-rebin\\n y=data[:, counter][t_mask] \\n x=temp_lamdas[t_mask]\\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\\n\\n interp=si.interp1d(x, y, fill_value='extrapolate')\\n out=interp(new_x) \\n\\n templates[:, b, a, c]=out\\n\\n return templates, new_x\",\n \"def kohonen():\\n# plb.close('all')\\n \\n dim = 28*28\\n data_range = 255.0\\n \\n # load in data and labels \\n data = np.array(np.loadtxt('data.txt'))\\n labels = np.loadtxt('labels.txt')\\n\\n # select 4 digits \\n name = \\\"Stettler\\\"\\n targetdigits = name2digits(name) # assign the four digits that should be used\\n print(targetdigits) # output the digits that were selected\\n\\n # this selects all data vectors that corresponds to one of the four digits\\n data = data[np.logical_or.reduce([labels==x for x in targetdigits]),:]\\n \\n dy, dx = data.shape\\n \\n #set the size of the Kohonen map. In this case it will be 6 X 6\\n size_k = 6\\n \\n #set the width of the neighborhood via the width of the gaussian that\\n #describes it\\n sigma = 2.0\\n \\n #initialise the centers randomly\\n centers = np.random.rand(size_k**2, dim) * data_range\\n \\n #build a neighborhood matrix\\n neighbor = np.arange(size_k**2).reshape((size_k, size_k))\\n\\n #set the learning rate\\n eta = 0.9 # HERE YOU HAVE TO SET YOUR OWN LEARNING RATE\\n \\n #set the maximal iteration count\\n tmax = 5000 # this might or might not work; use your own convergence criterion\\n \\n #set the random order in which the datapoints should be presented\\n i_random = np.arange(tmax) % dy\\n np.random.shuffle(i_random)\\n \\n for t, i in enumerate(i_random):\\n som_step(centers, data[i,:],neighbor,eta,sigma)\\n\\n # for visualization, you can use this:\\n for i in range(size_k**2):\\n plb.subplot(size_k,size_k,i)\\n \\n plb.imshow(np.reshape(centers[i,:], [28, 28]),interpolation='bilinear')\\n plb.axis('off')\\n \\n # leave the window open at the end of the loop\\n plb.show()\\n plb.draw()\",\n \"def olivine():\\n\\n rho = 3355.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 320.5; C[0,1] = 68.15; C[0,2] = 71.6; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 196.5; C[1,2] = 76.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 233.5; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 64.; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 77.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 78.7\\n\\n return C, rho\",\n \"def FO2(lam):\\n return 1.096 + 1.385 *1e-3 *lam**(-2) + 1.448 *1e-4 *lam**(-4)\",\n \"def seepage_from_superoperator(U):\\n if U.type=='oper':\\n sump = 0\\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n bra_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\\n qtp.ket([i_list[1]], dim=[3])).dag()\\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\\n qtp.ket([j_list[1]], dim=[3]))\\n p = np.abs((bra_i*U*ket_j).data[0, 0])**2\\n sump += p\\n sump /= 5 # divide by number of non-computational states\\n L1 = 1-sump\\n return L1\\n elif U.type=='super':\\n sump = 0\\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n ket_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\\n qtp.ket([i_list[1]], dim=[3]))\\n rho_i=qtp.operator_to_vector(qtp.ket2dm(ket_i))\\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\\n qtp.ket([j_list[1]], dim=[3]))\\n rho_j=qtp.operator_to_vector(qtp.ket2dm(ket_j))\\n p = (rho_i.dag()*U*rho_j).data[0, 0]\\n sump += p\\n sump /= 5 # divide by number of non-computational states\\n sump=np.real(sump)\\n L1 = 1-sump\\n return L1\",\n \"def solve_LF(self):\\n self.u = zeros(self.N)\\n self.u[0] = self.u0\\n self.u[1] = self.u1\\n u = self.u\\n f= self.f\\n dt = self.dt\\n t = self.t\\n N = self.N\\n for n in xrange(1,N-1):\\n u[n+1] = 2*dt*f(u[n],t[n]) + u[n-1]\\n #return t,u\",\n \"def punto2_1():\\r\\n\\tprint(\\\"2.1R/\\\")\\r\\n\\tn = 15\\r\\n\\tp = 0.2\\r\\n\\tseed = 12\\r\\n\\tvis = [False for i in range(n)]\\r\\n\\tG,graph=erdos_renyi_seed(n,p,seed)\\r\\n\\tnx.draw(graph,with_labels = True)\\r\\n\\tplt.show()\\t\\r\\n\\tm1 = tarjan(G)\\r\\n\\tnumCC = 0\\r\\n\\tfor u in range(n):\\r\\n\\t\\tif vis[u] == False:\\r\\n\\t\\t\\tnumCC+=1\\r\\n\\t\\t\\tdfsCC(G,vis,u)\\r\\n\\r\\n\\tavNumCC = n/numCC\\r\\n\\tnumAp,numB = m1[0],m1[1]\\r\\n\\tavnDeg = deg(G)\\r\\n\\tt = tripTrian(G)\\r\\n\\tnumTrian,numTrip = t[0],t[1]\\r\\n\\tprint(\\\"numero de componentes conectados: \\\" + str(numCC))\\r\\n\\tprint(\\\"tamaño promedio de componentes conectados: \\\" + str(avNumCC))\\r\\n\\tprint(\\\"numero de puntos de articulacion: \\\" + str(numAp))\\r\\n\\tprint(\\\"numero de puentes: \\\" + str(numB))\\r\\n\\tprint(\\\"Grado promedio por nodo: \\\" + str(avnDeg))\\r\\n\\tprint(\\\"numero de triangulos: \\\" + str(numTrian))\\r\\n\\tprint(\\\"numero de tripletas: \\\" + str(numTrip))\\r\\n\\treturn\",\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 test_lu_factor():\\n\\t#[A, b] = lu_read('test1.txt')\\n\\t# it is poor form to read an external file into a test function, as above\\n\\tA = np.array([\\n\\t\\t[ 2., 3., -4., 2.],\\n\\t\\t[-4., -5., 6., -3.],\\n\\t\\t[ 2., 2., 1., 0.],\\n\\t\\t[-6., -7., 14., -4.]])\\t\\n\\tLU,p = lu_factor(A, pivot=False)\\n\\tLU_soln = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\tassert norm(LU - LU_soln) < 1.e-10\\t\\n\\n\\n\\t# test 2\\n\\t[A2, b2] = lu_read('test2.txt')\\t\\t\\t\\t\\t\\t# read a matrix and RHS vector\\n\\tLU2,p2 = lu_factor(A2) \\t\\t\\t\\t\\t\\t\\t\\t# change display to False when LU_FACTOR working\\n\\tLU_soln2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\tassert norm(LU2 - LU_soln2) < 1.e-10\",\n \"def bcL(self, rng=None):\\n if rng is None:\\n rng = random.PRNGKey(1)\\n n = self.n\\n x = onp.sin(self.bcmesh * np.pi)\\n n_y = (np.floor((n + 1) / 2) - 1).astype(int)\\n if rng is not None:\\n coeffs = random.multivariate_normal(rng, np.zeros(16),\\n np.diag(np.ones(16)))\\n else:\\n key = random.randint(random.PRNGKey(1), (1,), 1, 1000)\\n coeffs = random.multivariate_normal(\\n random.PRNGKey(key[0]), np.zeros(16), np.diag(np.ones(16)))\\n left = coeffs[0] * x**3 + coeffs[1] * x**2 + coeffs[2] * x #+ coeffs[3]\\n right = coeffs[4] * x**3 + coeffs[5] * x**2 + coeffs[6] * x #+ coeffs[7]\\n lower = coeffs[8] * x**3 + coeffs[9] * x**2 + coeffs[10] * x #+ coeffs[11]\\n upper = coeffs[12] * x**3 + coeffs[13] * x**2 + coeffs[14] * x #+ coeffs[15]\\n shape = 2 * x.shape\\n source = onp.zeros(shape)\\n source[0, :] = upper\\n source[n_y - 1, n_y - 1:] = lower[:n - n_y + 1]\\n source[n_y - 1:, n_y - 1] = right[:n - n_y + 1]\\n source[:, 0] = left\\n source[-1, :n_y - 1] = right[n:n - n_y:-1]\\n source[:n_y - 1, -1] = lower[n:n - n_y:-1]\\n # because this makes the correct order of boundary conditions\\n return source * (n + 1)**2\",\n \"def optimize_fore(self):\\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\\n \\n self.l2 = torch.from_numpy(self.u).float()\\n print('self u shape',self.l2.shape)\\n self.n = torch.randn(32, 1, 28, 28)\\n self.l1 = self.enc(self.input + self.n)\\n self.del1=self.dec(self.l1)\\n self.del2=self.dec(self.l2)\\n self.update_netc()\\n self.update_netd()\\n\\n self.update_l2()\\n self.update_netg()\\n print('sssssssssssssssssssssss')\",\n \"def second_class_tp(p,n):\\n c = np.zeros(n)\\n d = np.zeros(p)\\n ucon = np.zeros(n)\\n lcon = np.zeros(n)\\n \\n #uvar = np.ones(n)*1\\n uvar = np.ones(n)*5\\n lvar = np.ones(n)*0.5\\n name = str(p)+'_'+str(n)+'_'+str(n)+'_l1_tp'+'.txt'\\n #name = str(n)+'_'+str(p)+'_'+'_second_tp'+'.txt'\\n Q = rog.hilb(p,n)\\n # d=(di), di=sum qij for i= 1,...,p\\n for i in range(p): \\n d[i]= Q[i,:].sum()\\n B = np.zeros((n,n))\\n return Q,B,d,c,lcon,ucon,lvar,uvar,name\",\n \"def offspring_fertility(n1=4,n2=4):\\n ary = np.zeros( (n1,n2, n1,n2, 3), float )\\n for i in range(n1):\\n for j in range(n2):\\n for k in range(n1):\\n for l in range(n2):\\n # set group counter to zero (one counter is sufficient)\\n gc1 = 0\\n for index in [i,j,k,l]: \\n if index in [0,1]: gc1+=1\\n if gc1==0 or gc1==4:\\n ary[i,j,k,l,0] = 1. # set mark at S0\\n elif gc1==1 or gc1==3:\\n ary[i,j,k,l,2] = 1. # set mark at S2\\n else:\\n ary[i,j,k,l,1] = 1. # set mark at S1\\n return ary\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def lam2E(l):\\n E=12398.4/(l*u['ang'])\\n return E\",\n \"def comprehensiveLOOEvaluation(directory=defaultDirectory(), \\n pruneGlobal = True, numLayers = 2, \\n numNodesPerLayer = 200, randSeed = 1,\\n trainPer = .6, valPer = .25, testPer = 0.15,\\n totalPer = 1, batchSize = 64,\\n numEpochs = 1000, learningRate = 0.001, \\n l2Reg = 0.0001, modelFilePrefix = '',\\n useGRU = False,\\n dropoutI = 0.2, dropoutH = 0.2, trainMode = 'continue',\\n randSeed2 = None, center = False, prependMean = False):\\n \\n trainModes = ['continue', 'overwrite', 'continue-each']\\n \\n if trainMode.lower() not in trainModes:\\n raise ValueError(\\\"Parameter 'trainMode' must be either 'continue', 'overwrite', or 'continue-each'.\\\")\\n \\n np.random.seed(randSeed) #control permutation of data\\n # prune global coordinate data?\\n if pruneGlobal:\\n pruneRange = range(0, 18)\\n else:\\n pruneRange = None\\n structs = loadDataset(directory=directory, LOUO=True, \\n delRange=pruneRange, trainPer=trainPer,\\n valPer = valPer, testPer=testPer, totalPer=totalPer,\\n preExt = '.left', prune=True)\\n\\n u=0\\n losses = []\\n accs = []\\n balAccs = []\\n finAccs = []\\n cmEpochs = []\\n outDirectory = nameModelFile('', useGRU, numLayers, numNodesPerLayer, randSeed,\\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\\n center, prependMean)\\n if not os.path.isdir(outDirectory):\\n os.mkdir(outDirectory)\\n if randSeed2 is not None: #control randomization of training (for Keras at least)\\n np.random.seed(randSeed2)\\n for struct in structs:\\n modelFile = modelFilePrefix + 'LOU-' + str(u)\\n modelFile = nameModelFile(modelFile, useGRU, numLayers, numNodesPerLayer, randSeed,\\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\\n center, prependMean)\\n u += 1\\n if (os.path.isfile(outDirectory + '\\\\\\\\' + 'Keras' + modelFile + '.json') \\n and os.path.isfile(outDirectory + '\\\\\\\\' + 'Keras' + modelFile + '_Weights.h5')):\\n #if we have already trained for leaving out this user\\n if trainMode == 'continue': #continue until each user has a model\\n trainMode2 = 'skip' \\n elif trainMode == 'continue-each': # continue training previous models\\n trainMode2 = 'continue'\\n else:\\n trainMode2 = 'overwrite'\\n else:\\n trainMode2 = trainMode\\n\\n if center:\\n \\\"\\\"\\\"\\n Center the labeled markers on their mean. \\n \\\"\\\"\\\"\\n from Postures import centerData\\n struct = list(struct)\\n labeledMarkerData = struct[0][:,:,18:].reshape((-1, 11, 3))\\n labeledMarkerData = centerData(labeledMarkerData, True, prependMean).reshape((struct[0].shape[0], struct[0].shape[1], -1))\\n struct[0] = np.concatenate([struct[0][:,:,0:18], labeledMarkerData], axis = 2)\\n if prependMean:\\n struct[8] += 3\\n\\n\\n cmEpoch, loss, acc, balAcc, finAcc = trainGestureRNN(numLayers=numLayers, numNodesPerLayer=numNodesPerLayer,\\n useGRU=useGRU, batchSize=batchSize, \\n numEpochs = numEpochs, learningRate=learningRate,\\n l1Reg=0, l2Reg = l2Reg, dropoutI=dropoutI, dropoutH=dropoutH,\\n sequences = struct[0], classes = struct[1],\\n trainRange = struct[2], valRange = struct[3],\\n testRange = struct[4], numClasses = struct[5],\\n numObservations = struct[6], numSequences = struct[7],\\n numFeatures = struct[8],\\n modelFile=modelFile, \\n outDirectory=outDirectory, trainMode=trainMode2,\\n callbacks = [EarlyStopping(patience=20)])\\n #catch our breath.... Really, give the user a chance to insert Ctrl-C\\n time.sleep(2)\\n losses += [loss]\\n accs += [acc]\\n balAccs += [balAcc]\\n finAccs += [finAcc]\\n cmEpochs += [cmEpoch]\\n losses = np.asarray(losses)\\n accs = np.asarray(accs)*100\\n balAccs = np.asarray(balAccs)*100\\n finAccs = np.asarray(finAccs)*100\\n trainPer, valPer, _, _ = normalizePercentages(trainPer, valPer, 0, 1)\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Leave One User Out Evaluation\\\\nTest Results for ' + str(numLayers) + '-Layer, ' \\n + str(numNodesPerLayer) + ' Nodes-Per-Layer ' + ('GRU' if useGRU else 'LSTM') + ' Networks\\\\n'\\n + 'Trained with ' + (\\\"%0.2f\\\" % (dropoutI*100)) + '% Input Dropout, '\\n + (\\\"%0.2f\\\" % (dropoutH*100)) + '% Hidden Dropout, and ' + str(l2Reg) + ' L2 Regularization\\\\n'\\n + str(numEpochs) + ' Maximum Epochs at ' + (\\\"%0.2f\\\" % trainPer) + '/' + (\\\"%0.2f\\\" % valPer) + ' Training/Validation Split\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Loss: ' + str(np.mean(losses)) + ' +/- ' + str(np.std(losses)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Loss: ' + str(np.percentile(losses, 25))\\n + ', ' + str(np.median(losses)) \\n + ', ' + str(np.percentile(losses, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Accuracy: ' + str(np.mean(accs)) + ' +/- ' + str(np.std(accs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Accuracy: ' + str(np.percentile(accs, 25))\\n + ', ' + str(np.median(accs)) \\n + ', ' + str(np.percentile(accs, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Balanced Accuracy: ' + str(np.mean(balAccs)) + ' +/- ' + str(np.std(balAccs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Balanced Accuracy: ' + str(np.percentile(balAccs, 25))\\n + ', ' + str(np.median(balAccs))\\n + ', ' + str(np.percentile(balAccs, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Final-Frame Accuracy: ' + str(np.mean(finAccs)) + ' +/- ' + str(np.std(finAccs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Final-Frame Accuracy: ' + str(np.percentile(finAccs, 25))\\n + ', ' + str(np.median(finAccs))\\n + ', ' + str(np.percentile(finAccs, 75)) +'\\\\n')\",\n \"def compute_cost(n: int,\\n lam: float,\\n dE: float,\\n L: int,\\n Lxi: int,\\n chi: int,\\n beta: int,\\n stps: int,\\n verbose: bool = False) -> Tuple[int, int, int]:\\n\\n # The number of bits used for the second register.\\n nxi = np.ceil(np.log2(n // 2))\\n\\n # The number of bits for the contiguous register.\\n nLxi = np.ceil(np.log2(Lxi + n // 2))\\n\\n # The number of bits used for the first register.\\n nL = np.ceil(np.log2(L + 1))\\n\\n # The power of 2 that is a factor of L + 1\\n eta = power_two(L + 1)\\n\\n oh = [0] * 20\\n for p in range(20):\\n # JJG note: arccos arg may be > 1\\n v = np.round(np.power(2,p+1) / (2 * np.pi) * arccos(np.power(2,nL) /\\\\\\n np.sqrt((L + 1)/2**eta)/2))\\n oh[p] = np.real(stps * (1 / (np.sin(3 * arcsin(np.cos(v * 2 * np.pi / \\\\\\n np.power(2,p+1)) * \\\\\\n np.sqrt((L + 1)/2**eta) / np.power(2,nL)))**2) - 1) + 4 * (p + 1))\\n\\n # Bits of precision for rotation\\n br = int(np.argmin(oh) + 1)\\n\\n # The following costs are from the list starting on page 50.\\n\\n # The cost for preparing an equal superposition for preparing the first\\n # register in step 1 (a). We double this cost to account for the inverse.\\n cost1a = 2 * (3 * nL + 2 * br - 3 * eta - 9)\\n\\n # The output size for the QROM for the first state preparation in Eq. (C27)\\n bp1 = nL + chi\\n\\n # The cost of the QROM for the first state preparation in step 1 (b) and\\n # its inverse.\\n cost1b = QR(L + 1, bp1)[1] + QI(L + 1)[1]\\n\\n # The cost for the inequality test, controlled swap and their inverse in\\n # steps 1 (c) and (d)\\n cost1cd = 2 * (chi + nL)\\n\\n # The total cost for preparing the first register in step 1.\\n cost1 = cost1a + cost1b + cost1cd\\n\\n # The output size for the QROM for the data to prepare the equal\\n # superposition on the second register, as given in Eq. (C29).\\n bo = nxi + nLxi + br + 1\\n\\n # This is step 2. This is the cost of outputting the data to prepare the\\n # equal superposition on the second register. We will assume it is not\\n # uncomputed, because we want to keep the offset for applying the QROM for\\n # outputting the rotations.\\n cost2 = QR(L + 1, bo)[1] + QI(L + 1)[1]\\n\\n # The number of bits for rotating the ancilla for the second preparation.\\n # We are just entering this manually because it is a typical value.\\n br = 7\\n\\n # The cost of preparing an equal superposition over the second register in\\n # a controlled way. We pay this cost 4 times.\\n cost3a = 4 * (7 * nxi + 2 * br - 6)\\n\\n # The cost of the offset to apply the QROM for state preparation on the\\n # second register.\\n cost3b = 4 * (nLxi - 1)\\n\\n bp2 = nxi + chi + 2\\n\\n # The cost of the QROMs and inverse QROMs for the state preparation, where\\n # in the first one we need + n/2 to account for the one-electron terms.\\n cost3c = QR(Lxi + n // 2, bp2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, bp2)[1] + QI(Lxi)[1]\\n\\n # The inequality test and state preparations.\\n cost3d = 4 * (nxi + chi)\\n\\n # The total costs for state preparations on register 2.\\n cost3 = cost3a + cost3b + cost3c + cost3d\\n\\n # The cost of adding offsets in steps 4 (a) and (h).\\n cost4ah = 4 * (nLxi - 1)\\n\\n # The costs of the QROMs and their inverses in steps 4 (b) and (g).\\n cost4bg = QR(Lxi + n // 2, n * beta // 2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, n * beta // 2)[1] + QI(Lxi)[1]\\n\\n # The cost of the controlled swaps based on the spin qubit in steps 4c and f\\n cost4cf = 2 * n\\n\\n # The controlled rotations in steps 4 (d) and (f).\\n cost4df = 4 * n * (beta - 2)\\n\\n # The controlled Z operations in the middle for step 4 (e).\\n cost4e = 3\\n\\n # This is the cost of the controlled rotations for step 4.\\n cost4 = cost4ah + cost4bg + cost4cf + cost4df + cost4e\\n\\n # This is the cost of the reflection on the second register from step 6.\\n cost6 = nxi + chi + 2\\n\\n # The cost of the final reflection req'd to construct the step of the\\n # quantum walk from step 9.\\n cost9 = nL + nxi + chi + 1\\n\\n # The extra two qubits for unary iteration and making the rflxn controlled.\\n cost10 = 2\\n\\n # The Toffoli cost for a single step\\n cost = cost1 + cost2 + cost3 + cost4 + cost6 + cost9 + cost10\\n\\n # The number of steps needed\\n iters = np.ceil(np.pi * lam / (2 * dE))\\n\\n # Now the number of qubits from the list on page 54.\\n\\n k1 = np.power(2, QR(Lxi + n // 2, n * beta // 2)[0])\\n\\n # The control register for phase estimation and iteration on it.\\n ac1 = np.ceil(np.log2(iters + 1)) * 2 - 1\\n\\n # The system qubits\\n ac2 = n\\n\\n # The first register prepared, a rotated qubit and a flag qubit.\\n ac3 = nL + 2\\n\\n # The output of the QROM, the equal superposition state and a flag qubit.\\n ac4 = nL + chi * 2 + 1\\n\\n # The data used for preparing the equal superposition state on the 2nd reg\\n ac5 = bo\\n\\n # The second register, a rotated qubit and a flag qubit.\\n ac6 = nxi + 2\\n\\n # The second preparation QROM output.\\n ac8 = bp2\\n\\n # The equal superposition state and the result of the inequality test.\\n ac9 = chi + 1\\n\\n # The angles for rotations.\\n ac10 = k1 * n * beta // 2\\n\\n # The phase gradient state.\\n ac11 = beta\\n\\n # A control qubit for the spin.\\n ac12 = 1\\n\\n # A T state.\\n ac13 = 1\\n\\n if verbose:\\n print(\\\"[*] Top of routine\\\")\\n print(\\\" [+] nxi = \\\", nxi)\\n print(\\\" [+] nLxi = \\\", nLxi)\\n print(\\\" [+] nL = \\\", nL)\\n print(\\\" [+] eta = \\\", eta)\\n print(\\\" [+] cost3 = \\\", cost3)\\n print(\\\" [+] cost4 = \\\", cost4)\\n print(\\\" [+] cost = \\\", cost)\\n print(\\\" [+] iters = \\\", iters)\\n\\n ancilla_cost = ac1 + ac2 + ac3 + ac4 + ac5 + ac6 + ac8 + ac9 + ac10 + ac11\\\\\\n + ac12 + ac13\\n\\n # Sanity checks before returning as int\\n assert cost.is_integer()\\n assert iters.is_integer()\\n assert ancilla_cost.is_integer()\\n\\n step_cost = int(cost)\\n total_cost = int(cost * iters)\\n ancilla_cost = int(ancilla_cost)\\n\\n return step_cost, total_cost, ancilla_cost\",\n \"def levin(x):\\n summ = 0\\n for t, l in x: # for the time and length of each algorithm\\n summ += l + np.log(t)\\n return summ\",\n \"def get_hbls_hbbl(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 u = self.u\\n v = self.v\\n \\n v_upts = TTTW_func.v2u(v)\\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\\n\\n\\n\\n # CALCULATE swr_frac\\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\\n\\n\\n # WHOLE THING HAPPENS IN j loop through y-indices\\n \\n # INITIALIZE ARRAYS\\n self.kmo = np.zeros([Ly])\\n self.Cr = np.zeros([Ly])\\n self.kbl = np.empty([Ly],dtype='int')\\n self.C_h_MO = np.zeros([Ly])\\n self.Cr = np.zeros([Ly,N+1]) # sum term\\n self.FC = np.zeros([Ly,N+1])\\n self.swdk_r = np.zeros([Ly,N+1])\\n \\n self.zscale = np.zeros([Ly,N])\\n self.Kern = np.zeros([Ly,N])\\n\\n \\n # --> LOOP THROUGH Y-INDICES\\n for j in range(Ly):\\n if self.LIMIT_MO_DEPTH:\\n self.kmo[j] = 0\\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\\n \\n self.kbl[j] = 0\\n self.Cr[j,-1] = 0 # set top Cr\\n self.Cr[j,0] = 0 # set bottom Cr\\n \\n # SEARCH FOR MIXED LAYER DEPTH\\n self.FC[j,-1] = 0.\\n\\n\\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\\n for k in range(N-1,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n \\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n self.zscale[j,k_w] = zscale\\n if self.LMD_KPP:\\n if self.LMD_BKPP:\\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\\n else:\\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\\n else:\\n Kern = 1.\\n \\n\\n\\n self.Kern[j,k_w] = Kern\\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\\\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\\\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\\n\\n\\n #\\t\\tLOOP THAT FINDS BL DEPTH ##\\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \\n \\n if self.LMD_KPP:\\n #swdk_r only used in this function so don't need to be class attribute\\n # but for testing make it an attribute to see what it is\\n \\n # fortran equivlanet ===> k=N,1,-1 \\n for k in range(N,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n ###################################################################### \\n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\\n \\n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\\n \\n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\\n \\t\\t\\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\\n \\n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\\n \\n\\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\\n \\n\\n #######################################################################\\n \\n # SEARCH FOR hbls vertical level #\\n '''\\n kbl is specified at vertical w-level (via Cr which is at\\n vertical w-levels)\\n '''\\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\\n self.kbl[j] = k_w\\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\\n self.kmo[j] = k_w\\n\\n \\n #--> still in j-loop\\n #######################################################\\n \\n # \\t\\tGET SURFACE BOUNDARY LAYER DEPTH # \\n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\\n if self.kbl[j] > 0:\\n k_w = self.kbl[j]\\n k_r = k_w - 1 \\n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\\n \\n else:\\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\\\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\\n \\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] > 0:\\n k_w = self.kmo[j]\\n k_r = k_w-1\\n if k_w == N:\\n z_up = z_u_w[j,N]\\n cff_up = np.max([0,Bo[j]])\\n else:\\n z_up = z_r[j,k_w+1]\\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\\n \\n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \\n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\\\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\\\\n + self.C_h_MO[j] * (cff_dn - cff_up)\\n\\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\\n\\n\\n\\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\\n if self.LMD_BKPP:\\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\\n self.Cr[j,0] = 0.\\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\\n \\n #---> LOOP BOTTOM TO TOP\\n # FIND kbl for BBL\\n for k in range(1,N+1):\\n k_r = k-1\\n k_w = k \\n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\\n \\n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\\n self.kbl[j] = k_w \\n \\n\\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\\n if self.kbl[j] > 0 :\\n k_w = self.kbl[j] \\n k_r = k_w -1\\n if k_w == 1: # NO BBL CASE\\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\\n else:\\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\\\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]\",\n \"def relative_l2_error(u, U):\\n return l2(u - U) / l2(u)\",\n \"def classify_lenet5(batch_size=500, output_size=20):\\n\\n rng = numpy.random.RandomState(23455)\\n\\n\\n # start-snippet-1\\n x = T.matrix('x') # the data is presented as rasterized images\\n ######################\\n # BUILD ACTUAL MODEL #\\n ######################\\n print '... building the model'\\n\\n # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)\\n # to a 4D tensor, compatible with our LeNetConvPoolLayer\\n # (28, 28) is the size of MNIST images.\\n layer0_input = x.reshape((batch_size, 1, 37, 23))\\n\\n # Construct the first convolutional pooling layer:\\n # filtering reduces the image size to (28-5+1 , 28-5+1) = (24, 24)\\n # maxpooling reduces this further to (24/2, 24/2) = (12, 12)\\n # 4D output tensor is thus of shape (batch_size, nkerns[0], 12, 12)\\n layer0 = LeNetConvPoolLayer(\\n rng,\\n input=layer0_input,\\n image_shape=(batch_size, 1, 37, 23),\\n filter_shape=(20, 1, 4, 2),\\n poolsize=(2, 2),\\n )\\n\\n # layer1 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer0.output,\\n # image_shape=(batch_size, 20, 17, 11),\\n # filter_shape=(50, 20, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n #\\n # layer4 = LeNetConvPoolLayer(\\n # rng,\\n # input=layer1.output,\\n # image_shape=(batch_size, 50, 7, 5),\\n # filter_shape=(100, 50, 4, 2),\\n # poolsize=(2, 2),\\n # )\\n\\n layer2_input = layer0.output.flatten(2)\\n\\n # construct a fully-connected sigmoidal layer\\n layer2 = HiddenLayer(\\n rng,\\n input=layer2_input,\\n n_in=3740,\\n n_out=output_size,\\n activation=T.tanh,\\n use_bias=True\\n )\\n\\n # layer5 = HiddenLayer(\\n # rng,\\n # input=layer2.output,\\n # n_in=200,\\n # n_out=output_size,\\n # activation=T.tanh,\\n # use_bias=True\\n # )\\n\\n # classify the values of the fully-connected sigmoidal layer\\n layer3 = LogisticRegression(input=layer2.output, n_in=output_size, n_out=2)\\n\\n model_params = pickle.load(open('../model/cnn_dist_'+str(output_size)+'.pkl'))\\n #\\n layer0.W = theano.shared(\\n value=numpy.array(\\n model_params[2].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer0.b = theano.shared(\\n value=numpy.array(\\n model_params[3].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer1.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-4].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer1.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-3].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n #\\n # layer4.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-6].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer4.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-5].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer2.W = theano.shared(\\n value=numpy.array(\\n model_params[0].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer2.b = theano.shared(\\n value=numpy.array(\\n model_params[1].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # layer5.W = theano.shared(\\n # value=numpy.array(\\n # model_params[-10].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='W',\\n # borrow=True\\n # )\\n #\\n # layer5.b = theano.shared(\\n # value=numpy.array(\\n # model_params[-9].get_value(True),\\n # dtype=theano.config.floatX\\n # ),\\n # name='b',\\n # borrow=True\\n # )\\n\\n layer3.W = theano.shared(\\n value=numpy.array(\\n model_params[4].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='W',\\n borrow=True\\n )\\n\\n layer3.b = theano.shared(\\n value=numpy.array(\\n model_params[5].get_value(True),\\n dtype=theano.config.floatX\\n ),\\n name='b',\\n borrow=True\\n )\\n\\n # params = layer3.params + layer5.params + layer2.params + layer4.params + layer1.params + layer0.params\\n\\n datasets = load_data(None)\\n\\n sets = ['train', 'dev', 'test']\\n dimension = [20000, 20000, 20000]\\n for k in range(3):\\n if k == 0:\\n classify_set_x, classify_set_y, classify_set_z, classify_set_m, classify_set_c, classify_set_b= datasets[k]\\n else:\\n classify_set_x, classify_set_y, classify_set_z= datasets[k]\\n\\n # compute number of minibatches for training, validation and testing\\n n_classify_batches = classify_set_x.get_value(borrow=True).shape[0]\\n n_classify_batches /= batch_size\\n\\n # allocate symbolic variables for the data\\n index = T.lscalar() # index to a [mini]batch\\n classify = theano.function(\\n [index],\\n layer2.output,\\n givens={\\n x: classify_set_x[index * batch_size: (index + 1) * batch_size],\\n }\\n )\\n\\n r = []\\n\\n for i in xrange(n_classify_batches):\\n m = classify(i)\\n r.extend(m)\\n r = np.array(r)\\n print r.shape\\n r = np.append(r, np.reshape(classify_set_y.eval(),(dimension[k], 1)), 1)\\n numpy.savetxt('../extractedInformation/cnn_dist_'+str(output_size)+'/'+sets[k]+'.csv', r, delimiter=\\\",\\\")\",\n \"def coarse_to_fine(im1, im2, pyramid1, pyramid2, n_iter=3):\\n assert im1.shape == im2.shape\\n \\n u = np.zeros_like(im1)\\n v = np.zeros_like(im1)\\n\\n #\\n # Your code here\\n #\\n\\n # Code inspired by:\\n # https://www.youtube.com/watch?v=FhlbUHhNpD4\\n\\n # descending indices of the gaussian pyramid \\n # (from small to big image)\\n K = len(pyramid1)\\n levels = np.arange(K - 1, -1, -1) # [K - 1, K - 2, ..., 0]\\n\\n #######################\\n # intial estimation #\\n #######################\\n\\n ##################################################\\n # print('Level [{}]'.format(K - 1))\\n\\n # get coarsest images from the gaussian pyramid\\n # at level (k - 1)\\n im1_k = pyramid1[-1].copy()\\n im2_k = pyramid2[-1].copy()\\n\\n # iterative LK-Algorithm (refine the motion)\\n uk, vk = iter_LK(im1_k, im2_k, n_iter)\\n\\n # expand image to new resolution\\n uk_exp = expand(uk) * 2\\n vk_exp = expand(vk) * 2\\n ###################################################\\n\\n\\n ##############################\\n # coarse to fine iteritons #\\n ##############################\\n\\n # iterate over [ K-2, K-3, ..., 0 ] -> all scales except the smallest\\n for k in levels[1:]: \\n # print('Level [{}]'.format(k))\\n\\n # get images of current scale from the pyramid\\n im1_k = pyramid1[k]\\n im2_k = pyramid2[k]\\n\\n # warp im1 image from pyramid1\\n im1_k_warp = warp(im1_k, uk_exp, vk_exp)\\n\\n # apply LK for iterative refinement on current resolution\\n uk, vk = iter_LK(im1_k_warp, im2_k, n_iter)\\n\\n # add current motion fields (uk, vk) from iter_LK to \\n # previous expanded motion fields (uk_exp, vk_exp)\\n uk = uk + uk_exp\\n vk = vk + vk_exp\\n\\n # expand the motion fields (uk, vk) to the next higher\\n # scale in the gaussian pyramid (to use in next iteration)\\n if k > 0: # all other level\\n uk_exp = expand(uk) * 2\\n vk_exp = expand(vk) * 2\\n else: # last level 0 (no expansion needed -> original scale)\\n uk_exp = uk\\n vk_exp = vk\\n\\n # print('[', k, ']: uk_exp = ', uk_exp.shape, ' | vk_exp = ', vk_exp.shape)\\n\\n # print('[FINAL]: u = ', uk_exp.shape, ' | v = ', vk_exp.shape)\\n\\n # set the final parameter \\n # (LK at original resolution)\\n u = uk_exp\\n v = vk_exp\\n\\n assert u.shape == im1.shape and \\\\\\n v.shape == im1.shape\\n return u, v\",\n \"def _apply_array_spin12_lowfilling_python(self, h1e: 'Nparray',\\n h2e: 'Nparray') -> 'Nparray':\\n out = self._apply_array_spin1(h1e)\\n\\n norb = self.norb()\\n nalpha = self.nalpha()\\n nbeta = self.nbeta()\\n lena = self.lena()\\n lenb = self.lenb()\\n nlt = norb * (norb + 1) // 2\\n\\n h2ecompa = numpy.zeros((nlt, nlt), dtype=self._dtype)\\n h2ecompb = numpy.zeros((nlt, nlt), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for k in range(norb):\\n for l in range(k + 1, norb):\\n kln = k + l * (l + 1) // 2\\n h2ecompa[ijn, kln] = (h2e[i, j, k, l] -\\n h2e[i, j, l, k] -\\n h2e[j, i, k, l] + h2e[j, i, l, k])\\n ino = i + norb\\n jno = j + norb\\n kno = k + norb\\n lno = l + norb\\n h2ecompb[ijn, kln] = (h2e[ino, jno, kno, lno] -\\n h2e[ino, jno, lno, kno] -\\n h2e[jno, ino, kno, lno] +\\n h2e[jno, ino, lno, kno])\\n\\n if nalpha - 2 >= 0:\\n alpha_map, _ = self._core.find_mapping(-2, 0)\\n intermediate = numpy.zeros(\\n (nlt, int(binom(norb, nalpha - 2)), lenb), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n work = self.coeff[source, :] * parity\\n intermediate[ijn, target, :] += work\\n\\n intermediate = numpy.tensordot(h2ecompa, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n out[source, :] -= intermediate[ijn, target, :] * parity\\n\\n if self.nalpha() - 1 >= 0 and self.nbeta() - 1 >= 0:\\n alpha_map, beta_map = self._core.find_mapping(-1, -1)\\n intermediate = numpy.zeros((norb, norb, int(binom(\\n norb, nalpha - 1)), int(binom(norb, nbeta - 1))),\\n dtype=self._dtype)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n sign = ((-1)**(nalpha - 1)) * paritya\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = self.coeff[sourcea, sourceb] * sign * parityb\\n intermediate[i, j, targeta, targetb] += 2 * work\\n\\n intermediate = numpy.tensordot(h2e[:norb, norb:, :norb, norb:],\\n intermediate,\\n axes=2)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n paritya *= (-1)**nalpha\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = intermediate[i, j, targeta, targetb]\\n out[sourcea, sourceb] += work * paritya * parityb\\n\\n if self.nbeta() - 2 >= 0:\\n _, beta_map = self._core.find_mapping(0, -2)\\n intermediate = numpy.zeros((nlt, lena, int(binom(norb, nbeta - 2))),\\n dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in beta_map[(i, j)]:\\n work = self.coeff[:, source] * parity\\n intermediate[ijn, :, target] += work\\n\\n intermediate = numpy.tensordot(h2ecompb, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, sign in beta_map[(min(i, j), max(i,\\n j))]:\\n out[:, source] -= intermediate[ijn, :, target] * sign\\n return out\",\n \"def cayley_menger_det_no_linalg(x2, y2, z2, xb2, yb2, zb2):\\n xs = x2 + xb2\\n ys = y2 + yb2\\n zs = z2 + zb2\\n buf1 = ys + zs\\n buf1 -= xs\\n buf2 = x2 * xb2\\n buf1 *= buf2 # buf1 has first term, halved\\n np.multiply(y2, yb2, out=buf2)\\n buf3 = xs + zs\\n buf3 -= ys\\n buf2 *= buf3 # buf2 has second term\\n buf1 += buf2 # buf1 is sum of two terms, halved\\n np.multiply(z2, zb2, out=buf3)\\n np.add(xs, ys, out=buf2) # reuse buf2\\n buf2 -= zs\\n buf3 *= buf2 # buf3 has third term\\n buf1 += buf3 # buf1 is sum of 3 first terms, halved\\n buf1 *= 2\\n np.subtract(x2, xb2, out=buf2)\\n np.subtract(y2, yb2, out=buf3)\\n buf2 *= buf3\\n np.subtract(z2, zb2, out=buf3)\\n buf2 *= buf3\\n buf1 += buf2 # buf1 is sum of 4 first terms\\n np.multiply(xs, ys, out=buf3)\\n buf3 *= zs\\n buf1 -= buf3\\n return buf1\",\n \"def hausdorffDistance(self,id1,id2):\\n #productive #math\\n profprint()\\n node1 = slicer.mrmlScene.GetNodeByID(id1)\\n polydata1=node1.GetPolyData()\\n node2 = slicer.mrmlScene.GetNodeByID(id2)\\n polydata2=node2.GetPolyData()\\n nb1 = polydata1.GetNumberOfPoints()\\n nb2 = polydata2.GetNumberOfPoints()\\n minimum=None\\n maximum=None\\n JJ,jj=None,None\\n II,ii=None,None\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n polydata1.GetPoint(1,pt1)\\n polydata1.GetPoint(nb1-1,pt2)\\n minVal1=min(pt1[2],pt2[2])\\n maxVal1=max(pt1[2],pt2[2])\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n pt1b,pt2b=None,None\\n polydata2.GetPoint(1,pt1)\\n polydata2.GetPoint(nb2-1,pt2)\\n minVal2 = min(pt1[2],pt2[2])\\n maxVal2 = max(pt1[2],pt2[2])\\n valueBase=max(minVal1,minVal2)\\n valueTip=min(maxVal1,maxVal2)\\n\\n # truncate polydatas\\n truncatedPolydata1 = self.clipPolyData(node1,valueBase)\\n truncatedPolydata2 = self.clipPolyData(node2,valueBase)\\n\\n cellId=vtk.mutable(1)\\n subid=vtk.mutable(1)\\n dist=vtk.mutable(1)\\n cl2=vtk.vtkCellLocator()\\n cl2.SetDataSet(truncatedPolydata2)\\n cl2.BuildLocator()\\n # Hausforff 1 -> 2\\n minima=[]\\n for i in range(int(nb1/float(10))):\\n pt=[0,0,0]\\n polydata1.GetPoint(10*i,pt)\\n closest=[0,0,0]\\n cl2.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff12 = max(minima)\\n \\n # Hausforff 2 -> 1\\n minima=[]\\n cl1=vtk.vtkCellLocator()\\n cl1.SetDataSet(truncatedPolydata1)\\n cl1.BuildLocator()\\n for i in range(int(nb2/float(10))):\\n pt=[0,0,0]\\n polydata2.GetPoint(10*i,pt)\\n closest=[0,0,0]\\n cl1.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff21 = max(minima)\\n return max(hausdorff12,hausdorff21)\",\n \"def LEIsotropic2D(self):\\n const = self.ymod / ((1+self.Nu) * (1-(2*self.Nu)))\\n a = const * self.Nu\\n b = const * (1-self.Nu)\\n c = const * 0.5 * (1-2*self.Nu)\\n Cmat = np.array(\\n [\\n [b, a, 0],\\n [a, b, 0],\\n [0, 0, c],\\n ], dtype=float)\\n stress_el = Cmat @ self.eps\\n return stress_el, Cmat\",\n \"def calc_lampam_2(ss):\\n if isinstance(ss, list):\\n lampam = np.zeros((len(ss), 12), float)\\n for index in range(len(ss)):\\n lampam[index] = calc_lampam_2(ss[index])\\n return lampam\\n if ss.ndim == 2 and ss.shape[0] > 1:\\n lampam = np.zeros((ss.shape[0], 12), float)\\n for index in range(ss.shape[0]):\\n lampam[index] = calc_lampam_2(ss[index])\\n return lampam\\n\\n n_plies_in_panels = np.size(ss) # laminate ply count\\n\\n theta2 = np.deg2rad(2*ss.astype(float))\\n theta4 = 2*theta2\\n cos_sin = np.concatenate((\\n np.cos(theta2),\\n np.cos(theta4),\\n np.sin(theta2),\\n np.sin(theta4))).reshape((4, n_plies_in_panels))\\n\\n for_the_top = np.arange(n_plies_in_panels)\\n z_0 = np.ones(n_plies_in_panels)\\n z_2 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**3 \\\\\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**3\\n z_1 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**2 \\\\\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**2\\n\\n return np.array([\\n (1/n_plies_in_panels)*np.matmul(cos_sin, z_0),\\n (2/n_plies_in_panels**2)*np.matmul(cos_sin, z_1),\\n (4/n_plies_in_panels**3)*np.matmul(cos_sin, z_2)]).reshape(12)\",\n \"def _coef(ctx, J, eps):\\n\\n newJ = J+2 # compute more coefficients that are needed\\n neweps6 = eps/2. # compute with a slight more precision that are needed\\n\\n # PREPARATION FOR THE COMPUTATION OF V(N) AND W(N)\\n # See II Section 3.16\\n #\\n # Computing the exponent wpvw of the error II equation (81)\\n wpvw = max(ctx.mag(10*(newJ+3)), 4*newJ+5-ctx.mag(neweps6))\\n\\n # Preparation of Euler numbers (we need until the 2*RS_NEWJ)\\n E = ctx._eulernum(2*newJ)\\n\\n # Now we have in the cache all the needed Euler numbers.\\n #\\n # Computing the powers of pi\\n #\\n # We need to compute the powers pi**n for 1<= n <= 2*J\\n # with relative error less than 2**(-wpvw)\\n # it is easy to show that this is obtained\\n # taking wppi as the least d with\\n # 2**d>40*J and 2**d> 4.24 *newJ + 2**wpvw\\n # In II Section 3.9 we need also that\\n # wppi > wptcoef[0], and that the powers\\n # here computed 0<= k <= 2*newJ are more\\n # than those needed there that are 2*L-2.\\n # so we need J >= L this will be checked\\n # before computing tcoef[]\\n wppi = max(ctx.mag(40*newJ), ctx.mag(newJ)+3 +wpvw)\\n ctx.prec = wppi\\n pipower = {}\\n pipower[0] = ctx.one\\n pipower[1] = ctx.pi\\n for n in range(2,2*newJ+1):\\n pipower[n] = pipower[n-1]*ctx.pi\\n\\n # COMPUTING THE COEFFICIENTS v(n) AND w(n)\\n # see II equation (61) and equations (81) and (82)\\n ctx.prec = wpvw+2\\n v={}\\n w={}\\n for n in range(0,newJ+1):\\n va = (-1)**n * ctx._eulernum(2*n)\\n va = ctx.mpf(va)/ctx.fac(2*n)\\n v[n]=va*pipower[2*n]\\n for n in range(0,2*newJ+1):\\n wa = ctx.one/ctx.fac(n)\\n wa=wa/(2**n)\\n w[n]=wa*pipower[n]\\n\\n # COMPUTATION OF THE CONVOLUTIONS RS_P1 AND RS_P2\\n # See II Section 3.16\\n ctx.prec = 15\\n wpp1a = 9 - ctx.mag(neweps6)\\n P1 = {}\\n for n in range(0,newJ+1):\\n ctx.prec = 15\\n wpp1 = max(ctx.mag(10*(n+4)),4*n+wpp1a)\\n ctx.prec = wpp1\\n sump = 0\\n for k in range(0,n+1):\\n sump += ((-1)**k) * v[k]*w[2*n-2*k]\\n P1[n]=((-1)**(n+1))*ctx.j*sump\\n P2={}\\n for n in range(0,newJ+1):\\n ctx.prec = 15\\n wpp2 = max(ctx.mag(10*(n+4)),4*n+wpp1a)\\n ctx.prec = wpp2\\n sump = 0\\n for k in range(0,n+1):\\n sump += (ctx.j**(n-k)) * v[k]*w[n-k]\\n P2[n]=sump\\n # COMPUTING THE COEFFICIENTS c[2n]\\n # See II Section 3.14\\n ctx.prec = 15\\n wpc0 = 5 - ctx.mag(neweps6)\\n wpc = max(6,4*newJ+wpc0)\\n ctx.prec = wpc\\n mu = ctx.sqrt(ctx.mpf('2'))/2\\n nu = ctx.expjpi(3./8)/2\\n c={}\\n for n in range(0,newJ):\\n ctx.prec = 15\\n wpc = max(6,4*n+wpc0)\\n ctx.prec = wpc\\n c[2*n] = mu*P1[n]+nu*P2[n]\\n for n in range(1,2*newJ,2):\\n c[n] = 0\\n return [newJ, neweps6, c, pipower]\",\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def l2(u: np.ndarray, v: np.ndarray) -> np.ndarray:\\n\\n return (u - v) ** 2\",\n \"def frame3dlin_Kg(E,A1,A2,L,Te1,Te2,R=None):\\n Kge1= np.array([\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , (A2*E)/(10*L) , 0 , -((A2+3*A1)*E)/30 , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0],\\n [0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+3*A1)*E)/30 , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , (A1*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0 , 0 , 0 , -(A1*E)/(10*L) , 0 , -((3*A2+A1)*E)/30 , 0],\\n [0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60 , 0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((3*A2+A1)*E)/30]\\n ])\\n Kge2= np.array([\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+3*A1)*E)/30 , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0],\\n [0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+3*A1)*E)/30 , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , -(A1*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0 , 0 , 0 , (A1*E)/(10*L) , 0 , ((3*A2+A1)*E)/30 , 0],\\n [0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60 , 0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((3*A2+A1)*E)/30]])\\n\\n Kg = Kge1*Te1 + Kge2*Te2\\n\\n if (R is not None):\\n RR = scipy.linalg.block_diag(R,R,R,R)\\n Kg = np.transpose(RR).dot(Kg.dot(RR))\\n\\n return Kg\",\n \"def OptimizeL(L,nepochs=10,rho=.5,noise=.05,npred=200,Href=None): \\n N = len(L) \\n HS = np.zeros((N,2,nepochs+1))\\n\\n Lp = []\\n error = []\\n\\n for i in range(N):\\n t = L[i]\\n h = EntropyKS(t)\\n dd0 = DegreeDist(t,npred,directed=True)\\n s = EntropyD(dd0)\\n Lp.append(t)\\n HS[i,:,0]=[h,s]\\n \\n if not Href is None:\\n error.append(MyKLD(Href,HS[:,:,0]))\\n\\n Changes = []\\n for epoch in range(nepochs):\\n Lp2 = []\\n changes = 0\\n for nn,t in enumerate(Lp):\\n h0 = HS[nn,0,epoch]\\n s0 = HS[nn,1,epoch]\\n\\n t1,h1,s1,change = Optimize(t,h0,s0,rho,noise,npred)\\n Lp2.append(t1)\\n HS[nn,:,epoch+1] = np.array([h1,s1])\\n changes+=change\\n Lp = Lp2\\n Changes.append(changes)\\n if not Href is None:\\n error.append(MyKLD(Href,HS[:,:,epoch+1]))\\n return(Lp,HS,np.array(Changes),np.array(error))\",\n \"def alternate_ls (u_num, Y, P, C, reg):\\n\\n\\t# get # of items/users and # of latent factors\\n\\t[i_num, f_num] = Y.shape\\n\\n\\t# output buffer\\n\\tX = np.zeros((u_num, f_num))\\n\\n\\t# precalculate YtY to improve the performance\\n\\tYtY = Y.T * Y\\n\\n\\t# iterate over each user/item\\n\\tfor u in range(u_num):\\n\\n\\t\\t# store the diagonal elements of the matrix Cu discussed in the paper in a vector\\n\\t\\tCu = C[u,:]\\n\\n\\t\\t# store the coresponding row/column of the preference matrix\\n\\t\\tPu = P[u,:]\\n\\n\\t\\t# compute Cu-I\\n\\t\\tCu_I = Cu - 1\\n\\n\\t\\t# calculate Yt(Cu-I)Y\\n\\t\\tYtCu_IY = np.zeros((f_num, f_num))\\n\\t\\tCuIY = np.multiply(Y, Cu_I.T) # weight each row of Y with Cu-I\\n\\t\\tfor row in range(f_num):\\n\\t\\t\\tfor col in range(f_num):\\n\\t\\t\\t\\tYtCu_IY[row,col] = Y[:,row].T * CuIY[:,col]\\n\\t\\t\\n\\t\\t# left term : ((YtCuY + regI)^(-1)) = (YtY + Yt(Cu-I)Y + regI)^(-1)\\n\\t\\tleft_inv = YtY + YtCu_IY + reg*np.eye(f_num)\\n\\t\\tleft = np.linalg.inv(left_inv)\\n\\n\\t\\t# right term : YtCuPu\\n\\t\\tright = Y.T * np.multiply(Cu.T, Pu.T)\\n\\n\\t\\t# compute the latent factor of the user/item\\n\\t\\tx = left * right\\n\\t\\t\\n\\t\\t# store it in a matrix\\n\\t\\tX[u,:] = x.T\\n\\n\\t# return an MxF or NxF matrix\\n\\treturn np.matrix(X)\",\n \"def recover_components( k, P, T, Pe, Te, delta=0.01 ):\\n d, _ = P.shape\\n\\n # Input error\\n logger.add_err( \\\"P\\\", Pe, P, 2 )\\n logger.add_consts( \\\"Pe\\\", Pe, k, 2 )\\n logger.add_consts( \\\"P\\\", P, k, 2 )\\n logger.add_terr( \\\"T\\\", Te, T, d )\\n logger.add_tconsts( \\\"Te\\\", Te, d )\\n logger.add_tconsts( \\\"T\\\", T, d )\\n\\n # Get the whitening matrix of M2\\n W, Wt = get_whitener( P, k )\\n We, _ = get_whitener( Pe, k )\\n\\n logger.add_err( \\\"W\\\", We, W, 2 )\\n logger.add_consts( \\\"We\\\", We, k, 2 )\\n logger.add_consts( \\\"W\\\", W, k, 2 )\\n\\n Tw = lambda theta: W.T.dot( T( W.dot( theta ) ) ).dot( W )\\n Twe = lambda theta: We.T.dot( Te( We.dot( theta ) ) ).dot( We )\\n #Tw = sc.einsum( 'ijk,ia,jb,kc->abc', T, W, W, W )\\n #Twe = sc.einsum( 'ijk,ia,jb,kc->abc', Te, We, We, We )\\n\\n logger.add_terr( \\\"Tw\\\", Twe, Tw, k )\\n\\n # Repeat [-\\\\log(\\\\delta] times for confidence 1-\\\\delta to find best\\n # \\\\theta\\n t = int( sc.ceil( -log( delta ) ) )\\n best = (-sc.inf, None, None)\\n for i in xrange( t ):\\n # Project Tw onto a matrix\\n theta = sc.rand( k )\\n theta = theta/theta.sum()\\n\\n # Find the eigen separation\\n X = Tw(theta)\\n #X = Tw.dot(theta)\\n sep = column_sep( X )\\n\\n if sep > best[0]:\\n best = sep, theta, X\\n \\n # Find the eigenvectors as well\\n sep, theta, X = best\\n S, U = eig( X, left=True, right=False )\\n assert( sc.isreal( S ).all() and sc.isreal( U ).all() )\\n S, U = S.real, U.real\\n\\n Xe = Twe( theta )\\n ##Xe = Twe.dot( theta )\\n sepe = column_sep( Xe )\\n Se, Ue = eig( Xe, left=True, right=False )\\n Se, Ue = Se.real, Ue.real\\n\\n logger.add( \\\"D\\\", sep/sepe )\\n logger.add_err( \\\"lambda\\\", Se, S, sc.inf )\\n logger.add_err( \\\"v\\\", Se, S, 'col' )\\n \\n M = sc.zeros( (d, k) )\\n for i in xrange(k):\\n M[:, i] = S[i]/theta.dot(U.T[i]) * Wt.dot(U.T[i]) \\n\\n return M\",\n \"def gelu(input):\\n return FunctionLib.apply('Gelu', input.device, [input], approximate=False)\",\n \"def Langmuir_Knudsen_mdot(D, T_p, Psat, Re, mu_g, cp_g, lambda_g, P_g, R_g, Sc_g, R_v, Yinf):\\n Pr_g = mu_g * cp_g / lambda_g # Gas Prandtl Number\\n Sh = 2.0 + 0.552 * math.sqrt(Re) * Sc_g ** (1.0/3.0) \\n Re_b = 0.0 #Blowing Reynolds number \\n Re_b0 = Re_b \\n Xseq = min(Psat / P_g, 1.0) #Molar mass fraction\\n theta2 = R_v / R_g ;\\n Yseq = min(Xseq /max(Xseq + (1.0 - Xseq) * theta2, 1e-30), 1.0) \\n yMin = min(Yseq, Yinf) \\n yMax = max(Yseq, Yinf) \\n\\n # Iterate to converge on Re_b\\n # This part could be optimized\\n Lk = computeLK(T_p,R_v,mu_g,Sc_g,P_g) \\n Re_b0 = estimate_re_b(yMin, yMax, Yinf, Sh, Sc_g)\\n \\n max_solver_iterations = 100\\n for i in range(max_solver_iterations): \\n Ysneq = computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b) \\n #Bound Ysneq so that it lies between Yseq and Yinf\\n Ysneq = max(yMin, min(yMax, Ysneq)) \\n BMneq = (Ysneq - Yinf) / max(1.0 - Ysneq, 1e-30) \\n Hm = math.log(max(1.0 + BMneq, 1e-40)) \\n Re_b0 = Re_b \\n Re_b = Hm * Sh / Sc_g \\n factor = min(0.8, 0.5 * D / Lk) #Damping factor\\n\\n if i >= max_solver_iterations:\\n print('Mdot Calculation failed to converge')\\n\\n if abs(Re_b - Re_b0) < 1.0e-6:\\n break \\n\\n #Relax update to help convergence\\n Re_b = factor * Re_b + (1.0 - factor) * Re_b0 \\n \\n #Chris debug\\n beta = 0.5 * Pr_g * Re_b ;\\n if i > -1: \\n format_string = 'i= {0:<4d} Re_b= {1:<8.4f} Ysneq= {2:<8.4f} Hm= {3:<8.4f} ' \\\\\\n 'BMneq= {4:<8.4f} Lk= {5:<8.4e} Lk/D= {6:<8.4e} factor= {7:<8.4e} beta= {8:<8.4f}'\\n print(format_string.format(i, Re_b, computeYsneq(Xseq,Lk,D,theta2,Pr_g,Re_b), Hm, BMneq, Lk, Lk/D, factor, beta))\\n \\n # Back out mdot from blowing reunolds number\\n mdot = -Re_b * D * mu_g * math.pi \\n return mdot\",\n \"def calc_ell_list(chain) :\\n ell_list = np.zeros(len(chain.bridges_dict))\\n \\n for b in chain.bridges_dict.keys() :\\n i, j = chain.bridges_dict[b].lumen1, chain.bridges_dict[b].lumen2\\n L_i, pos_i = chain.lumens_dict[i].length, chain.lumens_dict[i].pos\\n L_j, pos_j = chain.lumens_dict[j].length, chain.lumens_dict[j].pos\\n \\n chain.bridges_dict[b].length = np.abs(pos_j - pos_i) - (L_i + L_j)\",\n \"def _get_lt_problem(self,x,n_seg=[10,10], high_fidelity=True):\\n\\tfrom PyKEP import epoch, lambert_problem, DAY2SEC, fb_prop, propagate_lagrangian\\n\\tfrom PyGMO import population\\n\\tfrom math import pi, acos,cos,sin,sqrt, exp\\n\\tfrom scipy.linalg import norm\\n\\t\\n\\tretval = []\\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\\tn_legs = len(x)/4\\n\\tseq = self.get_sequence()\\n\\tcommon_mu = seq[0].mu_central_body\\n\\t#2 - We compute the epochs and ephemerides of the planetary encounters\\n\\tt_P = list([None] * (n_legs))\\n\\tr_P = list([None] * (n_legs))\\n\\tv_P = list([None] * (n_legs))\\n\\tDV = list([None] * (n_legs))\\n\\t\\n\\tfor i,planet in enumerate(seq):\\n\\t\\tt_P[i] = epoch(x[0]+sum(T[:i+1]))\\n\\t\\tr_P[i],v_P[i] = 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,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\\t\\n\\t#We start appending in the lt chromosome (see mga_incipit_lt)\\n\\tretval.append(theta)\\n\\tretval.append(phi)\\n\\t\\n\\t#First DSM occuring at the very beginning (will be cancelled by the optimizer)\\n\\tDV[0] = abs(norm(v_beg_l) - 3400)\\n\\t\\n\\t#Start of the first lt leg encoding \\n\\tretval.append(T[0])\\n\\tretval.append(exp(-DV[0]/9.80665/2000)*2000) #Tsiolkowsky\\n\\tretval.extend(v_beg_l)\\n\\tretval.extend([a-b for a,b in zip(v_end_l,v_P[0])])\\n\\n\\t#4 - And we proceed with each successive leg\\n\\tfor i in xrange(1,n_legs):\\n\\t\\t#Fly-by \\n\\t\\tv_out = fb_prop(v_end_l,v_P[i-1],x[1+4*i]*seq[i-1].radius,x[4*i],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,common_mu)\\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,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#DSM occuring at time nu2*T2\\n\\t\\tDV[i] = norm([a-b for a,b in zip(v_beg_l,v)])\\n\\t\\t\\n\\t\\t#lt encoding of all legs\\n\\t\\tretval.append(T[i])\\n\\t\\tretval.append(exp(-sum(DV[:i+1])/9.80665/2000)*2000) #Tsiolkowsky\\n\\t\\tretval.extend([a-b for a,b in zip(v_out,v_P[i-1])])\\n\\t\\tif i != n_legs-1:\\n\\t\\t\\tretval.extend([a-b for a,b in zip(v_end_l,v_P[i])])\\n\\t\\n\\tretval = retval + [0]*sum(n_seg)*3\\n\\tprob = mga_incipit_lt(high_fidelity=high_fidelity,seq=seq, n_seg = n_seg,tf = epoch(x[0]+sum(T)), vf = [a-b for a,b in zip(v_end_l,v_P[i])])\\n\\t# solves the problem of chemical trajectories wanting higher launch dv\\n\\tub = list(prob.ub)\\n\\tlb = list(prob.lb)\\n\\tub[4:7] = [5000,5000,5000]\\n\\tlb[4:7] = [-5000,-5000,-5000]\\n\\tprob.set_bounds(lb, ub)\\n\\tpop = population(prob)\\n\\tpop.push_back(retval)\\n\\treturn (prob,pop)\",\n \"def probability(N_dr, L_opmin, L_opmax, L_min, L_max, L_d):\\n opening_nomullignas = []\\n opening_withmullignas = []\\n sum_nomulligans = 0\\n sum_withmulligans = 0\\n mulligan_coeff = 0\\n\\n for i in range(L_opmin, min(L_opmax + 1, 8)): # first make a list of tuples of the form:\\n # (number_of_lands_in_opening_hand, probability_of_drawing_such_a_hand)\\n a = hypergeom(i, 7, 60, L_d)\\n opening_nomullignas.append((i, a))\\n mulligan_coeff = mulligan_coeff + a # this will be used later for calculating the probability of\\n # taking the mulligan and is used as a coefficient before the mulligan sum\\n for (x, y) in opening_nomullignas: # use the list of tuples to calculate the first part of equation 5\\n partial_nomulligans = 0\\n for j in range(L_min - x, L_max - x + 1):\\n partial_nomulligans = partial_nomulligans + hypergeom(j, N_dr, 53, L_d - x)\\n sum_nomulligans = sum_nomulligans + partial_nomulligans * y\\n\\n mulligan_coeff = 1 - mulligan_coeff # probability of mulliganing\\n for i in range(L_opmin, min(L_opmax + 1, 7)): # doing the same thing as before, but drawing 6 instead of 7 cards\\n a = hypergeom(i, 6, 60, L_d)\\n opening_withmullignas.append((i, a))\\n\\n for (x, y) in opening_withmullignas:\\n partial_withmulligans = 0\\n for j in range(L_min - x, L_max - x + 1):\\n partial_withmulligans = partial_withmulligans + hypergeom(j, N_dr, 54, L_d - x)\\n sum_withmulligans = sum_withmulligans + partial_withmulligans * y\\n total_withmulligans = mulligan_coeff * sum_withmulligans\\n\\n return total_withmulligans + sum_nomulligans\",\n \"def test_el_lfc_equals_lcl():\\n levels = np.array([912., 905.3, 874.4, 850., 815.1, 786.6, 759.1, 748.,\\n 732.3, 700., 654.8, 606.8, 562.4, 501.8, 500., 482.,\\n 400., 393.3, 317.1, 307., 300., 252.7, 250., 200.,\\n 199.3, 197., 190., 172., 156.6, 150., 122.9, 112.,\\n 106.2, 100.]) * units.mbar\\n temperatures = np.array([29.4, 28.7, 25.2, 22.4, 19.4, 16.8, 14.3,\\n 13.2, 12.6, 11.4, 7.1, 2.2, -2.7, -10.1,\\n -10.3, -12.4, -23.3, -24.4, -38., -40.1, -41.1,\\n -49.8, -50.3, -59.1, -59.1, -59.3, -59.7, -56.3,\\n -56.9, -57.1, -59.1, -60.1, -58.6, -56.9]) * units.celsius\\n dewpoints = np.array([18.4, 18.1, 16.6, 15.4, 13.2, 11.4, 9.6, 8.8, 0.,\\n -18.6, -22.9, -27.8, -32.7, -40.1, -40.3, -42.4, -53.3,\\n -54.4, -68., -70.1, -70., -70., -70., -70., -70., -70.,\\n -70., -70., -70., -70., -70., -70., -70., -70.]) * units.celsius\\n el_pressure, el_temperature = el(levels, temperatures, dewpoints)\\n assert_almost_equal(el_pressure, 175.7663 * units.mbar, 3)\\n assert_almost_equal(el_temperature, -57.03994 * units.degC, 3)\",\n \"def method3(self):\\n cres=0.\\n Ux_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_aloc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.ALDM[ix ,iy, : , : ]\\n mat2=self.ALDM[(ix%self.kS.Nx)+1, iy, : , : ]\\n mat3=self.ALDM[ix ,(iy%self.kS.Ny)+1, : , : ]\\n \\n Ux_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[self.NL-1:,self.NL-1:])\\n Uy_aloc[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[self.NL-1:,self.NL-1:])\\n\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_aloc[ix,iy]*Uy_aloc[ix+1,iy]/Ux_aloc[ix,iy+1]/Uy_aloc[ix,iy])\\n cres+=ftemp/2./pi/1j\\n \\n return cres.real\\n #End of method3\",\n \"def os2latlng(E, N):\\n\\n OSGB_F0 = 0.9996012717\\n N0 = -100000.0\\n E0 = 400000.0\\n\\n a = 6377563.396\\n b = 6356256.909\\n eSquared = ab2ecc(a, b)\\n\\n phi0 = math.radians(49.0)\\n lambda0 = math.radians(-2.0)\\n phi = 0.0\\n lmb = 0.0\\n n = (a - b) / (a + b)\\n M = 0.0\\n phiPrime = ((N - N0) / (a * OSGB_F0)) + phi0\\n\\n while True:\\n M = (b * OSGB_F0) \\\\\\n * (((1 + n + ((5.0 / 4.0) * n * n) + ((5.0 / 4.0) * n * n * n)) \\\\\\n * (phiPrime - phi0)) \\\\\\n - (((3 * n) + (3 * n * n) + ((21.0 / 8.0) * n * n * n)) \\\\\\n * math.sin(phiPrime - phi0) \\\\\\n * math.cos(phiPrime + phi0)) \\\\\\n + ((((15.0 / 8.0) * n * n) + ((15.0 / 8.0) * n * n * n)) \\\\\\n * math.sin(2.0 * (phiPrime - phi0)) \\\\\\n * math.cos(2.0 * (phiPrime + phi0))) \\\\\\n - (((35.0 / 24.0) * n * n * n) \\\\\\n * math.sin(3.0 * (phiPrime - phi0)) \\\\\\n * math.cos(3.0 * (phiPrime + phi0))))\\n\\n phiPrime += (N - N0 - M) / (a * OSGB_F0)\\n if ((N - N0 - M) >= 0.001):\\n break\\n\\n v = a * OSGB_F0 * math.pow(1.0 - eSquared * sinSquared(phiPrime), -0.5)\\n rho = a \\\\\\n * OSGB_F0 \\\\\\n * (1.0 - eSquared) \\\\\\n * math.pow(1.0 - eSquared * sinSquared(phiPrime), -1.5)\\n\\n etaSquared = (v / rho) - 1.0\\n\\n VII = math.tan(phiPrime) / (2 * rho * v)\\n VIII = (math.tan(phiPrime) / (24.0 * rho * math.pow(v, 3.0))) \\\\\\n * (5.0 \\\\\\n + (3.0 * tanSquared(phiPrime)) \\\\\\n + etaSquared \\\\\\n - (9.0 * tanSquared(phiPrime) * etaSquared))\\n IX = (math.tan(phiPrime) / (720.0 * rho * math.pow(v, 5.0))) \\\\\\n * (61.0 \\\\\\n + (90.0 * tanSquared(phiPrime)) \\\\\\n + (45.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\\n X = sec(phiPrime) / v\\n XI = (sec(phiPrime) / (6.0 * v * v * v)) \\\\\\n * ((v / rho) + (2 * tanSquared(phiPrime)))\\n XII = (sec(phiPrime) / (120.0 * math.pow(v, 5.0))) \\\\\\n * (5.0 \\\\\\n + (28.0 * tanSquared(phiPrime)) \\\\\\n + (24.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\\n XIIA = (sec(phiPrime) / (5040.0 * math.pow(v, 7.0))) \\\\\\n * (61.0 \\\\\\n + (662.0 * tanSquared(phiPrime)) \\\\\\n + (1320.0 * tanSquared(phiPrime) * tanSquared(phiPrime)) \\\\\\n + (720.0\\n * tanSquared(phiPrime) \\\\\\n * tanSquared(phiPrime) \\\\\\n * tanSquared(phiPrime)))\\n\\n phi = phiPrime \\\\\\n - (VII * math.pow(E - E0, 2.0)) \\\\\\n + (VIII * math.pow(E - E0, 4.0)) \\\\\\n - (IX * math.pow(E - E0, 6.0))\\n\\n lmb = lambda0 \\\\\\n + (X * (E - E0)) \\\\\\n - (XI * math.pow(E - E0, 3.0)) \\\\\\n + (XII * math.pow(E - E0, 5.0)) \\\\\\n - (XIIA * math.pow(E - E0, 7.0))\\n\\n return OSGB36toWGS84(math.degrees(phi), math.degrees(lmb))\",\n \"def dolomite():\\n\\n rho = 2840.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 205.; C[0,1] = 71.; C[0,2] = 57.4; C[0,3] = -19.5; C[0,4] = 13.7; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 205.; C[1,2] = 57.4; C[1,3] = 19.5; C[1,4] = -13.7; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 113.; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 39.8; C[3,4] = 0.; C[3,5] = -13.7\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 39.8; C[4,5] = -19.5\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 67.\\n\\n return C, rho\",\n \"def lizardite():\\n\\n rho = 2610.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 245.; C[0,1] = 50.; C[0,2] = 31.; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 245.; C[1,2] = 31.; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 23.; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 11.6; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 11.6; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 97.5\\n\\n return C, rho\",\n \"def lcn(x,ishape,size=9):\\n # Function borrowed from bengioe_util\\n inshape = (x.shape[0],1,ishape[0],ishape[1])\\n p = x.reshape(inshape)\\n #p = (p-TT.mean(p))/T.std(p)\\n g = gaussian(size,1.591/size)\\n g/=g.sum()\\n g = numpy.float32(g.reshape((1,1,size,size)))\\n mean = TT.nnet.conv.conv2d(p,TT.constant(g),\\n None,\\n (1,1,size,size),\\n 'full').reshape(\\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\\n mean = mean[:,:,\\n size/2:ishape[0]+size/2,\\n size/2:ishape[1]+size/2]\\n v = (p - mean)#.dimshuffle('x','x',0,1)\\n var = TT.nnet.conv.conv2d(TT.sqr(v),TT.constant(g),\\n None,\\n (1,1,size,size),\\n 'full').reshape(\\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\\n var = var[:,:,\\n size/2:ishape[0]+size/2,\\n size/2:ishape[1]+size/2]\\n std = TT.sqrt(var)\\n std_mean = TT.mean(TT.mean(std,axis=3),axis=2).dimshuffle(0,1,'x','x')\\n out = v / TT.maximum(std,std_mean)\\n return (out + 2.5 )/5# - out.min()\",\n \"def eulerBuckle(dim):\\n bst = dim[0]\\n tst = dim[1]\\n tsk = dim[2]\\n\\n ZEAZ = (Est*bst*tst*((tsk/2)+(bst/2)))\\n ZEA = (Est*bst*tst)+(Esk*tsk*bsk)\\n zbar = ZEAZ/ZEA # Neutral Axis\\n\\n EIbar = ((Esk*bsk*(tsk**3))/12)+(Esk*bsk*tsk*(zbar**2))+((Est*tst*bst**3)/12)+\\\\\\n (Est*bst*tst*(((bst/2)+(tsk/2)-zbar)**2)) # Using Parallel Axis Theorm\\n NxEuler = ((math.pi**2)*EIbar)/(ribSpace**2*bsk) # Critical Load\\n rsf = NxEuler/Nx\\n return rsf - 1.1 # Using a target Reserve Factor of >=1.1\",\n \"def P2l_rec_norm(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 P2l_norm = np.copy(P2l)\\n P2l_norm[2] *= P2l_norm_prefac(2)\\n P2l_norm[3] *= P2l_norm_prefac(3)\\n for ell in ells[4:]:\\n # print ell, P2l[ell-1], P2l[ell-2]\\n a = np.sqrt((4 * ell**2 - 1.) / (ell**2 - 4))\\n b = cost * P2l_norm[ell - 1]\\n c = np.sqrt(((ell - 1.)**2 - 4) /\\n (4 * (ell - 1.)**2 - 1)) * P2l_norm[ell - 2]\\n # print a,b,c\\n P2l_norm[ell] = a * (b - c)\\n # print ell, P2l_norm[ell], P2l_norm_prefac(ell)\\n P2l[ell] = P2l_norm[ell] / P2l_norm_prefac(ell)\\n return P2l\",\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 task2_extra():\\n N = 0\\n lam = 0\\n Ls = numpy.array([2*L for L in range(1,23)])\\n h = 0.01\\n tau = 0.000099\\n\\n iterss = []\\n\\n for L in Ls:\\n a = L // 2\\n print(L)\\n x = numpy.linspace(-L, L, int(2*L/h) + 1)\\n # eps = int(0.1 * len(x))\\n\\n Vm = V1D(lam, x)\\n state = phi(N, x-a)\\n\\n iters = 0\\n while True:\\n prob = numpy.abs(state)**2\\n mid = int(2*L/h) // 2\\n # if max(prob) in prob[mid-eps:mid+eps]:\\n if numpy.argmax(prob) <= mid:\\n print(iters)\\n iterss.append(iters)\\n break\\n\\n state[0] = 0\\n state[-1] = 0\\n state = implicit_scheme_step(state, tau, h, Vm)\\n iters += 1\\n\\n fig = plt.figure()\\n plt.title(\\\"Iterations of Gaussian travel to center\\\")\\n plt.xlabel(\\\"$L$\\\")\\n plt.ylabel(\\\"Time\\\")\\n plt.plot(Ls, tau*numpy.array(iterss))\\n plt.show()\\n fig.savefig(\\\"naloga2_iters_of_gaussian_travel.pdf\\\", bbox_inches=\\\"tight\\\")\",\n \"def phi2_coefficient(L):\\r\\n\\r\\n if 0 < L < 120:\\r\\n return L / 120\\r\\n if L >= 120:\\r\\n return 1\",\n \"def kl2(mu1, mu2, sigma1, sigma2):\\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)\",\n \"def kl2(mu1, mu2, sigma1, sigma2):\\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)\",\n \"def kl(mu1, mu2):\\n return (mu2-mu1)**2/2\",\n \"def kl(mu1, mu2):\\n return (mu2-mu1)**2/2\",\n \"def laplacian_smoothing(texture_data, lap, lap_b, nb_iter, dt):\\n mod = 1\\n if nb_iter > 10:\\n mod = 10\\n if nb_iter > 100:\\n mod = 100\\n if nb_iter > 1000:\\n mod = 1000\\n # print(tex.shape[0])\\n # print(tex.ndim)\\n # if tex.ndim < 2:\\n # Mtex = tex.reshape(tex.shape[0],1)\\n # else:\\n # Mtex = tex\\n # using Implicit scheme\\n # B(X^(n+1)-X^n)/dt+L(X^(n+1))=0\\n M = lap_b + dt * lap\\n for i in range(nb_iter):\\n texture_data = lap_b * texture_data\\n if texture_data.ndim > 1:\\n for d in range(texture_data.shape[1]):\\n texture_data[:, d], infos = lgmres(\\n M.tocsr(), texture_data[:, d], tol=solver_tolerance\\n )\\n else:\\n texture_data, infos = lgmres(M.tocsr(), texture_data, tol=solver_tolerance)\\n if i % mod == 0:\\n print(i)\\n\\n # using Explicit scheme, convergence guaranteed only for dt<1 and not\\n # faster than implicit when using fem Laplacian\\n # B(X^(n+1)-X^n)/dt+L(X^n)=0\\n # M = B-dt*L\\n # for i in range(Niter):\\n # Mtex = M * Mtex\\n # Mtex, infos = lgmres(B.tocsr(), Mtex, tol=solver_tolerance)\\n # if (i % mod == 0):\\n # print(i)\\n print(\\\" OK\\\")\\n return texture_data\",\n \"def getTru(n,int_method,func) :\\n m = np.asarray([0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,6,7,8,9,10])\\n bes = np.asarray([-0.5,0,0.43675,0.47773,0.49231,0.49316,0.49280,0.50325,\\n 0.51140,0.52169,0.55823,0.58086,0.60463,0.61483,0.66995])\\n p = np.asarray([1,0,0.61007,0.77491,0.84071,0.87689,0.89914,0.91365,\\n 0.92449,0.93279,0.94451,0.95289,0.95904,0.96385,\\n 0.96731])\\n h1 = np.asarray([0,0,-0.07257,-0.04963,-0.03313,-0.02282,-0.01648,\\n -0.01248,-0.00970,-0.00773,-0.00522,-0.00369,-0.00272,\\n -0.00206,-0.00164])\\n h2 = np.asarray([0,0,-0.20048,-0.15556,-0.12070,-0.09611,-0.07919,\\n -0.06747,-0.05829,-0.05106,-0.04060,-0.03311,-0.02768,\\n -0.02353,-0.02053])\\n h3 = np.asarray([0,0,0.01647,0.08284,0.14390,0.19680,0.24168,0.27969,\\n 0.31280,0.34181,0.39002,0.42942,0.46208,0.48997,0.51325])\\n \\n if (func == True) :\\n int_bes = splev(n,splrep(m, bes))\\n int_p = splev(n,splrep(m, p))\\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_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_h1,int_h2,int_h3])\",\n \"def test_linear_2d_merwe_column():\\n\\n\\n def fx(x, dt):\\n F = np.array([[1, dt, 0, 0],\\n [0, 1, 0, 0],\\n [0, 0, 1, dt],\\n [0, 0, 0, 1]], dtype=float)\\n\\n return np.dot(F, x)\\n\\n def hx(x):\\n return np.array([x[0], x[2]])\\n\\n\\n dt = 0.1\\n points = MerweScaledSigmaPoints2(4, .1, 2., -1)\\n kf = UKF2(dim_x=4, dim_z=2, dt=dt, fx=fx, hx=hx, points=points)\\n\\n\\n kf.x = np.array([[-1., 1., -1., 1]]).T\\n kf.P*=0.0001\\n #kf.R *=0\\n #kf.Q\\n\\n zs = []\\n for i in range(20):\\n z = np.array([[i+randn()*0.1],\\n [i+randn()*0.1]])\\n zs.append(z)\\n\\n Ms, Ps = kf.batch_filter(zs)\\n smooth_x, _, _ = kf.rts_smoother(Ms, Ps, dt=dt)\\n\\n if DO_PLOT:\\n plt.figure()\\n zs = np.asarray(zs)\\n plt.plot(zs[:,0], marker='+', c='b')\\n plt.plot(Ms[:,0], c='b')\\n plt.plot(smooth_x[:,0], smooth_x[:,2], c='r')\\n print(smooth_x)\",\n \"def exo1():\\n randu = randn(N/ 2, N/ 2, 2); % a random vector field\\n b = 2\\n for i in 1: 4:\\n LLs_u = Li{i}(LiS{i}(randu))\\n % relative error should be very small\\n norm(abs(LLs_u(: ) - b*randu(: )))/ norm(randu(: ))\",\n \"def LLE(data, n_components=2, n_neighbors=10):\\n # Compute the nearest neighbors\\n _, neighbors_idx = AffiinityMAt(data,n_neighbor=n_neighbors,kernel_method='Linear')\\n\\n n = data.shape[0]\\n w = np.zeros((n, n))\\n for i in range(n):\\n # Center the neighbors matrix\\n k_indexes = neighbors_idx[i, :]\\n neighbors = data[k_indexes, :] - data[i, :]\\n\\n # Compute the corresponding gram matrix\\n gram_inv = np.linalg.pinv(np.dot(neighbors, neighbors.T))\\n\\n # Setting the weight values according to the lagrangian\\n lambda_par = 2/np.sum(gram_inv)\\n w[i, k_indexes] = lambda_par*np.sum(gram_inv, axis=1)/2\\n m = np.subtract(np.eye(n), w)\\n values, u = np.linalg.eigh(np.dot(np.transpose(m), m))\\n return u[:, 1:n_components+1]\",\n \"def exclusive_lasso5(X, n_clusters, gamma=0.5):\\n MAX_ITERS = 100\\n n_dims, n_samples = X.shape\\n\\n # Initialize indicaotr matrix F\\n F = np.zeros((n_samples, n_clusters), dtype=np.int8)\\n for i in xrange(n_samples):\\n F[i, randint(0, n_clusters-1)] = 1\\n\\n conv = False\\n iteration = 0\\n results = np.zeros(n_clusters, dtype=np.float64)\\n\\n while iteration < MAX_ITERS and not conv:\\n conv = True\\n # Calculate H = XF(F^TF)^-1\\n H = X.dot(sp.linalg.pinv(F.T))\\n\\n base_sum = ((X-H.dot(F.T))**2).sum(axis=0)\\n F_counts = F.sum(axis=0)\\n\\n # Caculate F\\n # For each row (sample)\\n for i in xrange(n_samples):\\n # Get current indicator\\n curr_ind = F[i].nonzero()[0][0]\\n F_counts[curr_ind] = F_counts[curr_ind] - 1\\n\\n # We want to find the indicator column that minimizes\\n # X-HF^T + gamma * Tr(F^T11^TF)\\n for j in xrange(n_clusters):\\n F_counts[j] = F_counts[j] + 1\\n tr = (F_counts**2).sum()\\n res = ((X[:, i]-H[:, j])**2).sum() - base_sum[i] + gamma * tr\\n results[j] = res\\n F_counts[j] = F_counts[j] - 1\\n new_ind = results.argmin()\\n\\n F_counts[new_ind] = F_counts[new_ind] + 1\\n\\n if (curr_ind != new_ind):\\n conv = False\\n F[i, curr_ind] = 0\\n F[i, new_ind] = 1\\n iteration = iteration + 1\\n print iteration\\n return map(lambda x: x.index(1), F.tolist())\",\n \"def Analytical_2x2(J, L, temp):\\n\\n const = 8*J/temp\\n\\n # the partition function\\n Z = 12 + 2*np.exp(-const) + 2*np.exp(const)\\n\\n # expectation values for E\\n E_avg = 16*J* (np.exp(-const) - np.exp(const)) / Z\\n E2_avg = 128*J**2*(np.exp(-const) + np.exp(const)) / Z\\n E_var = E2_avg - E_avg**2 # 512*J**2 * (Z-6) / Z**2 ??\\n\\n # expectation values for M\\n M_avg = 0\\n M2_avg = 32*(1 + np.exp(const)) / Z\\n M_abs_avg = 8*(2 + np.exp(const)) / Z\\n M_var = M2_avg - M_avg**2\\n\\n # scaling by L? why is this correct?\\n A_Energy = E_avg / L**2\\n A_SpecificHeat = E_var / (temp**2 * L**2) # Cv\\n A_Magnetization = M_avg / L**2\\n A_MagnetizationAbs = M_abs_avg / L**2\\n A_Susceptibility = M_var / (temp * L**2) # X, (32/(4*Z))*(1+np.exp(ang))\\n\\n return A_Energy, A_SpecificHeat, A_Magnetization, A_Susceptibility, A_MagnetizationAbs\",\n \"def LBP(ising, maxIter=100, verbose=False):\\n # TODO: pass requested beliefs (like JT?), or \\\"single\\\", \\\"factors\\\", etc.\\n assert isinstance(ising,Ising), \\\"Model must be an Ising model for this version to work\\\"\\n R = ising.L.tocoo(); row = R.row; col = R.col;\\n mu = csr(([],([],[])),shape=ising.L.shape)\\n L_tanh = ising.L.tanh();\\n for it in range(maxIter):\\n mu_sum = arr(mu.sum(0)).reshape(-1);\\n #R = csr( (ising.h[row]+mu_sum[row], (row,col)), shape=ising.L.shape) - mu.T\\n R = csr( (ising.h[row]+mu_sum[row]-arr(mu[col,row]).reshape(-1), (row,col)), shape=ising.L.shape);\\n mu = (L_tanh.multiply(R.tanh())).arctanh()\\n if verbose: print(\\\"Iter \\\"+str(it)+\\\": \\\"+str(__Bethe(ising,R,mu)));\\n\\n R = csr( (ising.h[row]+mu_sum[row]-arr(mu[col,row]).reshape(-1), (row,col)), shape=ising.L.shape);\\n bel = 1./(1+np.exp(-2.*(arr(mu.sum(0)).reshape(-1)+ising.h)))\\n lnZ = __Bethe(ising,R,mu,bel)\\n return lnZ, bel\",\n \"def le(self, x, y):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59114254","0.5880291","0.5843534","0.5838584","0.58302855","0.5817063","0.5756946","0.5756367","0.57547534","0.5744916","0.5710205","0.57045275","0.56486785","0.5626035","0.56195045","0.5611582","0.55996555","0.5590846","0.55713654","0.5568172","0.5551131","0.5550431","0.5540012","0.5513688","0.5506659","0.5503114","0.5491747","0.5491747","0.5484005","0.54807395","0.54734844","0.54665893","0.54660934","0.5458518","0.54560095","0.5451719","0.54489076","0.5438429","0.54172593","0.5405861","0.5398411","0.53978485","0.5394104","0.53875935","0.5386279","0.537965","0.5375857","0.5368208","0.536642","0.53661275","0.53546536","0.53536755","0.5348005","0.534657","0.5345183","0.53409153","0.53375834","0.5337251","0.5330468","0.5320911","0.53176355","0.53144234","0.5312644","0.5299943","0.5294848","0.52920985","0.5290968","0.52802473","0.5278491","0.5276576","0.527237","0.527216","0.52721184","0.527034","0.5269057","0.52659434","0.52658695","0.52625614","0.5262289","0.52617687","0.52590555","0.525572","0.52537954","0.52532625","0.5249906","0.5249013","0.5238846","0.52355254","0.5232843","0.5232843","0.52326757","0.52326757","0.52322024","0.5229603","0.5226592","0.52248114","0.5221975","0.52209824","0.5220982","0.5220957","0.5218896"],"string":"[\n \"0.59114254\",\n \"0.5880291\",\n \"0.5843534\",\n \"0.5838584\",\n \"0.58302855\",\n \"0.5817063\",\n \"0.5756946\",\n \"0.5756367\",\n \"0.57547534\",\n \"0.5744916\",\n \"0.5710205\",\n \"0.57045275\",\n \"0.56486785\",\n \"0.5626035\",\n \"0.56195045\",\n \"0.5611582\",\n \"0.55996555\",\n \"0.5590846\",\n \"0.55713654\",\n \"0.5568172\",\n \"0.5551131\",\n \"0.5550431\",\n \"0.5540012\",\n \"0.5513688\",\n \"0.5506659\",\n \"0.5503114\",\n \"0.5491747\",\n \"0.5491747\",\n \"0.5484005\",\n \"0.54807395\",\n \"0.54734844\",\n \"0.54665893\",\n \"0.54660934\",\n \"0.5458518\",\n \"0.54560095\",\n \"0.5451719\",\n \"0.54489076\",\n \"0.5438429\",\n \"0.54172593\",\n \"0.5405861\",\n \"0.5398411\",\n \"0.53978485\",\n \"0.5394104\",\n \"0.53875935\",\n \"0.5386279\",\n \"0.537965\",\n \"0.5375857\",\n \"0.5368208\",\n \"0.536642\",\n \"0.53661275\",\n \"0.53546536\",\n \"0.53536755\",\n \"0.5348005\",\n \"0.534657\",\n \"0.5345183\",\n \"0.53409153\",\n \"0.53375834\",\n \"0.5337251\",\n \"0.5330468\",\n \"0.5320911\",\n \"0.53176355\",\n \"0.53144234\",\n \"0.5312644\",\n \"0.5299943\",\n \"0.5294848\",\n \"0.52920985\",\n \"0.5290968\",\n \"0.52802473\",\n \"0.5278491\",\n \"0.5276576\",\n \"0.527237\",\n \"0.527216\",\n \"0.52721184\",\n \"0.527034\",\n \"0.5269057\",\n \"0.52659434\",\n \"0.52658695\",\n \"0.52625614\",\n \"0.5262289\",\n \"0.52617687\",\n \"0.52590555\",\n \"0.525572\",\n \"0.52537954\",\n \"0.52532625\",\n \"0.5249906\",\n \"0.5249013\",\n \"0.5238846\",\n \"0.52355254\",\n \"0.5232843\",\n \"0.5232843\",\n \"0.52326757\",\n \"0.52326757\",\n \"0.52322024\",\n \"0.5229603\",\n \"0.5226592\",\n \"0.52248114\",\n \"0.5221975\",\n \"0.52209824\",\n \"0.5220982\",\n \"0.5220957\",\n \"0.5218896\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24395,"cells":{"query":{"kind":"string","value":"Coordinate descent algorithm for lassoformulated l2penalized UOT"},"document":{"kind":"string","value":"def ot_ul2_solve_lasso_cd(C, a, b, reg, nitermax=100000, tol=1e-14):\n\n X = get_X_lasso(C.shape[0], C.shape[1])\n X = X.dot(sp.diags((1 / C.ravel())))\n y = np.concatenate((a, b))\n reg2 = 1.0 / (2 * (C.shape[0] + C.shape[1]) * reg)\n model = Lasso(reg2, positive=True, fit_intercept=False, max_iter=nitermax, tol=tol)\n model.fit(X, y)\n G2 = model.coef_.reshape(C.shape) / C\n return G2"},"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 method2(self):\n cres=np.zeros(self.NL,dtype=float) # List of invariants\n # The U matrices from Fukui's method; storage...\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n for il in range(self.NL):\n # ... and calculation of U matrices for each layer\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.LDM[il,ix ,iy ,:,:]\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\n \n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\n \n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\n \n return cres","def test_el_below_lcl():\n p = [902.1554, 897.9034, 893.6506, 889.4047, 883.063, 874.6284, 866.2387, 857.887,\n 849.5506, 841.2686, 833.0042, 824.7891, 812.5049, 796.2104, 776.0027, 751.9025,\n 727.9612, 704.1409, 680.4028, 656.7156, 629.077, 597.4286, 565.6315, 533.5961,\n 501.2452, 468.493, 435.2486, 401.4239, 366.9387, 331.7026, 295.6319, 258.6428,\n 220.9178, 182.9384, 144.959, 106.9778, 69.00213] * units.hPa\n t = [-3.039381, -3.703779, -4.15996, -4.562574, -5.131827, -5.856229, -6.568434,\n -7.276881, -7.985013, -8.670911, -8.958063, -7.631381, -6.05927, -5.083627,\n -5.11576, -5.687552, -5.453021, -4.981445, -5.236665, -6.324916, -8.434324,\n -11.58795, -14.99297, -18.45947, -21.92021, -25.40522, -28.914, -32.78637,\n -37.7179, -43.56836, -49.61077, -54.24449, -56.16666, -57.03775, -58.28041,\n -60.86264, -64.21677] * units.degC\n td = [-22.08774, -22.18181, -22.2508, -22.31323, -22.4024, -22.51582, -22.62526,\n -22.72919, -22.82095, -22.86173, -22.49489, -21.66936, -21.67332, -21.94054,\n -23.63561, -27.17466, -31.87395, -38.31725, -44.54717, -46.99218, -43.17544,\n -37.40019, -34.3351, -36.42896, -42.1396, -46.95909, -49.36232, -48.94634,\n -47.90178, -49.97902, -55.02753, -63.06276, -72.53742, -88.81377, -93.54573,\n -92.92464, -91.57479] * units.degC\n prof = parcel_profile(p, t[0], td[0]).to('degC')\n el_p, el_t = el(p, t, td, prof)\n assert_nan(el_p, p.units)\n assert_nan(el_t, t.units)","def LEIsotropic2D(self):\n const = self.ymod / ((1+self.Nu) * (1-(2*self.Nu)))\n a = const * self.Nu\n b = const * (1-self.Nu)\n c = const * 0.5 * (1-2*self.Nu)\n Cmat = np.array(\n [\n [b, a, 0],\n [a, b, 0],\n [0, 0, c],\n ], dtype=float)\n stress_el = Cmat @ self.eps\n return stress_el, Cmat","def test_2():\n\n # generate two locusts of points\n npts = 100\n epsilon = 0.001\n # #cluster 1\n coords1 = generate_locus_of_3d_points(npts, 0.1, 0.1, 0.1, epsilon=epsilon)\n # cluster 2\n coords2 = generate_locus_of_3d_points(npts, 0.9, 0.9, 0.9, epsilon=epsilon)\n\n # generate orientation vectors for cluster 1\n vectors1 = generate_aligned_vectors(len(coords1))\n\n # calculate dot product between vectors1 and cluster 2\n r = np.sqrt((0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2)\n # s, vector between coords1 and cluster2\n s = np.zeros((npts, 3))\n s[:, 0] = 0.9 - coords1[:, 0]\n s[:, 1] = 0.9 - coords1[:, 1]\n s[:, 2] = 0.9 - coords1[:, 2]\n\n # calculate dot product between orientation and direction between cluster 1 and 2\n angles = angles_between_list_of_vectors(vectors1, s)\n avg_two_costheta_1 = np.mean(np.cos(2.0 * angles))\n avg_two_costheta_2 = np.mean(2.0 * np.cos(angles) * np.cos(angles) - 1.0)\n assert np.isclose(\n avg_two_costheta_1, avg_two_costheta_2\n ) # test trig identify used in weighting function\n avg_two_costheta = avg_two_costheta_2\n\n # define radial bins\n rbins = np.array([0.0, 0.1, r + 2.0 * epsilon])\n\n # define weights appropiate for weighting function\n weights1 = np.ones((npts, 4))\n weights1[:, 1] = vectors1[:, 0]\n weights1[:, 2] = vectors1[:, 1]\n weights1[:, 3] = vectors1[:, 2]\n weights2 = np.ones(npts)\n\n # calculate weighted counts\n weighted_counts, counts = positional_marked_npairs_3d(\n coords1,\n coords2,\n rbins,\n period=None,\n weights1=weights1,\n weights2=weights2,\n weight_func_id=2,\n num_threads=1,\n )\n\n msg = \"weighted counts do not match expected result given the weighting function\"\n assert np.isclose(\n weighted_counts[-1], avg_two_costheta * counts[-1], rtol=1.0 / npts\n ), msg","def lagrangePoints(mu):\n \n # define l = 1-mu\n l = 1 - mu\n \n # collinear points\n def eqL1(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)+mu-l)*x**2 + (mu**2*l**2+2*(l**2+mu**2))*x + mu**3-l**3\n #fval = gamma**5 - (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 + 2*mu*gamma - mu\n return fval\n sol_l1 = optimize.root(eqL1, 0.5, method='hybr')\n l1 = np.array([sol_l1.x[0] , 0, 0])\n \n def eqL2(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)-(mu+l))*x**2 + (mu**2*l**2+2*(l**2-mu**2))*x - (mu**3+l**3)\n #fval = gamma**5 + (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 - 2*mu*gamma - mu\n return fval\n sol_l2 = optimize.root(eqL2, 1.5, method='hybr')\n l2 = np.array([sol_l2.x[0] , 0, 0])\n \n def eqL3(x):\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*mu*l+mu**2)*x**3 + (2*mu*l*(l-mu)+(l+mu))*x**2 + (mu**2*l**2+2*(mu**2-l**2))*x + l**3+mu**3\n return fval\n sol_l3 = optimize.root(eqL3, -1, method='hybr')\n l3 = np.array([sol_l3.x[0] , 0, 0])\n \n # equilateral points\n # L4\n l4 = np.array([np.cos(np.pi/3) - mu , np.sin(np.pi/3), 0])\n # L5\n l5 = np.array([np.cos(np.pi/3) - mu , -np.sin(np.pi/3), 0])\n \n return _lagrangePointsReturn(l1,l2,l3,l4,l5)","def le(self, x, y):","def lorentzian2d(p, x, y):\n #2012-02-04 11:38 IJMC: Created\n \n x = array(x, dtype=float).copy()\n y = array(y, dtype=float).copy()\n p = array(p).copy()\n\n if len(p)==5:\n p = concatenate((p, [0, 0]))\n elif len(p)==6:\n p = concatenate((p, [0]))\n\n z = ((x - p[3]) / p[1])**2 + ((y - p[4]) / p[2])**2 + p[5] * (x - p[3]) * (y - p[4])\n \n return p[6] + p[0]/(1. + z)","def lherzolite():\n\n rho = 3270.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 190.; C[2,3] = 0.38; C[2,4] = 2.38; C[2,5] = -0.12\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 67.9; C[3,4] = -2.12; C[3,5] = 1.6\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 63.12; C[4,5] = -0.55\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 66.83\n\n return C, rho","def dist_vincenty(lat1, lon1, lat2, lon2, iterations=20):\r\n if lat1 < -90 or lat1 > 90 or lat2 < -90 or lat2 > 90 or lon1 < -180 or lon1 > 180 or lon2 < -180 or lon2 > 180:\r\n raise ValueError(\r\n \"Latitude values shoulds range from (-90,90) and longitude from (-180,180) but one of the input values is out of bounds. Latitude_1: %f, Logitude_1: %f, Latitude_2: %f, Logitude_2: %f\" %\r\n (lat1, lon1, lat2, lon2))\r\n\r\n major, minor, f = 6378137, 6356752.314245, 1 / 298.257223563\r\n\r\n lat1, lng1, lat2, lng2 = radians(\r\n lat1), radians(lon1), radians(lat2), radians(lon2)\r\n delta_lng = lng2 - lng1\r\n reduced_lat1, reduced_lat2 = atan(\r\n (1 - f) * tan(lat1)), atan((1 - f) * tan(lat2))\r\n\r\n sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1)\r\n sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2)\r\n\r\n lambda_lng = delta_lng\r\n lambda_prime = 2 * pi\r\n while abs(lambda_lng - lambda_prime) > 10e-12 and iterations > 0:\r\n sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng)\r\n\r\n sin_sigma = sqrt(\r\n (cos_reduced2 * sin_lambda_lng) ** 2 +\r\n (cos_reduced1 * sin_reduced2 -\r\n sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2\r\n )\r\n if sin_sigma == 0:\r\n return 0 # Coincident points\r\n\r\n cos_sigma = (\r\n sin_reduced1 * sin_reduced2 +\r\n cos_reduced1 * cos_reduced2 * cos_lambda_lng\r\n )\r\n sigma = atan2(sin_sigma, cos_sigma)\r\n\r\n sin_alpha = (cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma)\r\n cos_sq_alpha = 1 - sin_alpha ** 2\r\n\r\n if cos_sq_alpha != 0:\r\n cos2_sigma_m = cos_sigma - 2 * \\\r\n (sin_reduced1 * sin_reduced2 / cos_sq_alpha)\r\n else:\r\n cos2_sigma_m = 0.0 # Equatorial line\r\n\r\n C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))\r\n\r\n lambda_prime = lambda_lng\r\n lambda_lng = (\r\n delta_lng + (1 - C) * f * sin_alpha * (\r\n sigma + C * sin_sigma * (\r\n cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m ** 2)\r\n )\r\n )\r\n )\r\n iterations -= 1\r\n\r\n if iterations == 0:\r\n raise ValueError(\"Vincenty formula failed to converge!\")\r\n\r\n u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2\r\n A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))\r\n B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))\r\n delta_sigma = B * sin_sigma * (\r\n cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m ** 2) -\r\n B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma ** 2) *\r\n (-3 + 4 * cos2_sigma_m ** 2))\r\n )\r\n s = minor * A * (sigma - delta_sigma)\r\n\r\n return round(s, 3) # round to 1mm precision\r","def potentialSolver5(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def I(x, y, l, p):\n \n return 0.5 / (mu * c) * A0**2 * ( u(x, y, l, p) )**2","def __init__(self, \n nd = 2, \n goal = np.array([1.0,1.0]),\n state_bound = [[0,1],[0,1]],\n nA = 4,\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\n<<<<<<< HEAD:archive-code/puddleworld.py\n ngrid = [10.0,10.0],\n maxStep = 40):\n ngrid = [40, 40]\n x_vec = np.linspace(0,1,ngrid[0])\n y_vec = np.linspace(0,1,ngrid[1])\n for x in x_vec:\n for y in y_vec:\n if ~self.inPuddle([x,y]):\n puddle.append([x,y])\n # puddle is a closed loop \n outpuddlepts = np.asarray(puddle)\n \"\"\"\n\n\n # Horizontal wing of puddle consists of \n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\n # (xchi,ychi) is the center points (h ==> horizantal)\n # x, y = state[0], state[1]\n xch1, ych1 = 0.3, 0.7\n xch2, ych2 = 0.65, ych1\n radius = 0.1\n\n\n #Vertical wing of puddle consists of \n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\n # where (xcvi,ycvi) is the center points (v ==> vertical)\n xcv1 = 0.45; ycv1=0.4;\n xcv2 = xcv1; ycv2 = 0.8;\n\n # % 2) two half-circle at end edges of rectangle\n \n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n puddle.append([xcv1-radius,ych1-radius])\n \n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1-radius])\n \n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n \n puddle.append([xcv1-radius,ych1+radius])\n\n\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\n puddle.append([x,ych1+radius])\n\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1-radius,y])\n \n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\n puddle.append([xcv1+radius,y])\n \"\"\"\n for y in np.arrange():\n puddle.append([])\n \n for y in np.arrange():\n puddle.append([])\n \"\"\"\n\n # HALF CIRCLES\n ngridTheta = 10\n thetaVec = np.linspace(0,pi,ngridTheta)\n\n for t in thetaVec:\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\n\n for t in thetaVec:\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\n\n for t in thetaVec:\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\n\n \n outpuddlepts = np.asarray(puddle)\n return outpuddlepts","def light_source_directions():\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\n [-0.05939919, -0.33739538, 0.93948714],\n [-0.05710194, -0.21230722, 0.97553319],\n [-0.05360061, -0.07800089, 0.99551134],\n [-0.04919816, 0.05869781, 0.99706274],\n [-0.04399823, 0.19019233, 0.98076044],\n [-0.03839991, 0.31049925, 0.9497977],\n [-0.03280081, 0.41611025, 0.90872238],\n [-0.18449839, -0.43989616, 0.87889232],\n [-0.18870114, -0.32950199, 0.92510557],\n [-0.1901994, -0.20549935, 0.95999698],\n [-0.18849605, -0.07269848, 0.97937948],\n [-0.18329657, 0.06229884, 0.98108166],\n [-0.17500445, 0.19220488, 0.96562453],\n [-0.16449474, 0.31129005, 0.93597008],\n [-0.15270716, 0.4160195, 0.89644202],\n [-0.30139786, -0.42509698, 0.85349393],\n [-0.31020115, -0.31660118, 0.89640333],\n [-0.31489186, -0.19549495, 0.92877599],\n [-0.31450962, -0.06640203, 0.94692897],\n [-0.30880699, 0.06470146, 0.94892147],\n [-0.2981084, 0.19100538, 0.93522635],\n [-0.28359251, 0.30729189, 0.90837601],\n [-0.26670649, 0.41020998, 0.87212122],\n [-0.40709586, -0.40559588, 0.81839168],\n [-0.41919869, -0.29999906, 0.85689732],\n [-0.42618633, -0.18329412, 0.88587159],\n [-0.42691512, -0.05950211, 0.90233197],\n [-0.42090385, 0.0659006, 0.90470827],\n [-0.40860354, 0.18720162, 0.89330773],\n [-0.39141794, 0.29941372, 0.87013988],\n [-0.3707838, 0.39958255, 0.83836338],\n [-0.499596, -0.38319693, 0.77689378],\n [-0.51360334, -0.28130183, 0.81060526],\n [-0.52190667, -0.16990217, 0.83591069],\n [-0.52326874, -0.05249686, 0.85054918],\n [-0.51720021, 0.06620003, 0.85330035],\n [-0.50428312, 0.18139393, 0.84427174],\n [-0.48561334, 0.28870793, 0.82512267],\n [-0.46289771, 0.38549809, 0.79819605],\n [-0.57853599, -0.35932235, 0.73224555],\n [-0.59329349, -0.26189713, 0.76119165],\n [-0.60202327, -0.15630604, 0.78303027],\n [-0.6037003, -0.04570002, 0.7959004],\n [-0.59781529, 0.06590169, 0.79892043],\n [-0.58486953, 0.17439091, 0.79215873],\n [-0.56588359, 0.27639198, 0.77677747],\n [-0.54241965, 0.36921337, 0.75462733],\n [0.05220076, -0.43870637, 0.89711304],\n [0.05199786, -0.33138635, 0.9420612],\n [0.05109826, -0.20999284, 0.97636672],\n [0.04919919, -0.07869871, 0.99568366],\n [0.04640163, 0.05630197, 0.99733494],\n [0.04279892, 0.18779527, 0.98127529],\n [0.03870043, 0.30950341, 0.95011048],\n [0.03440055, 0.41730662, 0.90811441],\n [0.17290651, -0.43181626, 0.88523333],\n [0.17839998, -0.32509996, 0.92869988],\n [0.18160174, -0.20480196, 0.96180921],\n [0.18200745, -0.07490306, 0.98044012],\n [0.17919505, 0.05849838, 0.98207285],\n [0.17329685, 0.18839658, 0.96668244],\n [0.1649036, 0.30880674, 0.93672045],\n [0.1549931, 0.41578148, 0.89616009],\n [0.28720483, -0.41910705, 0.8613145],\n [0.29740177, -0.31410186, 0.90160535],\n [0.30420604, -0.1965039, 0.9321185],\n [0.30640529, -0.07010121, 0.94931639],\n [0.30361153, 0.05950226, 0.95093613],\n [0.29588748, 0.18589214, 0.93696036],\n [0.28409783, 0.30349768, 0.90949304],\n [0.26939905, 0.40849857, 0.87209694],\n [0.39120402, -0.40190413, 0.8279085],\n [0.40481085, -0.29960803, 0.86392315],\n [0.41411685, -0.18590756, 0.89103626],\n [0.41769724, -0.06449957, 0.906294],\n [0.41498764, 0.05959822, 0.90787296],\n [0.40607977, 0.18089099, 0.89575537],\n [0.39179226, 0.29439419, 0.87168279],\n [0.37379609, 0.39649585, 0.83849122],\n [0.48278794, -0.38169046, 0.78818031],\n [0.49848546, -0.28279175, 0.8194761],\n [0.50918069, -0.1740934, 0.84286803],\n [0.51360856, -0.05870098, 0.85601427],\n [0.51097962, 0.05899765, 0.8575658],\n [0.50151639, 0.17420569, 0.84742769],\n [0.48600297, 0.28260173, 0.82700506],\n [0.46600106, 0.38110087, 0.79850181],\n [0.56150442, -0.35990283, 0.74510586],\n [0.57807114, -0.26498677, 0.77176147],\n [0.58933134, -0.1617086, 0.7915421],\n [0.59407609, -0.05289787, 0.80266769],\n [0.59157958, 0.057798, 0.80417224],\n [0.58198189, 0.16649482, 0.79597523],\n [0.56620006, 0.26940003, 0.77900008],\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\n return L","def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\n #epsx = (1/2)*(eps1+eps2)\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))","def _holt__(x, xi, p, y, l, b, s, m, n, max_seen):\n alpha, beta, phi, alphac, betac, y_alpha = _holt_init(x, xi, p, y, l, b)\n for i in range(1, n):\n l[i] = (y_alpha[i - 1]) + (alphac * (l[i - 1]))\n return sqeuclidean(l, y)","def os2latlng(E, N):\n\n OSGB_F0 = 0.9996012717\n N0 = -100000.0\n E0 = 400000.0\n\n a = 6377563.396\n b = 6356256.909\n eSquared = ab2ecc(a, b)\n\n phi0 = math.radians(49.0)\n lambda0 = math.radians(-2.0)\n phi = 0.0\n lmb = 0.0\n n = (a - b) / (a + b)\n M = 0.0\n phiPrime = ((N - N0) / (a * OSGB_F0)) + phi0\n\n while True:\n M = (b * OSGB_F0) \\\n * (((1 + n + ((5.0 / 4.0) * n * n) + ((5.0 / 4.0) * n * n * n)) \\\n * (phiPrime - phi0)) \\\n - (((3 * n) + (3 * n * n) + ((21.0 / 8.0) * n * n * n)) \\\n * math.sin(phiPrime - phi0) \\\n * math.cos(phiPrime + phi0)) \\\n + ((((15.0 / 8.0) * n * n) + ((15.0 / 8.0) * n * n * n)) \\\n * math.sin(2.0 * (phiPrime - phi0)) \\\n * math.cos(2.0 * (phiPrime + phi0))) \\\n - (((35.0 / 24.0) * n * n * n) \\\n * math.sin(3.0 * (phiPrime - phi0)) \\\n * math.cos(3.0 * (phiPrime + phi0))))\n\n phiPrime += (N - N0 - M) / (a * OSGB_F0)\n if ((N - N0 - M) >= 0.001):\n break\n\n v = a * OSGB_F0 * math.pow(1.0 - eSquared * sinSquared(phiPrime), -0.5)\n rho = a \\\n * OSGB_F0 \\\n * (1.0 - eSquared) \\\n * math.pow(1.0 - eSquared * sinSquared(phiPrime), -1.5)\n\n etaSquared = (v / rho) - 1.0\n\n VII = math.tan(phiPrime) / (2 * rho * v)\n VIII = (math.tan(phiPrime) / (24.0 * rho * math.pow(v, 3.0))) \\\n * (5.0 \\\n + (3.0 * tanSquared(phiPrime)) \\\n + etaSquared \\\n - (9.0 * tanSquared(phiPrime) * etaSquared))\n IX = (math.tan(phiPrime) / (720.0 * rho * math.pow(v, 5.0))) \\\n * (61.0 \\\n + (90.0 * tanSquared(phiPrime)) \\\n + (45.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\n X = sec(phiPrime) / v\n XI = (sec(phiPrime) / (6.0 * v * v * v)) \\\n * ((v / rho) + (2 * tanSquared(phiPrime)))\n XII = (sec(phiPrime) / (120.0 * math.pow(v, 5.0))) \\\n * (5.0 \\\n + (28.0 * tanSquared(phiPrime)) \\\n + (24.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\n XIIA = (sec(phiPrime) / (5040.0 * math.pow(v, 7.0))) \\\n * (61.0 \\\n + (662.0 * tanSquared(phiPrime)) \\\n + (1320.0 * tanSquared(phiPrime) * tanSquared(phiPrime)) \\\n + (720.0\n * tanSquared(phiPrime) \\\n * tanSquared(phiPrime) \\\n * tanSquared(phiPrime)))\n\n phi = phiPrime \\\n - (VII * math.pow(E - E0, 2.0)) \\\n + (VIII * math.pow(E - E0, 4.0)) \\\n - (IX * math.pow(E - E0, 6.0))\n\n lmb = lambda0 \\\n + (X * (E - E0)) \\\n - (XI * math.pow(E - E0, 3.0)) \\\n + (XII * math.pow(E - E0, 5.0)) \\\n - (XIIA * math.pow(E - E0, 7.0))\n\n return OSGB36toWGS84(math.degrees(phi), math.degrees(lmb))","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def compute_loss_lasso(y, tx, w, lambda_):\n e = y - tx.dot(w)\n\n return e.dot(e)/(2 * len(e)) + lambda_ * sum(abs(w))","def img2heliovec(bxImg,byImg,bzImg,lon,lat,lonc,latc,pAng):\n a11 = -np.sin(latc)*np.sin(pAng)*np.sin(lon - lonc) + np.cos(pAng)*np.cos(lon - lonc)\n a12 = np.sin(latc)*np.cos(pAng)*np.sin(lon - lonc) + np.sin(pAng)*np.cos(lon - lonc)\n a13 = -np.cos(latc)*np.sin(lon - lonc)\n a21 = -np.sin(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.cos(lat)*np.cos(latc)*np.sin(pAng)\n a22 = np.sin(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.cos(lat)*np.cos(latc)*np.cos(pAng)\n a23 = -np.cos(latc)*np.sin(lat)*np.cos(lon - lonc) + np.sin(latc)*np.cos(lat)\n a31 = np.cos(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.sin(lat)*np.cos(latc)*np.sin(pAng)\n a32 = -np.cos(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.sin(lat)*np.cos(latc)*np.cos(pAng)\n a33 = np.cos(lat)*np.cos(latc)*np.cos(lon - lonc) + np.sin(lat)*np.sin(latc)\n\n bxHelio = a11 * bxImg + a12 * byImg + a13 * bzImg\n byHelio = a21 * bxImg + a22 * byImg + a23 * bzImg\n bzHelio = a31 * bxImg + a32 * byImg + a33 * bzImg\n\n return bxHelio,byHelio,bzHelio","def calc_lampam_2(ss):\n if isinstance(ss, list):\n lampam = np.zeros((len(ss), 12), float)\n for index in range(len(ss)):\n lampam[index] = calc_lampam_2(ss[index])\n return lampam\n if ss.ndim == 2 and ss.shape[0] > 1:\n lampam = np.zeros((ss.shape[0], 12), float)\n for index in range(ss.shape[0]):\n lampam[index] = calc_lampam_2(ss[index])\n return lampam\n\n n_plies_in_panels = np.size(ss) # laminate ply count\n\n theta2 = np.deg2rad(2*ss.astype(float))\n theta4 = 2*theta2\n cos_sin = np.concatenate((\n np.cos(theta2),\n np.cos(theta4),\n np.sin(theta2),\n np.sin(theta4))).reshape((4, n_plies_in_panels))\n\n for_the_top = np.arange(n_plies_in_panels)\n z_0 = np.ones(n_plies_in_panels)\n z_2 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**3 \\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**3\n z_1 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**2 \\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**2\n\n return np.array([\n (1/n_plies_in_panels)*np.matmul(cos_sin, z_0),\n (2/n_plies_in_panels**2)*np.matmul(cos_sin, z_1),\n (4/n_plies_in_panels**3)*np.matmul(cos_sin, z_2)]).reshape(12)","def lap2D(self, lat):\n lap = np.roll(lat, 1, 0) + np.roll(lat, -1, 0) + \\\n np.roll(lat, 1, 1) + np.roll(lat, -1, 1) - \\\n 4. * lat\n lap = 1./self.dx**2. * lap\n # print(lap[50][50])\n return(lap)","def offset(x, y, L):\n length = x.size\n offsetx = np.zeros((length, 2))\n offsety = np.zeros((length, 2))\n dx = np.zeros(length-1)\n dy = np.zeros(length-1)\n dxL = np.zeros(length-1)\n dyL = np.zeros(length-1)\n xl = np.zeros(length) # counterclockwise\n xr = np.zeros(length) # clockwise\n yl = np.zeros(length)\n yr = np.zeros(length)\n xl0 = np.zeros(length)\n xr0 = np.zeros(length)\n yl0 = np.zeros(length)\n yr0 = np.zeros(length) \n for i in range(0, length-1):\n dx[i] = x[i+1]-x[i]\n dy[i] = y[i+1]-y[i]\n for i in range(0, length-1):\n r = np.sqrt(dx[i]**2 + dy[i]**2)\n dxL[i] = dx[i]*L/r\n dyL[i] = dy[i]*L/r\n xl0[i] = -dyL[i] + x[i]\n yl0[i] = dxL[i] + y[i]\n xr0[i] = dyL[i] + x[i]\n yr0[i] = -dxL[i] + y[i]\n xl0[length-1] = xl0[length-2] + dx[length-2]\n yl0[length-1] = yl0[length-2] + dy[length-2]\n xr0[length-1] = xr0[length-2] + dx[length-2]\n yr0[length-1] = yr0[length-2] + dy[length-2]\n xl[0] = xl0[0]\n yl[0] = yl0[0]\n xl[length-1] = xl0[length-1]\n yl[length-1] = yl0[length-1]\n xr[0] = xr0[0]\n yr[0] = yr0[0]\n xr[length-1] = xr0[length-1]\n yr[length-1] = yr0[length-1]\n for i in range(1, length-1):\n a = np.array([[dy[i-1], -dx[i-1]], [dy[i], -dx[i]]])\n bl = np.array([dy[i-1]*xl0[i-1]-dx[i-1]*yl0[i-1], dy[i]*xl0[i]-dx[i]*yl0[i]])\n br = np.array([dy[i-1]*xr0[i-1]-dx[i-1]*yr0[i-1], dy[i]*xr0[i]-dx[i]*yr0[i]])\n theta = (dx[i-1]*dx[i]+dy[i-1]*dy[i])/(dx[i-1]**2+dy[i-1]**2)**0.5/(dx[i]**2+dy[i]**2)**0.5\n if theta > 1 - 1e-10:\n xl[i] = xl0[i]\n yl[i] = yl0[i]\n xr[i] = xr0[i]\n yr[i] = yr0[i]\n else:\n pl = np.linalg.solve(a, bl)\n xl[i] = pl[0]\n yl[i] = pl[1]\n pr = np.linalg.solve(a, br)\n xr[i] = pr[0]\n yr[i] = pr[1]\n offsetx[:, 0], offsetx[:, 1] = xl, xr\n offsety[:, 0], offsety[:, 1] = yl, yr\n return offsetx, offsety","def rwgraph_analyze2(input=(None)):\r\n\r\n\r\n #set up graph and degree distribution arrays\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n Nt=100\r\n M=20000\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n\r\n #set inital conditions and D\r\n y0=np.zeros(n,dtype=int)\r\n y0[j]=200\r\n D=1\r\n #define time for odi Int\r\n t=np.arange(Nt+1,dtype=int)\r\n #set up operators\r\n A = nx.adjacency_matrix(G)\r\n Q = A.toarray().sum(axis=1)\r\n L=np.diag(Q)-A.toarray()\r\n Q_inv=1/Q\r\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\r\n Ls_tran=np.transpose(Ls)\r\n\r\n #convert to sparse operators and include diffusion\r\n L_spar = scipy.sparse.csr_matrix(-D*L)\r\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\r\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\r\n A=nx.adjacency_matrix(G)\r\n L=-D*(scipy.sparse.diags(degree_arr)-A)\r\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\r\n\r\n #define operators\r\n def Lap(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\r\n def Lap_Ls(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\r\n def Lap_Ls_tran(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\r\n\r\n #solutions of different operators\r\n solL=scipy.integrate.odeint(Lap,y0,t)\r\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\r\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\r\n\r\n\r\n #finds eigen values and vectors and puts them into order\r\n def eigen(L):\r\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\r\n idx = eigen_values.argsort()[::-1]\r\n eigen_values = eigen_values[idx]\r\n eigen_vectors = eigen_vectors[:,idx]\r\n return eigen_values,eigen_vectors\r\n\r\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\r\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\r\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\r\n eigen_values_L,eigen_vectors_L=eigen(L)\r\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\r\n\r\n ### could have eigs here as didn't end up using all eigenvalues ####\r\n #eigen values graph\r\n n0=len(eigen_values_L)\r\n eig_nums=np.arange(n0)\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\"x\" ,label='L , D=0.36')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\"|\",label='LS , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\"+\" ,label='L , D=1')\r\n plt.legend(loc=\"lower left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.xlabel('eigen value number')\r\n plt.ylabel('eigenvalue')\r\n plt.title(\"Eigenvlaues of Laplacian Matrixs\")\r\n plt.show()\r\n\r\n print(\"4 biggest eigenvalues for each operater\")\r\n print('L=',eigen_values_L[0:4])\r\n print('Ls=',eigen_values_LS[0:4])\r\n print('Ls_tran=',eigen_values_LS_tran[0:4])\r\n #prints 4 biggest eigen values\r\n #counts node distrubtion by creating dictionary\r\n def result_count(sol,Nt,G):\r\n \"\"\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\"\"\"\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq\r\n\r\n #frequency count of solutions\r\n dict_freq=result_count(solL,Nt,G)\r\n dict_freq2=result_count(solLs,Nt,G)\r\n dict_freq3=result_count(solLs_tran,Nt,G)\r\n\r\n #random walk data\r\n X=rwgraph(G,j,20000,100)\r\n Listnodes7=[]\r\n for i in range(20000):\r\n Listnodes7.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,200,100)\r\n Listnodes8=[]\r\n for i in range(200):\r\n Listnodes8.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,50000,5000)\r\n Listnodes9=[]\r\n for i in range(50000):\r\n Listnodes9.append(G.degree(X[i,5000]))\r\n listfreq7=CountFrequency(Listnodes7)\r\n listfreq8=CountFrequency(Listnodes8)\r\n listfreq9=CountFrequency(Listnodes9)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n z2=[]\r\n z3=[]\r\n z1=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n z_deg1=[]\r\n for i in listfreq7:\r\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq8:\r\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n for i in listfreq8:\r\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\r\n z_deg1.append(i)\r\n #operator solutions compared to node degree frequency\r\n z4,z5,z6=[],[],[]\r\n z_deg4,z_deg5,z_deg6=[],[],[]\r\n for i in dict_freq:\r\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\r\n z_deg4.append(i)\r\n for i in dict_freq2:\r\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\r\n z_deg5.append(i)\r\n for i in dict_freq3:\r\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\r\n z_deg6.append(i)\r\n\r\n plt.figure(figsize=(15, 10))\r\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\r\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\r\n plt.scatter(z_deg4, z4,label='L, Nt=100')\r\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\r\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\r\n plt.ylim((-0.005,0.020))\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n\r\n #code to produce final graph\r\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\r\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\r\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\r\n tarray = np.linspace(0,5,Nt+1)\r\n plt.figure(figsize=(12, 6))\r\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\r\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\r\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\r\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\r\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\r\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\r\n plt.xlabel('time')\r\n plt.ylabel('representive frequency')\r\n plt.legend()\r\n plt.title(\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\")\r\n plt.show()\r\n return None #modify as needed\r","def dndt2(jx, iy, h, n, u, v, dx, dy) :\n p5 = np.float32(0.5)\n depth_jm0im0 = h[jx, iy ]+n[jx, iy]\n depth_jp1im0 = h[jx+1,iy] +n[jx+1,iy]\n depth_jm1im0 = h[jx-1,iy] +n[jx-1,iy]\n depth_jm0ip1 = h[jx, iy+1]+n[jx, iy+1]\n depth_jm0im1 = h[jx, iy-1]+n[jx, iy-1]\n \n hx_jp1 = u[jx+1,iy]*(depth_jm0im0 + depth_jp1im0)*p5\n hx_jm0 = u[jx, iy]*(depth_jm1im0 + depth_jm0im0)*p5\n \n \n hy_ip1 = v[jx,iy+1]*(depth_jm0im0 + depth_jm0ip1)*p5\n hy_im0 = v[jx,iy ]*(depth_jm0im1 + depth_jm0im0)*p5\n \n # assume u and v are zero on edge\n dhx = (hx_jp1-hx_jm0)/dx#[jx,iy]\n dhy = (hy_ip1-hy_im0)/dy#[jx,iy]\n\n \n return ( -dhx-dhy )","def nnl_combine(r, s2, N=10, debug=False, alpha=0.05, rang=5, rang_N=1000, EPS=1E-15):\n\n def est(rhat, delta2):\n\n # .maximum(,) operates element wise\n rhat = np.sum(r / np.maximum(s2 + delta2, EPS)) / \\\n (np.sum(1.0 / np.maximum(s2 + delta2, EPS)))\n delta2 = np.sum(((r - rhat)**2 - s2) / np.maximum(s2 + delta2, EPS)**2) / \\\n np.sum(1.0 / np.maximum(s2 + delta2, EPS)**2)\n\n # protection\n rhat = np.abs(rhat)\n delta2 = np.abs(delta2)\n\n return rhat, delta2\n\n # Iterate\n rhat = np.mean(r)\n delta2 = np.var(r)\n for i in range(N):\n rhat, delta2 = est(rhat,delta2)\n if debug:\n _2logL = nnl_2logL(rhat=rhat, delta2=delta2, r=r, s2=s2)\n print(__name__ + f'.nnl_combine: iter {i}: rhat = {rhat:0.3}, delta2 = {delta2:0.3} | 2lnL = {_2logL:0.5e}')\n \n # ....................................................................\n # Profiled log-likelihood ratio for the uncertainties\n\n x2LL_hat = nnl_2logL(rhat=rhat, delta2=delta2, r=r, s2=s2)\n \n ### RHAT\n theta_val = np.linspace(rhat/rang, rhat*rang, rang_N)\n x2LL = np.zeros(len(theta_val))\n for i in range(len(x2LL)):\n x2LL[i] = nnl_2logL(rhat=theta_val[i], delta2=delta2, r=r, s2=s2)\n\n ind = chi2range(x2LL=x2LL, x2LL_hat=x2LL_hat, alpha=alpha)\n \n if len(ind) >= 2:\n rhat_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\n else:\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on rhat, setting zero', 'red')\n rhat_err = np.array([0,0])\n \n # --------------------------------------------------------------------\n ### DELTA2\n theta_val = np.linspace(delta2/rang, delta2*rang, rang_N)\n x2LL = np.zeros(len(theta_val))\n for i in range(len(x2LL)):\n x2LL[i] = nnl_2logL(rhat=rhat, delta2=theta_val[i], r=r, s2=s2)\n\n ind = chi2range(x2LL=x2LL, x2LL_hat=x2LL_hat, alpha=alpha)\n\n if len(ind) >= 2:\n delta2_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\n else:\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on delta2, setting zero', 'red')\n delta2_err = np.array([0,0])\n\n # Check for NaN\n if np.isnan(rhat):\n cprint(__name__ + f'.nnl_combine: WARNING: rhat is NaN, setting zero', 'red')\n if np.isnan(delta2):\n cprint(__name__ + f'.nnl_combine: WARNING: delta2 is NaN, setting zero', 'red')\n\n return rhat, delta2, rhat_err, delta2_err","def lambert1(lat, lon, orglat, orglon, iopt):\n\n radearth = 6378.135 # equitorial earth radius\n f = 298.26 # 1/f wgs 72 model values\n dtr = 3.141592654 / 180.0\n\n lon1 = mod(lon + 720.0, 360.0)\n orglon1 = mod(orglon + 720.0, 360.0)\n #\n # compute local radius of the earth at center of image\n #\n # eradearth = 6378.0 # use fixed nominal value\n eradearth = radearth\n if iopt == 2: # local radius\n era = 1.0 - 1.0 / f\n eradearth = (\n radearth\n * era\n / sqrt(era * era * cos(orglat * dtr) ** 2 + sin(orglat * dtr) ** 2)\n )\n\n denom = (\n 1.0\n + sin(orglat * dtr) * sin(lat * dtr)\n + cos(orglat * dtr) * cos(lat * dtr) * cos(dtr * (lon1 - orglon1))\n )\n if np.all(denom > 0.0):\n ak = sqrt(2.0 / denom)\n else:\n print(\"*** division error in lambert1 routine ***\")\n ak = 1.0\n\n x = ak * cos(lat * dtr) * sin(dtr * (lon1 - orglon1))\n y = ak * (\n cos(dtr * orglat) * sin(dtr * lat)\n - sin(dtr * orglat) * cos(dtr * lat) * cos(dtr * (lon1 - orglon1))\n )\n x = x * eradearth\n y = y * eradearth\n return x, y","def _maping(x,y,l,a):\n newx = (x**2 *(l* ((x**2 + y**2)**(a/2) - 1) + 2) - l * y**2 *((x**2 + y**2)**(a/2) - 1))/(x**2 + y**2) \n newy = (2 * x* y *(l* ((x**2 + y**2)**(a/2) - 1) + 1))/(x**2 + y**2)\n return newx, newy","def potentialSolver4(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def nodalLaplacian(self):\n if getattr(self, '_nodalLaplacian', None) is None:\n print('Warning: Laplacian has not been tested rigorously.')\n # The number of cell centers in each direction\n n = self.vnC\n # Compute divergence operator on faces\n if(self.dim == 1):\n D1 = sdiag(1./self.hx) * ddx(self.nCx)\n L = - D1.T*D1\n elif(self.dim == 2):\n D1 = sdiag(1./self.hx) * ddx(n[0])\n D2 = sdiag(1./self.hy) * ddx(n[1])\n L1 = sp.kron(speye(n[1]+1), - D1.T * D1)\n L2 = sp.kron(- D2.T * D2, speye(n[0]+1))\n L = L1 + L2\n elif(self.dim == 3):\n D1 = sdiag(1./self.hx) * ddx(n[0])\n D2 = sdiag(1./self.hy) * ddx(n[1])\n D3 = sdiag(1./self.hz) * ddx(n[2])\n L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)\n L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))\n L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))\n L = L1 + L2 + L3\n self._nodalLaplacian = L\n return self._nodalLaplacian","def pontos(self):\n \n self.sc = 1. \n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\n self.px_index = len(self.x)\n #self.py_index = len(self.x)/2\n\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n \n self.x = self.x[::-1]\n self.y = -self.y[::-1] \n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\n\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \n \n self.coordi = np.array(self.coord)\n \n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \n self.cgi = np.array(self.cg)\n \n self.thi = 0. + self.dth \n self.th = float(self.thi) \n \n self.coordnav(self.dx,self.dy,self.dth)","def HOG(img, x, y):\n #TODO: write a HOG descriptor here\n des=[]\n row=0\n sub_image = img[x-8:x+8,y-8:y+8]\n while row < len(sub_image):\n col=0\n while col < len(sub_image[0]):\n temp_vector = [0 for i in range(8)]\n new_subimage = sub_image[row:row+4,col:col+4]\n x_gradient = cv2.Sobel(new_subimage,ddepth=-1,dx=1,dy=0)\n y_gradient = cv2.Sobel(new_subimage,ddepth=-1,dx=0,dy=1)\n theta = np.empty([x_gradient.shape[0],x_gradient.shape[1]])\n for i in range(len(x_gradient)):\n for j in range(len(x_gradient[0])):\n if x_gradient[i,j] == 0:\n theta[i,j] = 90\n else:\n theta[i,j] = np.arctan(y_gradient[i,j]/x_gradient[i,j])*(180/np.pi)\n theta_iter = theta.flatten() #To avoid nested for loops for 4x4 theta\n for i in range(len(theta_iter)):\n if theta_iter[i] < 45:\n temp_vector[0]=temp_vector[0]+1\n elif theta_iter[i] >= 45 and theta_iter[i] < 90:\n temp_vector[1]=temp_vector[1]+1\n elif theta_iter[i] >= 90 and theta_iter[i] < 135:\n temp_vector[2]=temp_vector[2]+1\n elif theta_iter[i] >= 135 and theta_iter[i] < 180:\n temp_vector[3]=temp_vector[3]+1\n elif theta_iter[i] >= 180 and theta_iter[i] < 225:\n temp_vector[4]=temp_vector[4]+1\n elif theta_iter[i] >= 225 and theta_iter[i] < 270:\n temp_vector[5]=temp_vector[5]+1\n elif theta_iter[i] >= 270 and theta_iter[i] < 315:\n temp_vector[6]=temp_vector[6]+1\n elif theta_iter[i] >= 315 and theta_iter[i] < 360:\n temp_vector[7]=temp_vector[7]+1\n des.extend(temp_vector)\n col=col+4\n row=row+4\n return des","def __init__(self, lattice, lp, xytup=None, NL=None, KL=None, PVx=None, PVy=None,\n BL_nm=None, NL_nm=None, KL_nm=None,\n Omg=None, OmK=None, matrix=None, eigval=None, eigvect=None, eps=1e-8, overwrite=False):\n # xytup is a tuple of inner points, outer points. Define self.xy to be all sites, including immobile ones\n self.lattice = lattice\n # lp contains Omg, Omk, als. With weights, Omg = 1.5, otherwise Omg = 1.0\n # Omk = k_m l^2 / I omega -> 0.86 in original experiments\n # aoverl = 0.0305/.038\n self.lp = lp\n self.inner_indices = None\n self.outer_indices = None\n\n if xytup is None:\n # Create self.xy and self.xy_inner\n self.xy = lattice.xy\n if 'roi' in self.lp:\n self.xy_inner = le.pts_in_polygon(self.xy, self.lp['roi'])\n else:\n # get boundary of the lattice and denote these particles as the outer particles\n # boundary = le.extract_boundary(self.xy, self.lattice.NL, self.lattice.KL, self.lattice.BL,\n # check=False)\n boundary = self.lattice.get_boundary()\n if boundary is None:\n self.xy_inner = self.xy\n elif isinstance(boundary, tuple):\n # There are multiple boundaries. Exclude all of them from inner_indices\n inners = np.arange(len(self.xy))\n outers = []\n for bndy in boundary:\n inners = np.setdiff1d(inners, np.array(bndy))\n outers.append(bndy)\n\n self.inner_indices = np.hstack(inners)\n self.outer_indices = np.hstack(outers)\n self.xy_inner = self.xy[self.inner_indices]\n else:\n self.inner_indices = np.setdiff1d(np.arange(len(self.xy)), np.array(boundary))\n self.outer_indices = np.array(boundary)\n self.xy_inner = self.xy[self.inner_indices]\n else:\n self.xy = xytup[1]\n self.xy_inner = xytup[0]\n\n if NL is not None and KL is not None:\n self.NL = NL\n self.KL = KL\n # determine if shortrange or longrange or intermediate interaction_range from supplied NL\n # if lp['intrange'] == 1:\n # nl_meshfn_exten = '_shortrange'\n if lp['intrange'] > 0:\n nl_meshfn_exten = '_intrange{0:04d}'.format(mglat.lp['interaction_range'])\n else:\n nl_meshfn_exten = ''\n # Get PVxy if not supplied\n if PVx is not None and PVy is not None:\n self.PVx, self.PVy = PVx, PVy\n else:\n if (KL > -eps).all():\n self.PVx = np.zeros_like(NL, dtype=float)\n self.PVy = np.zeros_like(NL, dtype=float)\n else:\n raise RuntimeError('periodic KL is supplied, but PVx and PVy are not supplied')\n else:\n self.NL, self.KL, self.PVx, self.PVy, nl_meshfn_exten = mgfns.create_NL_KL_pv(self)\n\n # print 'self.xy_inner = ', np.shape(self.xy_inner)\n # print 'self.xy = ', np.shape(self.xy)\n if self.inner_indices is None or self.outer_indices is None:\n self.outer_indices, self.inner_indices, self.total2inner = self.outer_inner(self.xy, self.xy_inner)\n\n # Add lattice properties to gyro_lattice_properties, by convention, but don't overwrite params\n for key in self.lattice.lp:\n if key not in self.lp:\n self.lp[key] = self.lattice.lp[key]\n\n ########################################################################\n self.lp['meshfn_exten'] = '_magnetic' + nl_meshfn_exten + '_aol' + sf.float2pstr(self.lp['aoverl'])\n # For magnetic class, OmK is bond dependent: OmK = 3 mu_0 M^2/ (pi a^5) for each bond\n if self.lp['Omk'] != -1.0:\n self.lp['meshfn_exten'] += '_Omk' + sf.float2pstr(self.lp['Omk'])\n\n # Build OmK array for couplings\n self.OmK, lp_Omk, omk_meshfn_exten = mgfns.build_OmK(self, self.lp, None)\n\n # Form Omg\n if Omg == 'auto' or Omg is None:\n if 'Omg' in self.lp:\n self.Omg = self.lp['Omg'] * np.ones_like(self.xy_inner[:, 0])\n else:\n print 'giving Omg the default value of -1s...'\n self.Omg = -1.0 * np.ones_like(self.xy_inner[:, 0])\n if self.lp['Omg'] != -1.0:\n self.lp['meshfn_exten'] += '_Omg' + sf.float2pstr(self.lp['Omg'])\n else:\n self.Omg = Omg\n if 'Omg' in self.lp:\n if (self.Omg != self.lp['Omg'] * np.ones(np.shape(self.xy_inner)[0])).any():\n self.lp['meshfn_exten'] += '_Omgspec'\n self.lp['Omg'] = -5000\n else:\n # Check if the values of all elements are identical\n kinds = np.nonzero(self.Omg)\n if len(kinds[0]) > 0:\n # There are some nonzero elements in Omg. Check if all the same\n value = self.Omg[kinds[0]]\n if (Omg[kinds] == value).all():\n self.lp['Omg'] = value\n else:\n self.lp['Omg'] = -5000\n else:\n self.lp['Omg'] = 0.0\n if 'ABDelta' in self.lp:\n if np.abs(self.lp['ABDelta']) > eps:\n self.lp['meshfn_exten'] += '_ABd{0:0.3f}'.format(self.lp['ABDelta']).replace('.', 'p').replace('-', 'n')\n else:\n self.lp['ABDelta'] = 0.\n\n # First check for gaussian disorder\n if 'V0_pin_gauss' in self.lp and 'V0_spring_gauss' in self.lp:\n if abs(self.lp['V0_pin_gauss']) > eps or (self.lp['V0_spring_gauss']) > eps:\n self.lp['dcdisorder'] = True\n self.lp['meshfn_exten'] += '_pinV' + sf.float2pstr(self.lp['V0_pin_gauss'])\n self.lp['meshfn_exten'] += '_sprV' + sf.float2pstr(self.lp['V0_spring_gauss'])\n if 'pinconf' not in self.lp:\n self.lp['pinconf'] = 0\n elif self.lp['pinconf'] > 0:\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\n else:\n self.lp['dcdisorder'] = False\n\n # If no gaussian disorder check for flat disorder\n if 'V0_pin_flat' in self.lp and 'V0_spring_flat' in self.lp and not self.lp['dcdisorder']:\n if abs(self.lp['V0_pin_flat']) > eps or (self.lp['V0_spring_flat']) > eps:\n self.lp['dcdisorder'] = True\n self.lp['meshfn_exten'] += '_pinVflat' + sf.float2pstr(self.lp['V0_pin_flat'])\n self.lp['meshfn_exten'] += '_sprVflat' + sf.float2pstr(self.lp['V0_spring_flat'])\n if 'pinconf' not in self.lp:\n self.lp['pinconf'] = 0\n elif self.lp['pinconf'] > 0:\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\n else:\n self.lp['dcdisorder'] = False\n\n # If neither gaussian nor flat, input no disorder\n if not self.lp['dcdisorder']:\n self.lp['V0_pin_gauss'] = 0.\n self.lp['V0_spring_gauss'] = 0.\n self.lp['V0_pin_flat'] = 0.\n self.lp['V0_spring_flat'] = 0.\n self.lp['pinconf'] = 0\n self.lp['dcdisorder'] = False\n\n vpin_has_gaussian = self.lp['V0_pin_gauss'] > eps or self.lp['V0_spring_gauss'] > eps\n vpin_has_flat = self.lp['V0_pin_flat'] > eps or self.lp['V0_spring_flat'] > eps\n if abs(self.lp['ABDelta']) > eps or vpin_has_gaussian or vpin_has_flat:\n # In order to load the random (V0) or alternating (AB) pinning sites, look for a txt file with the pinnings\n # that also has specifications in its meshfn exten, but IGNORE other parts of meshfnexten, if they exist.\n # Form abbreviated meshfn exten\n pinmfe = self.get_pinmeshfn_exten()\n\n print 'Trying to load offset/disorder to pinning frequencies: '\n print dio.prepdir(self.lp['meshfn']) + pinmfe\n # Attempt to load from file\n if not overwrite:\n try:\n self.load_pinning(meshfn=self.lp['meshfn'])\n # self.Omg = np.loadtxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt')\n # raise RuntimeError('This means an erronous Omg was saved --where was it saved?')\n print 'Loaded ABDelta and/or dcdisordered pinning frequencies.'\n define_Omg_now = False\n except IOError:\n define_Omg_now = True\n else:\n define_Omg_now = True\n\n if define_Omg_now:\n print 'Could not load ABDelta and/or dcdisordered pinning frequencies, defining them here...'\n # Make Omg from scratch\n if abs(self.lp['ABDelta']) > eps:\n asites, bsites = glatfns.ascribe_absites(self.lattice)\n self.Omg[asites[self.inner_indices]] += self.lp['ABDelta']\n self.Omg[bsites[self.inner_indices]] -= self.lp['ABDelta']\n if vpin_has_flat or vpin_has_gaussian:\n self.add_dcdisorder()\n\n # Save non-standard Omg\n if 'save_pinning_to_hdf5' in self.lp:\n if self.lp['save_pinning_to_hdf5']:\n force_hdf5pin = True\n else:\n force_hdf5pin = False\n else:\n force_hdf5pin = False\n self.save_Omg(infodir=self.lp['meshfn'], histogram=False, force_hdf5=force_hdf5pin, overwrite=overwrite)\n # self.plot_Omg()\n # np.savetxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt', self.Omg)\n # self.plot_Omg()\n\n ########################################################################\n\n # Non magnetic --> nm: taken from lat.NL, lat.KL, these are the inner particles (xy_in) connectivity M x M\n if BL_nm is not None:\n self.BL_nm = BL_nm\n if NL_nm is not None and KL_nm is not None:\n self.NL_nm = NL_nm\n self.KL_nm = KL_nm\n else:\n self.NL_nm, self.KL_nm = le.BL2NLandKL(self.BL_nm)\n else:\n # Remove self.outer_indices from lattice, and use resulting BL to get NL_nm and KL_nm\n # print 'magnetic_gyro_lattice_class: BL = ', self.lattice.BL\n # print 'magnetic_gyro_lattice_class: keep = ', self.inner_indices\n xytmp, self.NL_nm, self.KL_nm, self.BL_nm, self.PVxydict = \\\n le.remove_pts(self.inner_indices, self.lattice.xy, self.lattice.BL, PVxydict=self.lattice.PVxydict,\n PV=self.lattice.PV)\n\n # print 'lp[meshfn_exten] = ', self.lp['meshfn_exten']\n # Get inner boundary\n self.inner_boundary = mgfns.calc_boundary_inner(self, check=False)\n # Use dh to get indices of xy_inner that are on the 'inner' network's boundary\n # Note match_values returns inds such that vals[inds] ~= arr\n if self.inner_boundary is not None:\n self.inner_boundary_inner = dh.match_values(self.inner_boundary, self.inner_indices)\n else:\n self.inner_boundary_inner = None\n # print 'self.inner_indices = ', self.inner_indices\n # print 'self.inner_boundary = ', self.inner_boundary\n # print 'self.inner_boundary_inner = ', self.inner_boundary_inner\n # sys.exit()\n\n # Other attributes that can be calculated\n self.matrix = matrix\n self.eigval = eigval\n self.eigvect = eigvect\n self.localization = None\n self.edge_localization = None\n self.ipr = None","def lcn(x,ishape,size=9):\n # Function borrowed from bengioe_util\n inshape = (x.shape[0],1,ishape[0],ishape[1])\n p = x.reshape(inshape)\n #p = (p-TT.mean(p))/T.std(p)\n g = gaussian(size,1.591/size)\n g/=g.sum()\n g = numpy.float32(g.reshape((1,1,size,size)))\n mean = TT.nnet.conv.conv2d(p,TT.constant(g),\n None,\n (1,1,size,size),\n 'full').reshape(\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\n mean = mean[:,:,\n size/2:ishape[0]+size/2,\n size/2:ishape[1]+size/2]\n v = (p - mean)#.dimshuffle('x','x',0,1)\n var = TT.nnet.conv.conv2d(TT.sqr(v),TT.constant(g),\n None,\n (1,1,size,size),\n 'full').reshape(\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\n var = var[:,:,\n size/2:ishape[0]+size/2,\n size/2:ishape[1]+size/2]\n std = TT.sqrt(var)\n std_mean = TT.mean(TT.mean(std,axis=3),axis=2).dimshuffle(0,1,'x','x')\n out = v / TT.maximum(std,std_mean)\n return (out + 2.5 )/5# - out.min()","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 ldfe(n=3):\n\n # We will use the following coordinate system.\n #\n # | z, top\n # |\n # |\n # |\n # o------- x, right\n # /\n # /\n # /\n # / y, front\n\n # Cube inside the octant that touches the sphere at\n a = 1 / sqrt(3)\n\n # We have three important faces of the cube.\n # Start with the front face and refine it in N segments.\n x = linspace(0, a, n + 1)\n z = linspace(0, a, n + 1)\n\n # Then delta Omega_ij = [x_i,x_i+1] x [z_j,z_j+1]\n # Now go through every cell.\n points = zeros((1 * 1 * 4 * n * n, 3)) # 1/3 of the octants\n weights = zeros(1 * 1 * 4 * n * n)\n square = zeros(1 * 1 * 4 * n * n)\n counter = 0\n rhos0 = 0.1 * ones(4)\n for i in range(n):\n for j in range(n):\n x0, x1, z0, z1 = x[i], x[i + 1], z[j], z[j + 1]\n\n omegas = computeomegas(x0, x1, z0, z1)\n areas = computeareas(omegas, x0, x1, z0, z1)\n print(\"\\n\\nOptimiztation for:\")\n print(\"Domain:\")\n print([x0, x1, z0, z1])\n\n rhos = optimizeposition_leastsquares(areas, omegas, x0, x1, z0, z1,\n rhos0)\n rhos0 = rhos # take the optimal parameter of this cell as the starting value for the optimizer in the next cell\n dummy = rand()\n for k in range(4):\n points[counter, :] = project(omegas[k](rhos[k]))\n weights[counter] = areas[k]\n square[counter] = dummy\n counter += 1\n scatterplot(points, weights, square)\n return points, weights","def comprehensiveLOOEvaluation(directory=defaultDirectory(), \n pruneGlobal = True, numLayers = 2, \n numNodesPerLayer = 200, randSeed = 1,\n trainPer = .6, valPer = .25, testPer = 0.15,\n totalPer = 1, batchSize = 64,\n numEpochs = 1000, learningRate = 0.001, \n l2Reg = 0.0001, modelFilePrefix = '',\n useGRU = False,\n dropoutI = 0.2, dropoutH = 0.2, trainMode = 'continue',\n randSeed2 = None, center = False, prependMean = False):\n \n trainModes = ['continue', 'overwrite', 'continue-each']\n \n if trainMode.lower() not in trainModes:\n raise ValueError(\"Parameter 'trainMode' must be either 'continue', 'overwrite', or 'continue-each'.\")\n \n np.random.seed(randSeed) #control permutation of data\n # prune global coordinate data?\n if pruneGlobal:\n pruneRange = range(0, 18)\n else:\n pruneRange = None\n structs = loadDataset(directory=directory, LOUO=True, \n delRange=pruneRange, trainPer=trainPer,\n valPer = valPer, testPer=testPer, totalPer=totalPer,\n preExt = '.left', prune=True)\n\n u=0\n losses = []\n accs = []\n balAccs = []\n finAccs = []\n cmEpochs = []\n outDirectory = nameModelFile('', useGRU, numLayers, numNodesPerLayer, randSeed,\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\n center, prependMean)\n if not os.path.isdir(outDirectory):\n os.mkdir(outDirectory)\n if randSeed2 is not None: #control randomization of training (for Keras at least)\n np.random.seed(randSeed2)\n for struct in structs:\n modelFile = modelFilePrefix + 'LOU-' + str(u)\n modelFile = nameModelFile(modelFile, useGRU, numLayers, numNodesPerLayer, randSeed,\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\n center, prependMean)\n u += 1\n if (os.path.isfile(outDirectory + '\\\\' + 'Keras' + modelFile + '.json') \n and os.path.isfile(outDirectory + '\\\\' + 'Keras' + modelFile + '_Weights.h5')):\n #if we have already trained for leaving out this user\n if trainMode == 'continue': #continue until each user has a model\n trainMode2 = 'skip' \n elif trainMode == 'continue-each': # continue training previous models\n trainMode2 = 'continue'\n else:\n trainMode2 = 'overwrite'\n else:\n trainMode2 = trainMode\n\n if center:\n \"\"\"\n Center the labeled markers on their mean. \n \"\"\"\n from Postures import centerData\n struct = list(struct)\n labeledMarkerData = struct[0][:,:,18:].reshape((-1, 11, 3))\n labeledMarkerData = centerData(labeledMarkerData, True, prependMean).reshape((struct[0].shape[0], struct[0].shape[1], -1))\n struct[0] = np.concatenate([struct[0][:,:,0:18], labeledMarkerData], axis = 2)\n if prependMean:\n struct[8] += 3\n\n\n cmEpoch, loss, acc, balAcc, finAcc = trainGestureRNN(numLayers=numLayers, numNodesPerLayer=numNodesPerLayer,\n useGRU=useGRU, batchSize=batchSize, \n numEpochs = numEpochs, learningRate=learningRate,\n l1Reg=0, l2Reg = l2Reg, dropoutI=dropoutI, dropoutH=dropoutH,\n sequences = struct[0], classes = struct[1],\n trainRange = struct[2], valRange = struct[3],\n testRange = struct[4], numClasses = struct[5],\n numObservations = struct[6], numSequences = struct[7],\n numFeatures = struct[8],\n modelFile=modelFile, \n outDirectory=outDirectory, trainMode=trainMode2,\n callbacks = [EarlyStopping(patience=20)])\n #catch our breath.... Really, give the user a chance to insert Ctrl-C\n time.sleep(2)\n losses += [loss]\n accs += [acc]\n balAccs += [balAcc]\n finAccs += [finAcc]\n cmEpochs += [cmEpoch]\n losses = np.asarray(losses)\n accs = np.asarray(accs)*100\n balAccs = np.asarray(balAccs)*100\n finAccs = np.asarray(finAccs)*100\n trainPer, valPer, _, _ = normalizePercentages(trainPer, valPer, 0, 1)\n sys.stdout.write('\\n')\n sys.stdout.write('Leave One User Out Evaluation\\nTest Results for ' + str(numLayers) + '-Layer, ' \n + str(numNodesPerLayer) + ' Nodes-Per-Layer ' + ('GRU' if useGRU else 'LSTM') + ' Networks\\n'\n + 'Trained with ' + (\"%0.2f\" % (dropoutI*100)) + '% Input Dropout, '\n + (\"%0.2f\" % (dropoutH*100)) + '% Hidden Dropout, and ' + str(l2Reg) + ' L2 Regularization\\n'\n + str(numEpochs) + ' Maximum Epochs at ' + (\"%0.2f\" % trainPer) + '/' + (\"%0.2f\" % valPer) + ' Training/Validation Split\\n')\n sys.stdout.write('\\n')\n sys.stdout.write('Loss: ' + str(np.mean(losses)) + ' +/- ' + str(np.std(losses)) +'\\n')\n sys.stdout.write('25%, 50%, 75% Quartile Loss: ' + str(np.percentile(losses, 25))\n + ', ' + str(np.median(losses)) \n + ', ' + str(np.percentile(losses, 75)) +'\\n')\n sys.stdout.write('\\n')\n sys.stdout.write('Accuracy: ' + str(np.mean(accs)) + ' +/- ' + str(np.std(accs)) +'\\n')\n sys.stdout.write('25%, 50%, 75% Quartile Accuracy: ' + str(np.percentile(accs, 25))\n + ', ' + str(np.median(accs)) \n + ', ' + str(np.percentile(accs, 75)) +'\\n')\n sys.stdout.write('\\n')\n sys.stdout.write('Balanced Accuracy: ' + str(np.mean(balAccs)) + ' +/- ' + str(np.std(balAccs)) +'\\n')\n sys.stdout.write('25%, 50%, 75% Quartile Balanced Accuracy: ' + str(np.percentile(balAccs, 25))\n + ', ' + str(np.median(balAccs))\n + ', ' + str(np.percentile(balAccs, 75)) +'\\n')\n sys.stdout.write('\\n')\n sys.stdout.write('Final-Frame Accuracy: ' + str(np.mean(finAccs)) + ' +/- ' + str(np.std(finAccs)) +'\\n')\n sys.stdout.write('25%, 50%, 75% Quartile Final-Frame Accuracy: ' + str(np.percentile(finAccs, 25))\n + ', ' + str(np.median(finAccs))\n + ', ' + str(np.percentile(finAccs, 75)) +'\\n')","def do_test_latents(self, Y):\r\n assert not self.likelihood.is_heteroscedastic\r\n N_test = Y.shape[0]\r\n input_dim = self.Z.shape[1]\r\n means = np.zeros((N_test, input_dim))\r\n covars = np.zeros((N_test, input_dim))\r\n\r\n dpsi0 = -0.5 * self.input_dim * self.likelihood.precision\r\n dpsi2 = self.dL_dpsi2[0][None, :, :] # TODO: this may change if we ignore het. likelihoods\r\n V = self.likelihood.precision * Y\r\n\r\n #compute CPsi1V\r\n if self.Cpsi1V is None:\r\n psi1V = np.dot(self.psi1.T, self.likelihood.V)\r\n tmp, _ = linalg.dtrtrs(self._Lm, np.asfortranarray(psi1V), lower=1, trans=0)\r\n tmp, _ = linalg.dpotrs(self.LB, tmp, lower=1)\r\n self.Cpsi1V, _ = linalg.dtrtrs(self._Lm, tmp, lower=1, trans=1)\r\n\r\n dpsi1 = np.dot(self.Cpsi1V, V.T)\r\n\r\n start = np.zeros(self.input_dim * 2)\r\n\r\n for n, dpsi1_n in enumerate(dpsi1.T[:, :, None]):\r\n args = (self.kern, self.Z, dpsi0, dpsi1_n.T, dpsi2)\r\n xopt, fopt, neval, status = SCG(f=latent_cost, gradf=latent_grad, x=start, optargs=args, display=False)\r\n\r\n mu, log_S = xopt.reshape(2, 1, -1)\r\n means[n] = mu[0].copy()\r\n covars[n] = np.exp(log_S[0]).copy()\r\n\r\n return means, covars","def euc_dist(self, squared=True):","def linear_LS_triangulation(u1, P1, u2, P2):\n A = np.zeros((4, 3))\n b = np.zeros((4, 1))\n\n # Create array of triangulated points\n x = np.zeros((3, len(u1)))\n\n # Initialize C matrices\n C1 = np.array(linear_LS_triangulation_C)\n C2 = np.array(linear_LS_triangulation_C)\n\n for i in range(len(u1)):\n # Derivation of matrices A and b:\n # for each camera following equations hold in case of perfect point matches:\n # u.x * (P[2,:] * x) = P[0,:] * x\n # u.y * (P[2,:] * x) = P[1,:] * x\n # and imposing the constraint:\n # x = [x.x, x.y, x.z, 1]^T\n # yields:\n # (u.x * P[2, 0:3] - P[0, 0:3]) * [x.x, x.y, x.z]^T + (u.x * P[2, 3] - P[0, 3]) * 1 = 0\n # (u.y * P[2, 0:3] - P[1, 0:3]) * [x.x, x.y, x.z]^T + (u.y * P[2, 3] - P[1, 3]) * 1 = 0\n # and since we have to do this for 2 cameras, and since we imposed the constraint,\n # we have to solve 4 equations in 3 unknowns (in LS sense).\n #\n # Build C matrices, to construct A and b in a concise way\n C1[:, 2] = u1[i, :]\n C2[:, 2] = u2[i, :]\n\n # Build A matrix:\n # [\n # [ u1.x * P1[2,0] - P1[0,0], u1.x * P1[2,1] - P1[0,1], u1.x * P1[2,2] - P1[0,2] ],\n # [ u1.y * P1[2,0] - P1[1,0], u1.y * P1[2,1] - P1[1,1], u1.y * P1[2,2] - P1[1,2] ],\n # [ u2.x * P2[2,0] - P2[0,0], u2.x * P2[2,1] - P2[0,1], u2.x * P2[2,2] - P2[0,2] ],\n # [ u2.y * P2[2,0] - P2[1,0], u2.y * P2[2,1] - P2[1,1], u2.y * P2[2,2] - P2[1,2] ]\n # ]\n A[0:2, :] = C1.dot(P1[0:3, 0:3]) # C1 * R1\n A[2:4, :] = C2.dot(P2[0:3, 0:3]) # C2 * R2\n\n # Build b vector:\n # [\n # [ -(u1.x * P1[2,3] - P1[0,3]) ],\n # [ -(u1.y * P1[2,3] - P1[1,3]) ],\n # [ -(u2.x * P2[2,3] - P2[0,3]) ],\n # [ -(u2.y * P2[2,3] - P2[1,3]) ]\n # ]\n b[0:2, :] = C1.dot(P1[0:3, 3:4]) # C1 * t1\n b[2:4, :] = C2.dot(P2[0:3, 3:4]) # C2 * t2\n b *= -1\n\n # Solve for x vector\n cv2.solve(A, b, x[:, i:i + 1], cv2.DECOMP_SVD)\n\n return np.transpose(x), np.ones(len(u1), dtype=bool)","def compute_ul_ur(self, dt):\n\n g = self.grid\n # compute the piecewise linear slopes\n # here we define the range cells considered, including 1 ghost cell\n # on each side\n ib = g.ng-1\n ie = g.ng + g.N\n\n u = g.u\n \n # initialize empty arrays\n dc = np.zeros((g.N+2*g.ng))\n dl = np.zeros((g.N+2*g.ng))\n dr = np.zeros((g.N+2*g.ng))\n \n dc[ib:ie+1] = 0.5*(u[ib+1:ie+2] - u[ib-1:ie ])\n dl[ib:ie+1] = u[ib+1:ie+2] - u[ib :ie+1]\n dr[ib:ie+1] = u[ib :ie+1] - u[ib-1:ie ]\n\n # minmod()\n # fabs is the absolute value for real valued inputs\n # where does np.where(condition,if true keep this value, else this)\n # d1 = 2.0*np.where(np.fabs(dl) < np.fabs(dr), dl, dr)\n d1 = np.zeros((len(dl)))\n for i in range(len(dl)):\n if np.fabs(dl[i]) < np.fabs(dr[i]):\n d1[i] = dl[i]\n else:\n d1[i] = dr[i]\n d1 = 2.0*d1\n \n d2 = np.zeros((len(dc)))\n for i in range(len(dc)):\n if np.fabs(dc[i]) < np.fabs(d1[i]):\n d2[i] = dc[i]\n else:\n d2[i] = d1[i] \n \n # d2 = np.where(np.fabs(dc) < np.fabs(d1), dc, d1)\n ldeltau = np.zeros((len(d2)))\n for i in range(len(d2)):\n if dl[i]*dr[i] > 0.0:\n ldeltau[i] = d2[i]\n else:\n ldeltau[i] = 0.0\n # ldeltau = np.where(dl*dr > 0.0, d2, 0.0)\n\n # interface states. \n # Note from hydro_examples:\n # note that there are 1 more interfaces than zones\n ul = np.zeros((g.N+2*g.ng))\n ur = np.zeros((g.N+2*g.ng))\n\n ur[ib:ie+2] = u[ib:ie+2] - \\\n 0.5*(1.0 + u[ib:ie+2]*dt/self.grid.dx)*ldeltau[ib:ie+2]\n\n ul[ib+1:ie+2] = u[ib:ie+1] + \\\n 0.5*(1.0 - u[ib:ie+1]*dt/self.grid.dx)*ldeltau[ib:ie+1]\n\n return ul, ur","def cayley_menger_det_no_linalg(x2, y2, z2, xb2, yb2, zb2):\n xs = x2 + xb2\n ys = y2 + yb2\n zs = z2 + zb2\n buf1 = ys + zs\n buf1 -= xs\n buf2 = x2 * xb2\n buf1 *= buf2 # buf1 has first term, halved\n np.multiply(y2, yb2, out=buf2)\n buf3 = xs + zs\n buf3 -= ys\n buf2 *= buf3 # buf2 has second term\n buf1 += buf2 # buf1 is sum of two terms, halved\n np.multiply(z2, zb2, out=buf3)\n np.add(xs, ys, out=buf2) # reuse buf2\n buf2 -= zs\n buf3 *= buf2 # buf3 has third term\n buf1 += buf3 # buf1 is sum of 3 first terms, halved\n buf1 *= 2\n np.subtract(x2, xb2, out=buf2)\n np.subtract(y2, yb2, out=buf3)\n buf2 *= buf3\n np.subtract(z2, zb2, out=buf3)\n buf2 *= buf3\n buf1 += buf2 # buf1 is sum of 4 first terms\n np.multiply(xs, ys, out=buf3)\n buf3 *= zs\n buf1 -= buf3\n return buf1","def computeNormalAndCurvature():\n radius = 50\n for i,j in pts:\n nb_pts = ti.cast(0, ti.f32)\n accu_0 = ti.cast(0, ti.f32)\n accu_1 = ti.cast(0, ti.f32)\n accu_2 = ti.cast(0, ti.f32)\n accu_3 = ti.cast(0, ti.f32)\n accu_4 = ti.cast(0, ti.f32)\n accu_5 = ti.cast(0, ti.f32)\n accu_6 = ti.cast(0, ti.f32)\n accu_7 = ti.cast(0, ti.f32)\n accu_8 = ti.cast(0, ti.f32)\n z = 0\n for x in range(i-radius, i+radius):\n for y in range(j-radius, j+radius):\n if ti.is_active(block1, [x,y]):\n accu_0 += x * x\n accu_1 += x * y\n accu_2 += x * z\n accu_3 += y * y\n accu_4 += y * z\n accu_5 += z * z\n accu_6 += x\n accu_7 += y\n accu_8 += z\n nb_pts += 1\n accu_0 /= nb_pts\n accu_1 /= nb_pts\n accu_2 /= nb_pts\n accu_3 /= nb_pts\n accu_4 /= nb_pts\n accu_5 /= nb_pts\n accu_6 /= nb_pts\n accu_7 /= nb_pts\n accu_8 /= nb_pts\n cov_mat_0 = accu_0 - accu_6 * accu_6\n cov_mat_1 = accu_1 - accu_6 * accu_7\n cov_mat_2 = accu_2 - accu_6 * accu_8\n cov_mat_4 = accu_3 - accu_7 * accu_7\n cov_mat_5 = accu_4 - accu_7 * accu_8\n cov_mat_8 = accu_5 - accu_8 * accu_8\n cov_mat_3 = cov_mat_1\n cov_mat_6 = cov_mat_2\n cov_mat_7 = cov_mat_5\n\n # Compute eigen value and eigen vector\n # Make sure in [-1, 1]\n scale = ti.max(1.0, ti.abs(cov_mat_0))\n scale = ti.max(scale, ti.abs(cov_mat_1))\n scale = ti.max(scale, ti.abs(cov_mat_2))\n scale = ti.max(scale, ti.abs(cov_mat_3))\n scale = ti.max(scale, ti.abs(cov_mat_4))\n scale = ti.max(scale, ti.abs(cov_mat_5))\n scale = ti.max(scale, ti.abs(cov_mat_6))\n scale = ti.max(scale, ti.abs(cov_mat_7))\n scale = ti.max(scale, ti.abs(cov_mat_8))\n if scale > 1.0:\n cov_mat_0 /= scale\n cov_mat_1 /= scale\n cov_mat_2 /= scale\n cov_mat_3 /= scale\n cov_mat_4 /= scale\n cov_mat_5 /= scale\n cov_mat_6 /= scale\n cov_mat_7 /= scale\n cov_mat_8 /= scale\n \n # Compute roots\n eigen_val_0 = ti.cast(0, ti.f32)\n eigen_val_1 = ti.cast(0, ti.f32)\n eigen_val_2 = ti.cast(0, ti.f32)\n \n c0 = cov_mat_0 * cov_mat_4 * cov_mat_8 \\\n + 2 * cov_mat_3 * cov_mat_6 * cov_mat_7 \\\n - cov_mat_0 * cov_mat_7 * cov_mat_7 \\\n - cov_mat_4 * cov_mat_6 * cov_mat_6 \\\n - cov_mat_8 * cov_mat_3 * cov_mat_3\n c1 = cov_mat_0 * cov_mat_4 \\\n - cov_mat_3 * cov_mat_3 \\\n + cov_mat_0 * cov_mat_8 \\\n - cov_mat_6 * cov_mat_6 \\\n + cov_mat_4 * cov_mat_8 \\\n - cov_mat_7 * cov_mat_7\n c2 = cov_mat_0 + cov_mat_4 + cov_mat_8\n \n if ti.abs(c0) < 0.00001:\n eigen_val_0 = 0\n d = c2 * c2 - 4.0 * c1\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\n d = 0.0\n sd = ti.sqrt(d)\n eigen_val_2 = 0.5 * (c2 + sd)\n eigen_val_1 = 0.5 * (c2 - sd)\n else:\n s_inv3 = ti.cast(1.0 / 3.0, ti.f32)\n s_sqrt3 = ti.sqrt(3.0)\n c2_over_3 = c2 * s_inv3\n a_over_3 = (c1 - c2 * c2_over_3) * s_inv3\n if a_over_3 > 0:\n a_over_3 = 0\n \n half_b = 0.5 * (c0 + c2_over_3 * (2 * c2_over_3 * c2_over_3 - c1))\n q = half_b * half_b + a_over_3 * a_over_3 * a_over_3\n if q > 0:\n q = 0\n \n rho = ti.sqrt(-a_over_3)\n theta = ti.atan2(ti.sqrt(-q), half_b) * s_inv3\n cos_theta = ti.cos(theta)\n sin_theta = ti.sin(theta)\n eigen_val_0 = c2_over_3 + 2 * rho * cos_theta\n eigen_val_1 = c2_over_3 - rho * (cos_theta + s_sqrt3 * sin_theta)\n eigen_val_2 = c2_over_3 - rho * (cos_theta - s_sqrt3 * sin_theta)\n temp_swap = ti.cast(0, ti.f32)\n \n # Sort in increasing order.\n if eigen_val_0 >= eigen_val_1:\n temp_swap = eigen_val_1\n eigen_val_1 = eigen_val_0\n eigen_val_0 = temp_swap\n if eigen_val_1 >= eigen_val_2:\n temp_swap = eigen_val_2\n eigen_val_2 = eigen_val_1\n eigen_val_1 = temp_swap\n if eigen_val_0 >= eigen_val_1:\n temp_swap = eigen_val_1\n eigen_val_1 = eigen_val_0\n eigen_val_0 = temp_swap\n \n if eigen_val_0 <= 0:\n eigen_val_0 = 0\n d = c2 * c2 - 4.0 * c1\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\n d = 0.0\n sd = ti.sqrt(d)\n eigen_val_2 = 0.5 * (c2 + sd)\n eigen_val_1 = 0.5 * (c2 - sd)\n # end of compute roots\n\n eigen_value = eigen_val_1 * scale # eigen value for 2D SDF\n # eigen value for 3D SDF\n #eigen_value = eigen_val_0 * scale\n\n #print(\"eigen_val_0 \", eigen_val_0)\n #print(\"eigen_val_1 \", eigen_val_1)\n #print(\"eigen_val_2 \", eigen_val_2)\n \n # TODO\n #scaledMat.diagonal ().array () -= eigenvalues (0)\n #eigenvector = detail::getLargest3x3Eigenvector<Vector> (scaledMat).vector;\n\n # Compute normal vector (TODO)\n #visual_norm[i,j][0] = eigen_val_0 #eigen_vector[0]\n #visual_norm[i,j][1] = eigen_val_1 #eigen_vector[1]\n #visual_norm[i,j][2] = eigen_val_2 #eigen_vector[2]\n\n # Compute the curvature surface change\n eig_sum = cov_mat_0 + cov_mat_1 + cov_mat_2\n visual_curv[i,j][0] = 0\n if eig_sum != 0:\n visual_curv[i,j][0] = eigen_val_1 # true curvature is: ti.abs(eigen_value / eig_sum)","def calc_refl(velocity, shotloc_x, shotloc_z, layer_idxs):\n solver_dg = pykonal.EikonalSolver(coord_sys=\"cartesian\")\n solver_dg.vv.min_coords = velocity.min_coords\n solver_dg.vv.node_intervals = velocity.node_intervals\n solver_dg.vv.npts = velocity.npts\n solver_dg.vv.values = velocity.values\n\n #shotloc = 2.56 # km\n src_idx = (int((shotloc_x - velocity.min_coords[0])/velocity.node_intervals[0]), int(shotloc_z/velocity.node_intervals[1]), 0)\n solver_dg.tt.values[src_idx] = 0\n solver_dg.unknown[src_idx] = False\n solver_dg.trial.push(*src_idx)\n solver_dg.solve()\n\n solver_ug = pykonal.EikonalSolver(coord_sys=\"cartesian\")\n solver_ug.vv.min_coords = solver_dg.vv.min_coords\n solver_ug.vv.node_intervals = solver_dg.vv.node_intervals\n solver_ug.vv.npts = solver_dg.vv.npts\n solver_ug.vv.values = solver_dg.vv.values\n\n for ix in range(solver_ug.tt.npts[0]):\n #idx = (ix, solver_ug.tt.npts[1]-1, 0)\n idx = (ix, layer_idxs[ix], 0)\n solver_ug.tt.values[idx] = solver_dg.tt.values[idx]\n #print(idx, solver_dg.tt.values[idx])\n solver_ug.unknown[idx] = False\n solver_ug.trial.push(*idx)\n solver_ug.solve()\n \n return solver_ug.tt.values[:,0,0]","def test_lfc_pos_area_below_lcl():\n p = [902.1554, 897.9034, 893.6506, 889.4047, 883.063, 874.6284, 866.2387, 857.887,\n 849.5506, 841.2686, 833.0042, 824.7891, 812.5049, 796.2104, 776.0027, 751.9025,\n 727.9612, 704.1409, 680.4028, 656.7156, 629.077, 597.4286, 565.6315, 533.5961,\n 501.2452, 468.493, 435.2486, 401.4239, 366.9387, 331.7026, 295.6319, 258.6428,\n 220.9178, 182.9384, 144.959, 106.9778, 69.00213] * units.hPa\n t = [-3.039381, -3.703779, -4.15996, -4.562574, -5.131827, -5.856229, -6.568434,\n -7.276881, -7.985013, -8.670911, -8.958063, -7.631381, -6.05927, -5.083627,\n -5.11576, -5.687552, -5.453021, -4.981445, -5.236665, -6.324916, -8.434324,\n -11.58795, -14.99297, -18.45947, -21.92021, -25.40522, -28.914, -32.78637,\n -37.7179, -43.56836, -49.61077, -54.24449, -56.16666, -57.03775, -58.28041,\n -60.86264, -64.21677] * units.degC\n td = [-22.08774, -22.18181, -22.2508, -22.31323, -22.4024, -22.51582, -22.62526,\n -22.72919, -22.82095, -22.86173, -22.49489, -21.66936, -21.67332, -21.94054,\n -23.63561, -27.17466, -31.87395, -38.31725, -44.54717, -46.99218, -43.17544,\n -37.40019, -34.3351, -36.42896, -42.1396, -46.95909, -49.36232, -48.94634,\n -47.90178, -49.97902, -55.02753, -63.06276, -72.53742, -88.81377, -93.54573,\n -92.92464, -91.57479] * units.degC\n prof = parcel_profile(p, t[0], td[0]).to('degC')\n lfc_p, lfc_t = lfc(p, t, td, prof)\n assert_nan(lfc_p, p.units)\n assert_nan(lfc_t, t.units)","def _calc_longitudes(self):\n assert self.tracers\n\n # zp is z unit vector at all times, shape 501 x 3\n zp = np.cross(self.p0_positions, self.p0_velocities)\n zp = zp / np.linalg.norm(zp, axis=-1)[:, None]\n\n # xp and yp are x and y unit vectors\n xp = self.p0_positions\n xp = xp / np.linalg.norm(xp, axis=-1)[:, None]\n yp = np.cross(zp, xp)\n\n # project particle positions into orbital x-y plane\n p1_xp = np.sum(self.p1_positions * xp[:, None, :], axis=-1)\n p1_yp = np.sum(self.p1_positions * yp[:, None, :], axis=-1)\n p2_xp = np.sum(self.p2_positions * xp[:, None, :], axis=-1)\n p2_yp = np.sum(self.p2_positions * yp[:, None, :], axis=-1)\n\n # get longitudes\n p1_phi = np.arctan2(p1_yp, p1_xp)\n p2_phi = np.arctan2(p2_yp, p2_xp)\n\n # add/subtract multiples of 2pi for particles on higher wraps.\n dp = np.vstack((np.zeros((1, self.N1)), np.diff(p1_phi, axis=0)))\n for j in range(self.N1):\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\n for i in range(changes.size):\n p1_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\n dp = np.vstack((np.zeros((1, self.N2)), np.diff(p2_phi, axis=0)))\n for j in range(self.N2):\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\n for i in range(changes.size):\n p2_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\n\n return p1_phi, p2_phi","def weyl_coordinates(U: np.ndarray) -> np.ndarray:\n import scipy.linalg as la\n\n pi2 = np.pi / 2\n pi4 = np.pi / 4\n\n U = U / la.det(U) ** (0.25)\n Up = transform_to_magic_basis(U, reverse=True)\n # We only need the eigenvalues of `M2 = Up.T @ Up` here, not the full diagonalization.\n D = la.eigvals(Up.T @ Up)\n\n d = -np.angle(D) / 2\n d[3] = -d[0] - d[1] - d[2]\n cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)\n\n # Reorder the eigenvalues to get in the Weyl chamber\n cstemp = np.mod(cs, pi2)\n np.minimum(cstemp, pi2 - cstemp, cstemp)\n order = np.argsort(cstemp)[[1, 2, 0]]\n cs = cs[order]\n d[:3] = d[order]\n\n # Flip into Weyl chamber\n if cs[0] > pi2:\n cs[0] -= 3 * pi2\n if cs[1] > pi2:\n cs[1] -= 3 * pi2\n conjs = 0\n if cs[0] > pi4:\n cs[0] = pi2 - cs[0]\n conjs += 1\n if cs[1] > pi4:\n cs[1] = pi2 - cs[1]\n conjs += 1\n if cs[2] > pi2:\n cs[2] -= 3 * pi2\n if conjs == 1:\n cs[2] = pi2 - cs[2]\n if cs[2] > pi4:\n cs[2] -= pi2\n\n return cs[[1, 0, 2]]","def cie_luv(self):\n K = Fraction(29, 3) ** 3\n e = Fraction(6, 29) ** 3\n XYZ = self.cie_xyz\n yr = XYZ[1] / D65[1]\n L = 116 * yr ** Fraction(1, 3) - 16 if yr > e else K * yr\n u = 13 * L * (U(*XYZ) - U(*D65))\n v = 13 * L * (V(*XYZ) - V(*D65))\n return (L, u, v)","def __init__(self, u1=(1,0,0), u2=(0,1,0), u3=(0,0,1)):\n u1 = vec3(u1)\n u2 = vec3(u2)\n u3 = vec3(u3)\n\n if triple_scalar_product(u1, u2, u3) != 1:\n print >> sys.stderr, \"!! Invalid lattice vectors: u1 = %s, u2 = %s, u3 = %s\" % (u1,u2,u3)\n self.e1 = vec3(1,0,0)\n self.e2 = vec3(0,1,0)\n self.e3 = vec3(0,0,1)\n else:\n s1 = square(u1)\n s2 = square(u2)\n d12 = dot(u1, u2)\n d23 = dot(u2, u3)\n d13 = dot(u1, u3)\n alpha = -d12/s1\n gamma = -(alpha*d13 + d23)/(alpha*d12 + s2)\n beta = -(d13 + gamma*d12)/s1\n self.e1 = u1\n self.e2 = u2 + alpha*u1\n self.e3 = u3 + beta*u1 + gamma*u2\n\n if verbose:\n print(\"e1 = %s\" % self.e1)\n print(\"e2 = %s\" % self.e2)\n print(\"e3 = %s\" % self.e3)\n\n self.L1 = length(self.e1)\n self.L2 = length(self.e2)\n self.L3 = length(self.e3)\n self.n1 = self.e1/self.L1\n self.n2 = self.e2/self.L2\n self.n3 = self.e3/self.L3\n self.cells = []\n\n v0 = vec3(0,0,0)\n self.v = [v0,\n v0 + self.e3,\n v0 + self.e2,\n v0 + self.e2 + self.e3,\n v0 + self.e1,\n v0 + self.e1 + self.e3,\n v0 + self.e1 + self.e2,\n v0 + self.e1 + self.e2 + self.e3]\n\n # Compute bounding box of cuboid\n xs = [vk.x for vk in self.v]\n ys = [vk.y for vk in self.v]\n zs = [vk.z for vk in self.v]\n vmin = vec3(min(xs), min(ys), min(zs))\n vmax = vec3(max(xs), max(ys), max(zs))\n\n # Extend to nearest integer coordinates\n ixmin = int(floor(vmin.x))\n ixmax = int(ceil(vmax.x))\n iymin = int(floor(vmin.y))\n iymax = int(ceil(vmax.y))\n izmin = int(floor(vmin.z))\n izmax = int(ceil(vmax.z))\n if verbose:\n print(\"ixmin, ixmax = %d, %d\" % (ixmin,ixmax))\n print(\"iymin, iymax = %d, %d\" % (iymin,iymax))\n print(\"izmin, izmax = %d, %d\" % (izmin,izmax))\n\n # Determine which cells (and which faces within those cells) are non-trivial\n for ix in range(ixmin, ixmax):\n for iy in range(iymin, iymax):\n for iz in range(izmin, izmax):\n shift = vec3(-ix, -iy, -iz)\n faces = [Plane(self.v[0] + shift, +self.n1),\n Plane(self.v[4] + shift, -self.n1),\n Plane(self.v[0] + shift, +self.n2),\n Plane(self.v[2] + shift, -self.n2),\n Plane(self.v[0] + shift, +self.n3),\n Plane(self.v[1] + shift, -self.n3)]\n\n c = Cell(ix, iy, iz)\n skipcell = False\n for f in faces:\n r = UnitCubeTest(f)\n if r == +1:\n # Unit cube is completely above this plane; this cell is empty\n continue\n elif r == 0:\n # Unit cube intersects this plane; keep track of it\n c.faces.append(f)\n elif r == -1:\n skipcell = True\n break\n\n if skipcell or len(c.faces) == 0:\n if verbose:\n print(\"Skipping cell at (%d,%d,%d)\" % (ix,iy,iz))\n continue\n else:\n self.cells.append(c)\n if verbose:\n print(\"Adding cell at (%d,%d,%d)\" % (ix,iy,iz))\n\n # For the identity remapping, use exactly one cell\n if len(self.cells) == 0:\n self.cells.append(Cell())\n\n # Print the full list of cells\n if verbose:\n print(\"%d non-empty cells\" % len(self.cells))\n for c in self.cells:\n print(\"Cell at (%d,%d,%d) has %d non-trivial planes\" % (c.ix,\n c.iy, c.iz, len(c.faces)))","def l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # z >= 0 \n \n c = matrix(n*[0.0] + m*[1.0])\n h = matrix([q, -q])\n\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \n if trans == 'N':\n # y := alpha * [P, -I; -P, -I] * x + beta*y\n u = P*x[:n]\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\n\n else:\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\n\n\n def Fkkt(W): \n\n # Returns a function f(x, y, z) that solves\n #\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\n #\n # On entry bx, bz are stored in x, z.\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\n # returned instead of z). \n\n d1, d2 = W['d'][:m], W['d'][m:]\n D = 4*(d1**2 + d2**2)**-1\n A = P.T * spdiag(D) * P\n lapack.potrf(A)\n\n def f(x, y, z):\n\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \n + mul( .5*D, z[:m]-z[m:] ) )\n lapack.potrs(A, x)\n\n u = P*x[:n]\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\n\n z[:m] = div(u-x[n:]-z[:m], d1)\n z[m:] = div(-u-x[n:]-z[m:], d2)\n\n return f\n\n\n # Initial primal and dual points from least-squares solution.\n\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\n uls = +q\n lapack.gels(+P, uls)\n rls = P*uls[:n] - q \n\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \n s0 = +h\n Fi(x0, s0, alpha=-1, beta=1) \n\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \n # if rls is nonzero and w = 0 otherwise.\n if max(abs(rls)) > 1e-10: \n w = .9/max(abs(rls)) * rls\n else: \n w = matrix(0.0, (m,1))\n z0 = matrix([.5*(1+w), .5*(1-w)])\n\n dims = {'l': 2*m, 'q': [], 's': []}\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\n return sol['x'][:n]","def _apply_array_spatial12_lowfilling_python(self, h1e: 'Nparray',\n h2e: 'Nparray') -> 'Nparray':\n out = self._apply_array_spatial1(h1e)\n\n norb = self.norb()\n nalpha = self.nalpha()\n nbeta = self.nbeta()\n lena = self.lena()\n lenb = self.lenb()\n nlt = norb * (norb + 1) // 2\n\n h2ecomp = numpy.zeros((nlt, nlt), dtype=self._dtype)\n for i in range(norb):\n for j in range(i + 1, norb):\n ijn = i + j * (j + 1) // 2\n for k in range(norb):\n for l in range(k + 1, norb):\n h2ecomp[ijn, k + l * (l + 1) // 2] = (h2e[i, j, k, l] -\n h2e[i, j, l, k] -\n h2e[j, i, k, l] +\n h2e[j, i, l, k])\n\n if nalpha - 2 >= 0:\n alpha_map, _ = self._core.find_mapping(-2, 0)\n intermediate = numpy.zeros(\n (nlt, int(binom(norb, nalpha - 2)), lenb), dtype=self._dtype)\n for i in range(norb):\n for j in range(i + 1, norb):\n ijn = i + j * (j + 1) // 2\n for source, target, parity in alpha_map[(i, j)]:\n work = self.coeff[source, :] * parity\n intermediate[ijn, target, :] += work\n\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\n\n for i in range(norb):\n for j in range(i + 1, norb):\n ijn = i + j * (j + 1) // 2\n for source, target, parity in alpha_map[(i, j)]:\n out[source, :] -= intermediate[ijn, target, :] * parity\n\n if self.nalpha() - 1 >= 0 and self.nbeta() - 1 >= 0:\n alpha_map, beta_map = self._core.find_mapping(-1, -1)\n intermediate = numpy.zeros((norb, norb, int(binom(\n norb, nalpha - 1)), int(binom(norb, nbeta - 1))),\n dtype=self._dtype)\n\n for i in range(norb):\n for j in range(norb):\n for sourcea, targeta, paritya in alpha_map[(i,)]:\n sign = ((-1)**(nalpha - 1)) * paritya\n for sourceb, targetb, parityb in beta_map[(j,)]:\n work = self.coeff[sourcea, sourceb] * sign * parityb\n intermediate[i, j, targeta, targetb] += 2 * work\n\n intermediate = numpy.tensordot(h2e, intermediate, axes=2)\n\n for i in range(norb):\n for j in range(norb):\n for sourcea, targeta, paritya in alpha_map[(i,)]:\n sign = ((-1)**nalpha) * paritya\n for sourceb, targetb, parityb in beta_map[(j,)]:\n work = intermediate[i, j, targeta, targetb] * sign\n out[sourcea, sourceb] += work * parityb\n\n if self.nbeta() - 2 >= 0:\n _, beta_map = self._core.find_mapping(0, -2)\n intermediate = numpy.zeros((nlt, lena, int(binom(norb, nbeta - 2))),\n dtype=self._dtype)\n for i in range(norb):\n for j in range(i + 1, norb):\n ijn = i + j * (j + 1) // 2\n for source, target, parity in beta_map[(i, j)]:\n work = self.coeff[:, source] * parity\n intermediate[ijn, :, target] += work\n\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\n\n for i in range(norb):\n for j in range(i + 1, norb):\n ijn = i + j * (j + 1) // 2\n for source, target, sign in beta_map[(min(i, j), max(i,\n j))]:\n out[:, source] -= intermediate[ijn, :, target] * sign\n return out","def LLE(data, n_components=2, n_neighbors=10):\n # Compute the nearest neighbors\n _, neighbors_idx = AffiinityMAt(data,n_neighbor=n_neighbors,kernel_method='Linear')\n\n n = data.shape[0]\n w = np.zeros((n, n))\n for i in range(n):\n # Center the neighbors matrix\n k_indexes = neighbors_idx[i, :]\n neighbors = data[k_indexes, :] - data[i, :]\n\n # Compute the corresponding gram matrix\n gram_inv = np.linalg.pinv(np.dot(neighbors, neighbors.T))\n\n # Setting the weight values according to the lagrangian\n lambda_par = 2/np.sum(gram_inv)\n w[i, k_indexes] = lambda_par*np.sum(gram_inv, axis=1)/2\n m = np.subtract(np.eye(n), w)\n values, u = np.linalg.eigh(np.dot(np.transpose(m), m))\n return u[:, 1:n_components+1]","def needleman_wunsch1(x,y,lodict=None,gop=-2.5, gep=-1.75, local=False):\n n,m = len(x),len(y)\n dp = np.zeros((n+1,m+1))\n pointers = np.zeros((n+1,m+1),np.int32)\n for i in range(1,n+1):\n dp[i,0] = dp[i-1,0]+(gep if i>1 else gop)\n pointers[i,0]=1\n for j in range(1,m+1):\n dp[0,j] = dp[0,j-1]+(gep if j>1 else gop)\n pointers[0,j]=2\n for i in range(1,n+1):\n for j in range(1,m+1):\n if not lodict:\n if x[i-1] == y[j-1]:\n match = dp[i-1,j-1]+1\n else:\n match = dp[i-1,j-1]-1\n else:\n match = dp[i-1,j-1]+lodict[x[i-1],y[j-1]]\n insert = dp[i-1,j]+(gep if pointers[i-1,j]==1 else gop)\n delet = dp[i,j-1]+(gep if pointers[i,j-1]==2 else gop)\n max_score = max([match,insert,delet])\n dp[i,j] = max_score\n pointers[i,j] = [match,insert,delet].index(max_score)\n alg = []\n i,j = n,m\n while(i>0 or j>0):\n pt = pointers[i,j]\n if pt==0:\n i-=1\n j-=1\n alg = [[x[i],y[j]]]+alg\n if pt==1:\n i-=1\n alg = [[x[i],'-']]+alg\n if pt==2:\n j-=1\n alg = [['-',y[j]]]+alg\n return dp[-1,-1], alg","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts) \n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def probability(N_dr, L_opmin, L_opmax, L_min, L_max, L_d):\n opening_nomullignas = []\n opening_withmullignas = []\n sum_nomulligans = 0\n sum_withmulligans = 0\n mulligan_coeff = 0\n\n for i in range(L_opmin, min(L_opmax + 1, 8)): # first make a list of tuples of the form:\n # (number_of_lands_in_opening_hand, probability_of_drawing_such_a_hand)\n a = hypergeom(i, 7, 60, L_d)\n opening_nomullignas.append((i, a))\n mulligan_coeff = mulligan_coeff + a # this will be used later for calculating the probability of\n # taking the mulligan and is used as a coefficient before the mulligan sum\n for (x, y) in opening_nomullignas: # use the list of tuples to calculate the first part of equation 5\n partial_nomulligans = 0\n for j in range(L_min - x, L_max - x + 1):\n partial_nomulligans = partial_nomulligans + hypergeom(j, N_dr, 53, L_d - x)\n sum_nomulligans = sum_nomulligans + partial_nomulligans * y\n\n mulligan_coeff = 1 - mulligan_coeff # probability of mulliganing\n for i in range(L_opmin, min(L_opmax + 1, 7)): # doing the same thing as before, but drawing 6 instead of 7 cards\n a = hypergeom(i, 6, 60, L_d)\n opening_withmullignas.append((i, a))\n\n for (x, y) in opening_withmullignas:\n partial_withmulligans = 0\n for j in range(L_min - x, L_max - x + 1):\n partial_withmulligans = partial_withmulligans + hypergeom(j, N_dr, 54, L_d - x)\n sum_withmulligans = sum_withmulligans + partial_withmulligans * y\n total_withmulligans = mulligan_coeff * sum_withmulligans\n\n return total_withmulligans + sum_nomulligans","def l2p(x, y):\n \n return square_size[0]*x, square_size[1]*y","def l2_norm(self):\n return (self.x**2 + self.y**2 + self.z**2)**0.5","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 vincenty(lat1, lon1, lat2, lon2,\n r_major=6378.1370, r_minor=6356.752314, r_sphere=None):\n lat1 = m.radians(lat1)\n lat2 = m.radians(lat2)\n lon1 = m.radians(lon1)\n lon2 = m.radians(lon2)\n \n if (r_sphere is not None):\n r_major = r_sphere\n r_minor = r_sphere\n f = 0.0\n else:\n f = (r_major-r_minor)/r_major\n \n U1 = m.atan((1.0-f) * m.tan(lat1))\n U2 = m.atan((1.0-f) * m.tan(lat2))\n L = lon2 - lon1\n \n epsilon = 1E-12 # Accuracy (10E-12 -> ~ 0.06mm)\n max_iter = 500\n lam = L\n \n cU1 = m.cos(U1)\n cU2 = m.cos(U2)\n sU1 = m.sin(U1)\n sU2 = m.sin(U2)\n \n for i in range(max_iter):\n lam_old = lam\n sLam = m.sin(lam)\n cLam = m.cos(lam)\n sin_sig = m.sqrt((cU2*sLam)**2 + (cU1*sU2 - sU1*cU2*cLam)**2)\n cos_sig = sU1*sU2 + cU1*cU2*cLam\n sig = m.atan2(sin_sig,cos_sig)\n sin_alp = (cU1*cU2*sLam) / sin_sig\n cos2_alp = 1.0 - sin_alp**2\n if (cos2_alp == 0.0):\n # equitorial line\n cos_2sigm = 100\n C = 0.0\n else:\n cos_2sigm = cos_sig - (2.0*sU1*sU2)/cos2_alp\n C = f/16.0 * cos2_alp * (4.0 + f*(4.0-3.0*cos2_alp))\n lam = L + (1.0 - C) * f * sin_alp * \\\n (sig + C * sin_sig * (cos_2sigm + C * cos_sig * \\\n (-1.0 + 2.0 * cos_2sigm**2)))\n if ((m.fabs(lam - lam_old)) <= epsilon):\n # Found a solution in i iters...\n break\n elif (i == max_iter):\n # Catch the out of iters case, never seen this.\n raise Exception(\"Failed to solve for distance\")\n \n usq = cos2_alp * ((r_major**2 - r_minor**2) / r_minor**2)\n A = 1 + usq/16384 * (4096 + usq*(-768 + usq*(320 - 175*usq)))\n B = usq/1024 * (256 + usq*(-128 + usq*(74 - 47*usq)))\n del_sig = B * sin_sig * (cos_2sigm + 0.25*B*(cos_sig*( \\\n -1 + 2*cos_2sigm**2) - (1.0/6.0)*B*cos_2sigm * ( \\\n -3 + 4*sin_sig**2) * (-3 + 4 * cos_2sigm**2)))\n s = r_minor * A * (sig - del_sig)\n alp1 = m.atan2(cU2*m.sin(lam),(cU1*sU2-sU1*cU2*m.cos(lam)))\n alp2 = m.atan2(cU1*m.sin(lam),(cU1*sU2*m.cos(lam)-sU1*cU2))\n\n return (s, m.degrees(alp1), m.degrees(alp2))","def l2(x, y):\n return np.sum(((x - y) ** 2))","def laplace_2d(x_loc, y_loc, u):\n\n assert u.shape == (x_loc.shape[0], y_loc.shape[0])\n\n dx = x_loc[1:] - x_loc[0:-1]\n dy = y_loc[1:] - y_loc[0:-1]\n\n u_sol = u.copy()\n error = 1\n while error > 1e-3:\n u = u_sol.copy()\n u_sol[1:-1, 1:-1] = (dy[0:-1] * dy[1:] * (u_sol[2:, 1:-1] + u_sol[0:-2, 1:-1]) \\\n + dx[0:-1] * dx[1:] * (u_sol[1:-1, 2:] + u_sol[1:-1, 0:-2])) \\\n / (2 * (dy[0:-1] * dy[1:] + dx[0:-1] * dx[1:]))\n\n u_sol[0, :] = 0\n u_sol[-1, :] = y_loc\n u_sol[:, 0] = u_sol[:, 1]\n u_sol[:, -1] = u_sol[:, -2]\n\n error = np.abs(np.sum(np.abs(u_sol[:]) - np.abs([u])) / np.sum(np.abs(u[:])))\n return u_sol","def LD(x, y, lodict={}):\n return needleman_wunsch(x, y, lodict=lodict, gop=-1, gep=-1)","def helical_consistency(p2i, p1):\n\tfrom pixel_error import angle_diff\n\tfrom math import cos,pi\n\tfrom utilities import getvec\n\tfrom pixel_error import angle_error\n\tfrom EMAN2 import Vec2f\n\tn =len(p1[0])\n\tprint n\n\tqtm = -1.0e10\n\tfor lf in xrange(0,181,180):\n\t\tp2 = []\n\t\tp2.extend(p2i)\n\t\tif( lf == 180):\n\t\t\ttflip = Transform({\"type\":\"spider\",\"theta\":180.0})\n\t\t\tfor j in xrange(n):\n\t\t\t\tt2 = Transform({\"type\":\"spider\",\"phi\":p2[0][j],\"theta\":p2[1][j],\"psi\":p2[2][j]})\n\t\t\t\tt2.set_trans( Vec2f( -p2[3][j], -p2[4][j] ) )\n\t\t\t\tt2 = t2*tflip\n\t\t\t\td = t2.get_params(\"spider\")\n\t\t\t\tp2[0][j] = d[\"phi\"]\n\t\t\t\tp2[1][j] = d[\"theta\"]\n\t\t\t\tp2[2][j] = d[\"psi\"]\n\t\t\t\tp2[3][j] = -d[\"tx\"]\n\t\t\t\tp2[4][j] = -d[\"ty\"]\n\t\ttt1 = [0.0]*n\n\t\ttt2 = [0.0]*n\n\t\tmirror = [False]*n\n\t\tln = 0\n\t\tfor j in xrange( n ):\n\t\t\tt1 = getvec(p1[0][j],p1[1][j])\n\t\t\tt2 = getvec(p2[0][j],p2[1][j])\n\t\t\ttm = getvec(180.0+p2[0][j],180.0-p2[1][j])\n\t\t\ttt1[j] = t1[0]*t2[0]+t1[1]*t2[1]+t1[2]*t2[2]\n\t\t\ttt2[j] = t1[0]*tm[0]+t1[1]*tm[1]+t1[2]*tm[2]\n\t\t\tif(abs(tt1[j])<1.0e-7): tt1[j] = 0.0\n\t\t\tif(abs(tt2[j])<1.0e-7): tt2[j] = 0.0\n\t\t\tif(tt1[j]>tt2[j]):\n\t\t\t\tmirror[j] = True\n\t\t\t\tln+=1\n\t\tprint \" FLIP \",lf\n\t\tif(ln < n//2):\n\t\t\tprint \"mirror \",ln\n\t\t\tfor j in xrange( n ):\n\t\t\t\tp2[0][j] += 180.0\n\t\t\t\tp2[1][j] = 180.0-p2[1][j]\n\t\t\t\tp2[2][j] = -p2[2][j]\n\t\t\t\tp2[4][j] = -p2[4][j]\n\t\t\t\tmirror[j] = not(mirror[j])\n\t\telse:\n\t\t\tprint \" straight\", ln\n\t\tphi1 = []\n\t\tphi2 = []\n\t\tagree = []\n\t\tfor j in xrange(n):\n\t\t\tif(mirror[j]):\n\t\t\t\tphi1.append(p1[0][j])\n\t\t\t\tphi2.append(p2[0][j])\n\t\t\t\tagree.append(j)\n\t\tprint len(phi1)\n\t\tdelta_phi = angle_diff( phi2, phi1 )\n\t\tprint \"close form diff===\", delta_phi\n\n\t\tphi1 = []\n\t\tphi2 = []\n\t\terrorm = []\n\t\tfor j in xrange( len( p1[0]) ):\n\t\t\tp2[0][j] = (p2[0][j] + delta_phi + 360)%360.0\n\t\t\tif(mirror[j]):\n\t\t\t\tphi1.append(p1[0][j])\n\t\t\t\tphi2.append(p2[0][j])\n\t\t\t\terrorm.append(angle_error( [ p2[0][j] ], [ p1[0][j] ]))\n\t\tqt = sum(errorm)/len(errorm)\n\t\tprint len(errorm),qt\n\t\tif(qt > qtm):\n\t\t\tqtm = qt\n\t\t\tp2o = []\n\t\t\tp2o.extend(p2)\n\t\t\terrormo = []\n\t\t\tphi1o = []\n\t\t\tphi2o = []\n\t\t\terrormo.extend(errorm)\n\t\t\tphi1o.extend(phi1)\n\t\t\tphi2o.extend(phi2)\n\t\t\n\treturn p2o, errormo, agree, delta_phi, phi1o, phi2o","def cross_junctions(I, bounds, Wpts):\n #--- FILL ME IN ---\n\n Ipts = np.zeros((2, 48))\n\n#parameters\n alpha = 0.15 #typically 0.04 to 0.06\n threshold = 1500 #default 2000\n sigma = 2\n ws = 12 #window size for saddle point\n\n#building Harris Detecter\n I = I/255.0\n gradx, grady = np.gradient(I)\n IxIx = gaussian_filter(gradx*gradx,sigma)\n IxIy = gaussian_filter(gradx*grady,sigma)\n IyIy = gaussian_filter(grady*grady,sigma)\n print(I.shape)\n\n #get harris score\n cand_score = []\n cand_index = []\n cand = []\n s_cand = []\n\n for j in range(len(I)):\n for i in range(len(I[0])):\n a11 = IxIx[j][i]\n a12 = IxIy[j][i]\n a21 = a12\n a22 = IyIy[j][i]\n A = np.array([[a11, a12],[a21, a22]])\n ev0, ev1 = np.linalg.eigvals(A)\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\n cand_score.append(-h_score)\n cand_index.append([i, j])\n\n #get the coordinates of the top 5000 scores\n sorted_ind = np.argsort(cand_score)\n sorted_score = np.sort(cand_score).tolist()\n\n for ind in sorted_ind[:threshold]:\n cand.append(cand_index[ind])\n s_cand = sorted_score[:threshold]\n\n\n#clustering\n #using homography to project candidate points to a up-front view\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\n H = dlt_homography(bounds, new_bbox)\n cand = np.array(cand).T\n cand = np.vstack((cand, np.ones(cand.shape[1])))\n Ho_cand = np.matmul(H,cand).T\n for pt in Ho_cand:\n pt[0] = pt[0]/pt[2]\n pt[1] = pt[1]/pt[2]\n Ho_cand = Ho_cand[:,:2]\n Ho_cand = Ho_cand.tolist()\n\n #get rid of points that are not in the boundry\n temp_Ho_cand = []\n temp_s_cand = []\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\n continue\n else:\n temp_Ho_cand.append(pt)\n temp_s_cand.append(s_cand[i])\n Ho_cand = np.array(temp_Ho_cand)\n s_cand = temp_s_cand\n #divide candidates into clusters\n assignment = []\n assignment_score = []\n\n #first put in the point that has the highest score\n assignment.append([Ho_cand[0]])\n assignment_score.append([s_cand[0]])\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n if min(dist) > 6:\n assignment.append([pt])\n assignment_score.append([s_cand[i]])\n\n assignment = np.array(assignment)\n\n #assign points to clusters\n for i in range(len(Ho_cand)):\n pt = Ho_cand[i]\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\n continue\n dist = []\n for c in assignment:\n dist.append(np.linalg.norm(pt - c[0]))\n index = np.argsort(dist)[-1]\n np.append(assignment[index], pt)\n assignment_score[index].append(s_cand[i])\n\n #get centroids for each cluster\n Ho_centroids = []\n for i in range(len(assignment)):\n cl = assignment[i]\n cl = np.array(cl)\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\n assignment_score[i] = sum(assignment_score[i])\n\n print(len(assignment_score))\n\n Ho_centroids = np.array(Ho_centroids)\n #get rid of edge points\n\n xmin = np.amin(Ho_centroids.T[0])\n xmax = np.amax(Ho_centroids.T[0]) \n ymin = np.amin(Ho_centroids.T[1])\n ymax = np.amax(Ho_centroids.T[1])\n\n final_cand = []\n final_score = []\n for i in range(len(Ho_centroids)):\n pt = Ho_centroids[i]\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\n continue\n else:\n final_cand.append(pt)\n final_score.append(assignment_score[i])\n print(\"Number of corner found: \")\n print(len(final_cand))\n\n #get rid of fake corners\n if (len(final_cand)>48):\n ultimate_cand =[]\n for ind in np.argsort(final_score)[:48]:\n ultimate_cand.append(final_cand[ind])\n final_cand = ultimate_cand\n print(\"real corners count:\", len(ultimate_cand))\n\n\n #sort the points\n final_cand = np.array(final_cand)\n y_sort_ind = np.argsort(final_cand.T[1])\n final_cand = final_cand.tolist()\n rows = []\n for i in range(6):\n row = []\n for ind in y_sort_ind[i*8:(i+1)*8]:\n row.append(final_cand[ind])\n rows.append(row)\n\n ordered = []\n for row in rows:\n r = []\n x_sort_ind = np.argsort(np.array(row).T[0])\n for ind in x_sort_ind:\n r.append(row[ind])\n ordered.append(r)\n\n final_cand = []\n for row in ordered:\n for pt in row:\n final_cand.append(pt)\n \n\n\n #get coordinates of the centroids in the original frame\n Ho_centroids = np.array(final_cand)\n\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\n centroids = np.matmul(np.linalg.inv(H), centroids).T\n for pt in centroids:\n pt[0] = int(pt[0]/pt[2])\n pt[1] = int(pt[1]/pt[2])\n centroids = centroids[:,:2]\n\n#finding saddle points around the centroids\n saddle_points = []\n for pt in centroids:\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\n saddle = saddle_point(img)\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\n saddle_points.append(saddle)\n\n saddle_points = np.array(saddle_points)\n #------------------\n print(saddle_points.T)\n return saddle_points.T","def strassen_dot(x, y):\n# X = (A B) Y = (E F)\n# (C D) (G H)\n# \n# A through H -- (n/2 x n/2) matrices\n# \n# let P1 = A(F-H), P2 = (A+B)H, P3 = (C+D)E, P4 = D(G-E), \n# \n# P5 = (A+D)(E+H), P6 = (B-D)(G+H), P7 = (A-C)(E+F)\n# \n# XY = (AE+BG AF+BH) = (P5+P4-P2+P6 P1+P2 )\n# (CE+DG CF+DH) (P3+P4 P1+P5-P3-P7)\n\n n = x.shape[0]\n originalN = n\n \n # base case (n<=8)\n if n <= 8:\n return brute_multiply(x, y)\n \n n_is_power_of_two = (n & (n-1) == 0)\n\n if not n_is_power_of_two:\n # count the closest power of 2 above n\n # and resize x and y matrices\n newN = upper_pow_2(n)\n \n n = newN\n \n nX = np.zeros( (n, n) )\n# mapping x on to nX:\n nX[:originalN, :originalN] = x\n x = nX\n \n nY = np.zeros( (n, n) )\n# mapping y on to nY:\n nY[:originalN, :originalN] = y\n y = nY\n \n \n a = x[ 0:n//2, 0:n//2 ]\n b = x[ 0:n//2, n//2: ]\n c = x[ n//2:, 0:n//2 ]\n d = x[ n//2:, n//2: ]\n\n e = y[ 0:n//2, 0:n//2 ]\n f = y[ 0:n//2, n//2: ]\n g = y[ n//2:, 0:n//2 ]\n h = y[ n//2:, n//2: ]\n \n# let P1 = A(F-H), P2 = (A+B)H, P3 = (C+D)E, P4 = D(G-E), \n# \n# P5 = (A+D)(E+H), P6 = (B-D)(G+H), P7 = (A-C)(E+F)\n \n # recursively compute 7 (SEVEN) products P1 .. P7\n p1 = strassen_dot(a, f-h)\n p2 = strassen_dot(a+b, h)\n p3 = strassen_dot(c+d, e)\n p4 = strassen_dot(d, g-e)\n p5 = strassen_dot(a+d, e+h)\n p6 = strassen_dot(b-d, g+h)\n p7 = strassen_dot(a-c, e+f)\n \n# do the necessary (clever) additions & substractions with P1..P7\n \n# XY = (AE+BG AF+BH) = (P5+P4-P2+P6 P1+P2 )\n# (CE+DG CF+DH) (P3+P4 P1+P5-P3-P7)\n res1 = np.hstack( (p5+p4-p2+p6, p1+p2) )\n res2 = np.hstack( (p3+p4, p1+p5-p3-p7) )\n res = np.vstack( (res1, res2) )\n\n return res[:originalN, :originalN]","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 center_flows(L_wprime, U_wprime, L_w3, U_w3, L_overlap, U_overlap):\n # examine every possible point\n current_dist_to_edge = -1\n point = (0,0)\n #print(\"w3 range: [{}, {}]\".format(L_w3, U_w3))\n #print(\"w' range: [{}, {}]\".format(L_wprime, U_wprime))\n #print(\"overlap range: [{},{}]\".format(L_overlap, U_overlap))\n for y in range(L_w3, U_w3 + 1):\n #print(\"y={}\".format(y))\n LH_bound = max(L_wprime, L_overlap - y)\n #print(\"LH bound = {}\".format(LH_bound))\n RH_bound = min(U_wprime, U_overlap - y)\n #print(\"RH bound = {}\".format(RH_bound))\n for x in range(LH_bound, RH_bound + 1):\n # w3 UB: 0x + 1y - U_w3 = 0\n # w3 LB: 0x + 1y - L_w3 = 0\n # wprime UB: 1x + 0y - U_wprime\n # wprime LB: 1x + 0y - L_wprime\n # wprime + w3 UB: 1x + 1y - U_wprime,wk\n # wprime + w3 LB: 1x + 1y - L_wprime,wk\n dist_to_edge = min(distance_point_to_line(x, y, 0, -1, U_w3), #0x-1y+U_w3=0\n distance_point_to_line(x, y, 0, -1, L_w3), #0x-1y+L_w3=0\n # -1x + 0y + U_wprime = 0\n distance_point_to_line(x, y, -1, 0, U_wprime),\n # -1x + 0y + L_wprime = 0\n distance_point_to_line(x, y, -1, 0, L_wprime),\n # -1x - 1y + U_overlap = 0\n distance_point_to_line(x, y, -1, -1, U_overlap),\n # -1 x - y + L_overlap = 0\n distance_point_to_line(x, y, -1, -1, L_overlap))\n if dist_to_edge > current_dist_to_edge:\n #print(\"At point ({},{}), distance to edge increased from {} to {}.\"\\\n # .format(x,y,current_dist_to_edge,dist_to_edge))\n current_dist_to_edge = dist_to_edge\n point = (x,y)\n return(point)","def secondorder(self):\n f = self.img\n x = self.x\n y = self.y\n self.x2 = sum(f*x**2)/sum(f) - self.x1**2\n self.y2 = sum(f*y**2)/sum(f) - self.y1**2\n self.xy = sum(f*x*y)/sum(f) - self.x1*self.y1","def l2(u: np.ndarray, v: np.ndarray) -> np.ndarray:\n\n return (u - v) ** 2","def fdm_2d(N,L,x,y,h,k):\n\n # Create the Laplacian as a 1d sparse matrix using central difference\n ones = np.ones(N)\n diagvalues = np.array([ones,-2*ones,ones])\n offsets = np.array([-1,0,1])\n lap1d = sps.dia_matrix((diagvalues,offsets), shape=(N,N))/h**2\n \n # Represent 2d coordinates as kronecker sum\n lap = sps.kron(lap1d,sps.diags(np.ones(N))) + \\\n sps.kron(sps.diags(np.ones(N)),lap1d)\n \n # potential terms\n pot_x = np.repeat(x**2,N)\n pot_y = np.tile(y**2,N)\n\n # The whole Hamiltonian in matrix form\n A = (-1*lap + sps.diags(pot_x) + sps.diags(pot_y))/2\n\n # Calculate the k smallest eigenvalues and corresponding eigenvectors\n E, psi = eigsh(A,k=k,which='SM')\n\n\n # Perturbated potential\n a = 25\n pot_new = pot_x + pot_y + gauss_pert(N,a).flatten()\n\n # Plot the new potential\n X,Y = np.meshgrid(x,y)\n fig = plt.figure()\n ax = fig.add_subplot(1,2,1,projection='3d')\n ax.plot_surface(X, Y, pot_new.reshape((N,N)), cmap=cm.coolwarm,\n linewidth=0, antialiased=False)\n ax = fig.add_subplot(1,2,2)\n fig.suptitle(r'Potential with a Gaussian perturbation')\n ax.imshow(pot_new.reshape(N,N),extent=[-L/2,L/2,-L/2,L/2])\n plt.savefig(os.path.join(path,'perturbated_potential.png'))\n\n # The perturbated Hamiltonian in matrix form\n A = (-1*lap + sps.diags(pot_new))/2\n\n # Calculate the k smallest eigenvalues and corresponding eigenvector\n # Of the perturbated system\n E_p, psi_p = eigsh(A,k=k,which='SM')\n\n return E,psi,E_p,psi_p","def olivine():\n\n rho = 3355.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 320.5; C[0,1] = 68.15; C[0,2] = 71.6; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\n C[1,0] = C[0,1]; C[1,1] = 196.5; C[1,2] = 76.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 233.5; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 64.; C[3,4] = 0.; C[3,5] = 0.\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 77.; C[4,5] = 0.\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 78.7\n\n return C, rho","def build_coord(norm, d, pts):\n # Compute the origin as the mean point of the points, and this point has to be on the plane\n \n n = len(pts)\n x_total = 0\n y_total = 0\n z_total = 0\n \n for i in range(n):\n x_total += pts[i][0]\n y_total += pts[i][1]\n z_total += pts[i][2]\n\n x_o = x_total * 1.0 / n\n y_o = y_total * 1.0 / n\n z_o = z_total * 1.0 / n\n p_o = [x_o, y_o, z_o]\n \n # Choose p be the projection of a vector in the z-axis to the plane\n # If the plane is not perpendicular to the z-axis\n if ((norm[2] != 1) and (norm[2] != -1)): \n # Choose a point\n o_z = [x_o, y_o, z_o + 1]\n \n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\n \n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\n\n x_c = (x_p - x_o) * 1.0 / dist \n y_c = (y_p - y_o) * 1.0 / dist\n z_c = (z_p - z_o) * 1.0 / dist\n # Thus we have unit vector in x direction\n e_y = [x_c, y_c, z_c]\n #Compute the unit vector in y direction\n e_x = np.cross(e_y, norm).tolist()\n else:\n e_x = [1, 0, 0]\n e_y = [0, 1, 0]\n \n return [e_x, e_y, norm] , p_o","def illuminator_of_elfes():\n\n\t# Alpha - simplified by taking out the i by multiplying the outerproduct by 2i\n\talpha1i = np.matrix([[0, 0, 0, 2], [0, 0, 2, 0], [0, -2, 0, 0], [-2, 0, 0, 0]])\n\talpha2i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, 2], [0, 0, -2, 0]])\n\talpha3i = np.matrix([[0, 0, 2, 0], [0, 0, 0, -2], [-2, 0, 0, 0], [0, 2, 0, 0]])\n\n\t# Betas - simplified by taking out the i by multiplication of outerprod by 2i\n\tbeta1i = np.matrix([[0, 0, 0, 2], [0, 0, -2, 0], [0, 2, 0, 0], [-2, 0, 0, 0]])\n\tbeta2i = np.matrix([[0, 0, 2, 0], [0, 0, 0, 2], [-2, 0, 0, 0], [0, -2, 0, 0]])\n\tbeta3i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, -2], [0, 0, 2, 0]])\n\n\t# print(\"alpha 1\")\n\t# print(alpha1i)\n\t# print(\"\")\n\t# print(\"alpha 2\")\n\t# print(alpha2i)\n\t# print(\"\")\n\t# print(\"alpha 3\")\n\t# print(alpha3i)\n\t# print(\"\")\n\t# print(\"beta 1\")\n\t# print(beta1i)\n\t# print(\"\")\n\t# print(\"beta 2\")\n\t# print(beta2i)\n\t# print(\"\")\n\t# print(\"beta 3\")\n\t# print(beta3i)\n\t# print(\"\")\n\n\t# abperm_comb = [ np.multiply(alpha1i,-1), np.multiply(alpha2i,-1), np.multiply(alpha3i,-1), np.multiply(beta1i,-1), np.multiply(beta2i,-1), np.multiply(beta3i,-1)]\n\n\tabperm_comb = [alpha1i, alpha2i, alpha3i, beta1i, beta2i, beta3i]\n\treturn abperm_comb","def _computeStikeDip(self):\n seg = self._group_index\n groups = np.unique(seg)\n ng = len(groups)\n norm_vec = Vector(0, 0, 0)\n north_vec = Vector(0, 0, 0)\n up_vec = Vector(0, 0, 0)\n for i in range(ng):\n group_segments = np.where(groups[i] == seg)[0]\n nseg = len(group_segments) - 1\n for j in range(nseg):\n ind = group_segments[j]\n P0 = Point(self._toplons[ind],\n self._toplats[ind],\n self._topdeps[ind])\n P1 = Point(self._toplons[ind + 1],\n self._toplats[ind + 1],\n self._topdeps[ind + 1])\n P2 = Point(self._botlons[ind + 1],\n self._botlats[ind + 1],\n self._botdeps[ind + 1])\n P3 = Point(self._botlons[ind],\n self._botlats[ind],\n self._botdeps[ind])\n P1up = Point(self._toplons[ind + 1],\n self._toplats[ind + 1],\n self._topdeps[ind + 1] - 1.0)\n P1N = Point(self._toplons[ind + 1],\n self._toplats[ind + 1] + 0.001,\n self._topdeps[ind + 1])\n P3up = Point(self._botlons[ind],\n self._botlats[ind],\n self._botdeps[ind] - 1.0)\n P3N = Point(self._botlons[ind],\n self._botlats[ind] + 0.001,\n self._botdeps[ind])\n p0 = Vector.fromPoint(P0)\n p1 = Vector.fromPoint(P1)\n p2 = Vector.fromPoint(P2)\n p3 = Vector.fromPoint(P3)\n p1up = Vector.fromPoint(P1up)\n p1N = Vector.fromPoint(P1N)\n p3up = Vector.fromPoint(P3up)\n p3N = Vector.fromPoint(P3N)\n\n # Sides\n s01 = p1 - p0\n s02 = p2 - p0\n s03 = p3 - p0\n s21 = p1 - p2\n s23 = p3 - p2\n\n # First triangle\n t1norm = (s02.cross(s01)).norm()\n a = s01.mag()\n b = s02.mag()\n c = s21.mag()\n s = (a + b + c) / 2\n A1 = np.sqrt(s * (s - a) * (s - b) * (s - c)) / 1000\n\n # Second triangle\n t2norm = (s03.cross(s02)).norm()\n a = s03.mag()\n b = s23.mag()\n c = s02.mag()\n s = (a + b + c) / 2\n A2 = np.sqrt(s * (s - a) * (s - b) * (s - c)) / 1000\n\n # Up and North\n p1up = (p1up - p1).norm()\n p3up = (p3up - p3).norm()\n p1N = (p1N - p1).norm()\n p3N = (p3N - p3).norm()\n\n # Combine\n norm_vec = norm_vec + A1 * t1norm + A2 * t2norm\n north_vec = north_vec + A1 * p1N + A2 * p3N\n up_vec = up_vec + A1 * p1up + A2 * p3up\n\n norm_vec = norm_vec.norm()\n north_vec = north_vec.norm()\n up_vec = up_vec.norm()\n\n # Do I need to flip the vector because it is pointing down (i.e.,\n # right-hand rule is violated)?\n flip = np.sign(up_vec.dot(norm_vec))\n norm_vec = flip * norm_vec\n\n # Angle between up_vec and norm_vec is dip\n self._dip = np.arcsin(up_vec.cross(norm_vec).mag()) * 180 / np.pi\n\n # Normal vector projected to horizontal plane\n nvph = (norm_vec - up_vec.dot(norm_vec) * up_vec).norm()\n\n # Dip direction is angle between nvph and north; strike is orthogonal.\n cp = nvph.cross(north_vec)\n sign = np.sign(cp.dot(up_vec))\n dp = nvph.dot(north_vec)\n strike = np.arctan2(sign * cp.mag(), dp) * 180 / np.pi - 90\n if strike < -180:\n strike = strike + 360\n self._strike = strike","def L2_norm(self):\n analyticals = self.analytical(self.x_values, self.C, self.D)\n error = analyticals - self.numerical\n self.L2 = np.sqrt((1/self.gp)*np.sum(error**2))","def get_l2_distance(x1, x2, y1, y2):\n return ((x1-y1)**2 + (x2-y2)**2)**0.5","def kl_latent_space(network, *args):\n\n z, log_det_J = network(*args)\n loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\n return loss","def ols_data():\n\n xs = [35.3, 29.7, 30.8, 58.8, 61.4, 71.3, 74.4, 76.7, 70.7, 57.5,\n 46.4, 28.9, 28.1, 39.1, 46.8, 48.5, 59.3, 70, 70, 74.5, 72.1,\n 58.1, 44.6, 33.4, 28.6]\n ys = [10.98, 11.13, 12.51, 8.4, 9.27, 8.73, 6.36, 8.50,\n 7.82, 9.14, 8.24, 12.19, 11.88, 9.57, 10.94, 9.58,\n 10.09, 8.11, 6.83, 8.88, 7.68, 8.47, 8.86, 10.36, 11.08]\n\n\n # self.Xk = 28.6\n # self.ypred_k = 0.3091\n solution = {'slope': -0.0798,\n 'y_intercept': 13.623,\n 'n': len(xs),\n 'pred_x': 28.6,\n 'pred_error': 0.309}\n\n return xs, ys, solution","def project_L2(w, l):\n return w * min(1, 1 / (l ** (1 / 2.0) * np.linalg.norm(w, 2)))","def topography(x,y):\n \n z = -x/10\n \n N = len(x)\n for i in range(N):\n # Step\n if 10 < x[i] < 12:\n z[i] += 0.4 - 0.05*y[i]\n \n # Constriction\n if 27 < x[i] < 29 and y[i] > 3:\n z[i] += 2\n \n # Pole\n if (x[i] - 34)**2 + (y[i] - 2)**2 < 0.4**2:\n z[i] += 2\n \n return z","def P2l_rec_norm(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 P2l_norm = np.copy(P2l)\n P2l_norm[2] *= P2l_norm_prefac(2)\n P2l_norm[3] *= P2l_norm_prefac(3)\n for ell in ells[4:]:\n # print ell, P2l[ell-1], P2l[ell-2]\n a = np.sqrt((4 * ell**2 - 1.) / (ell**2 - 4))\n b = cost * P2l_norm[ell - 1]\n c = np.sqrt(((ell - 1.)**2 - 4) /\n (4 * (ell - 1.)**2 - 1)) * P2l_norm[ell - 2]\n # print a,b,c\n P2l_norm[ell] = a * (b - c)\n # print ell, P2l_norm[ell], P2l_norm_prefac(ell)\n P2l[ell] = P2l_norm[ell] / P2l_norm_prefac(ell)\n return P2l","def MyKLD(X,Y): \n mu1,mu2 = tuple(np.mean(X,axis=0))\n sigma1,sigma2 = tuple(np.std(X,axis=0))\n m1,m2 = tuple(np.mean(X,axis=0))\n s1,s2 = tuple(np.std(X,axis=0))\n rho = np.corrcoef(X,rowvar=False)[0,1]\n r = np.corrcoef(Y,rowvar=False)[0,1]\n \n return (\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\n (2 * (1 - r**2)) +\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \n (sigma2**2-s2**2)/s2**2) /\n (2 * (1 - r**2)) +\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\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","def run_gradient_descent2(seed=0):\n\n colors = [color for color in matplotlib.colors.cnames]\n\n def random_point():\n return (3 * random.random() - 1, 3 * random.random() - 1)\n\n def f(x):\n \"\"\"has min at (1,0), saddle point at (-1,0)\"\"\"\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)\n\n def df(x):\n return ((1 - x[0]**2) * f(x), -2 * x[1] * f(x))\n\n for color in random.sample(colors, 50):\n path = take(100, gradient_descent(df, random_point()))\n for i, (x, y) in enumerate(path):\n plt.plot(x, y, color=color, marker='*', markersize=25-i/4)\n\n plt.show()","def beta_gen_lasso(p):\n cardi = 0.005\n return np.array([0]*int(p-int(cardi*p)) + [1]*int(cardi*p))","def bcL(self, rng=None):\n if rng is None:\n rng = random.PRNGKey(1)\n n = self.n\n x = onp.sin(self.bcmesh * np.pi)\n n_y = (np.floor((n + 1) / 2) - 1).astype(int)\n if rng is not None:\n coeffs = random.multivariate_normal(rng, np.zeros(16),\n np.diag(np.ones(16)))\n else:\n key = random.randint(random.PRNGKey(1), (1,), 1, 1000)\n coeffs = random.multivariate_normal(\n random.PRNGKey(key[0]), np.zeros(16), np.diag(np.ones(16)))\n left = coeffs[0] * x**3 + coeffs[1] * x**2 + coeffs[2] * x #+ coeffs[3]\n right = coeffs[4] * x**3 + coeffs[5] * x**2 + coeffs[6] * x #+ coeffs[7]\n lower = coeffs[8] * x**3 + coeffs[9] * x**2 + coeffs[10] * x #+ coeffs[11]\n upper = coeffs[12] * x**3 + coeffs[13] * x**2 + coeffs[14] * x #+ coeffs[15]\n shape = 2 * x.shape\n source = onp.zeros(shape)\n source[0, :] = upper\n source[n_y - 1, n_y - 1:] = lower[:n - n_y + 1]\n source[n_y - 1:, n_y - 1] = right[:n - n_y + 1]\n source[:, 0] = left\n source[-1, :n_y - 1] = right[n:n - n_y:-1]\n source[:n_y - 1, -1] = lower[n:n - n_y:-1]\n # because this makes the correct order of boundary conditions\n return source * (n + 1)**2","def d2(x0,y0,x1,y1):\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)","def coordinate_descent(X, y, lam, theta=None, maxit=10000, eta=1e-8):\n \n n, m = X.shape\n \n # initialize the coefficients\n if theta is None: theta = np.random.randn(m, 1)\n \n # compute squared columns\n v = np.diag(np.dot(X.T, X))\n \n # coordinate optimization\n i = 0\n chg = 1\n theta_old = np.empty((m, 1))\n Xtheta = np.dot(X, theta)\n while i < maxit and chg > eta:\n i += 1\n theta_old = theta.copy()\n for j in range(m): \n Xtheta -= theta[j]*np.atleast_2d(X[:,j]).T\n alpha = np.dot(X[:,j].T, y - Xtheta)\n if abs(alpha) > lam: \n theta[j] = np.sign(alpha) * (abs(alpha) - lam) / v[j]\n Xtheta += theta[j]*np.atleast_2d(X[:,j]).T\n else:\n theta[j] = 0\n chg = np.sum((theta - theta_old)**2)/np.sum(theta_old**2)\n \n return theta, i","def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\n cells = misc.get_line(start_cell, end_cell) \n pnts = []\n elev = []\n \n dem_elv = dem[:,1]\n dem_indx = dem[:,2:4]\n\n for cell in cells:\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\n #xy_indx=[str(cell[0]),str(cell[1])]\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\n try:\n z=dem_elv[z_indx][0]\n except (np.sum(z_indx)>1):\n print(\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\")\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\n z = float(dem_elv[z_indx])\n pnts.append((x, y))\n elev.append(z)\n return pnts, elev","def hausdorffDistance13(self,id1,id2):\n #productive #math\n profprint()\n node1 = slicer.mrmlScene.GetNodeByID(id1)\n polydata1=node1.GetPolyData()\n node2 = slicer.mrmlScene.GetNodeByID(id2)\n polydata2=node2.GetPolyData()\n nb1 = polydata1.GetNumberOfPoints()\n nb2 = polydata2.GetNumberOfPoints()\n minimum=None\n maximum=None\n JJ,jj=None,None\n II,ii=None,None\n pt1=[0,0,0]\n pt2=[0,0,0]\n polydata1.GetPoint(1,pt1)\n polydata1.GetPoint(nb1-1,pt2)\n minVal1=min(pt1[2],pt2[2])\n maxVal1=max(pt1[2],pt2[2])\n pt1=[0,0,0]\n pt2=[0,0,0]\n pt1b,pt2b=None,None\n polydata2.GetPoint(1,pt1)\n polydata2.GetPoint(nb2-1,pt2)\n minVal2 = min(pt1[2],pt2[2])\n maxVal2 = max(pt1[2],pt2[2])\n valueBase=max(minVal1,minVal2)\n valueTip=min(maxVal1,maxVal2)\n cellId=vtk.mutable(1)\n subid=vtk.mutable(1)\n dist=vtk.mutable(1)\n cl2=vtk.vtkCellLocator()\n cl2.SetDataSet(polydata2)\n cl2.BuildLocator()\n # Hausforff 1 -> 2\n minima=[]\n for i in range(int(nb1/float(100))):\n pt=[0,0,0]\n polydata1.GetPoint(100*i,pt)\n closest=[0,0,0]\n cl2.FindClosestPoint(pt,closest,cellId,subid,dist)\n if abs(closest[2]-pt[2])<=1:\n minima.append(self.distance(pt,closest))\n else:\n minima.append(0)\n hausdorff12 = max(minima)\n \n # Hausforff 2 -> 1\n minima=[]\n cl1=vtk.vtkCellLocator()\n cl1.SetDataSet(polydata1)\n cl1.BuildLocator()\n for i in range(int(nb2/float(10))):\n pt=[0,0,0]\n polydata2.GetPoint(10*i,pt)\n closest=[0,0,0]\n cl1.FindClosestPoint(pt,closest,cellId,subid,dist)\n if abs(closest[2]-pt[2])<=1:\n minima.append(self.distance(pt,closest))\n else:\n minima.append(0)\n hausdorff21 = max(minima)\n return max(hausdorff12,hausdorff21)","def lloyds_algorithm(X, k, T):\n n, d = X.shape\n\n # Initialize clusters random.\n clustering = np.random.randint(0, k, (n,))\n centroids = np.zeros((k, d))\n\n # Used to stop if cost isn't improving (decreasing)\n cost = 0\n oldcost = 0\n\n # Column names\n # print(\"Iterations\\tCost\")\n for i in range(T):\n\n # Update centroid\n centroids = np.zeros((k, d))\n # YOUR CODE HERE\n numberOfPointsInClusters = np.zeros((k,))\n for idx, point in enumerate(clustering):\n numberOfPointsInClusters[point] += 1\n centroids[point] += X[idx]\n for n in range(k):\n if numberOfPointsInClusters[n] == 0:\n numberOfPointsInClusters[n] = float('-inf')\n centroids = [centroid / numberOfPointsInClusters[idx] for idx, centroid in enumerate(centroids)]\n # END CODE\n\n # Update clustering\n\n # YOUR CODE HERE\n for idx, point in enumerate(X):\n clustering[idx] = np.argmin([np.linalg.norm(point - cluster) for cluster in centroids])\n # END CODE\n\n # Compute and print cost\n cost = 0\n for j in range(n):\n cost += np.linalg.norm(X[j] - centroids[clustering[j]]) ** 2\n # print(i + 1, \"\\t\\t\", cost)\n\n # Stop if cost didn't improve more than epislon (decrease)\n if np.isclose(cost, oldcost): break # TODO\n oldcost = cost\n\n return clustering, centroids, cost","def pointfind2(plat, plon, lat, lon, pdif=1):\n\n\tdist_min = 1000000.\n\t\n\t\n\tfor i in range(lon.shape[0]):\n\t\tfor j in range(lon.shape[1]):\n\t\t\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\n\t\t\tif dist_min > dist:\n\t\t\t\tdist_min = dist\n\t\t\t\ti_min = i\n\t\t\t\tj_min = j\n\t\t\t\tlat_min = lat[i,j]\n\t\t\t\tlon_min = lon[i,j]\n\t\n\tprint(i_min,j_min,lat_min,lon_min)\n\tgg1 = i_min, j_min\n\t\n\treturn(gg1, lat_min, lon_min)","def frame3dlin_Kg(E,A1,A2,L,Te1,Te2,R=None):\n Kge1= np.array([\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , 0 , (A2*E)/(10*L) , 0 , -((A2+3*A1)*E)/30 , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0],\n [0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+3*A1)*E)/30 , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , 0 , (A1*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0 , 0 , 0 , -(A1*E)/(10*L) , 0 , -((3*A2+A1)*E)/30 , 0],\n [0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60 , 0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((3*A2+A1)*E)/30]\n ])\n Kge2= np.array([\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+3*A1)*E)/30 , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0],\n [0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+3*A1)*E)/30 , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\n [0 , 0 , -(A1*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0 , 0 , 0 , (A1*E)/(10*L) , 0 , ((3*A2+A1)*E)/30 , 0],\n [0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60 , 0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((3*A2+A1)*E)/30]])\n\n Kg = Kge1*Te1 + Kge2*Te2\n\n if (R is not None):\n RR = scipy.linalg.block_diag(R,R,R,R)\n Kg = np.transpose(RR).dot(Kg.dot(RR))\n\n return Kg","def test_lu_forward_sub():\t\n\t# test 1\n\tL = np.array([\n\t\t[ 2, 3,-4, 2],\n\t\t[-2, 1,-2, 1],\n\t\t[ 1,-1, 3,-1],\n\t\t[-3, 2, 2, 2]])\t\n\n\tb = np.array([4, -8, 9, 6])\n\n\ty = lu_forward_sub(L, b) \t\t\n\ty_soln = np.array([4,0,5,8])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y - y_soln) < 1.e-10\n\n\t# test 2\n\tL2 = np.array([\n\t\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\n\t\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\n\t\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\n\t\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\n\t\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\n\t\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\n\t\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\n\t\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\n\n\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\n\n\ty2 = lu_forward_sub(L2, b2) \t\t\n\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y2 - y_soln2) < 1.e-10","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\n \n for j in range(self.feature_count): # Loop over each feature\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \n numerator = single_word_count + self.alpha\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\n \n start_index = end_index","def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\n \n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\n# epsx = (1/2)*(eps1+eps2)\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\n \n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))","def laplace2d(get_A, get_rho, N=Mynum, Te=2):\n # Reduce the row and column of Laplacian matrix by 2 \n # Reduced row and column will be replace with embed in future\n # n = N - 2 for embed\n n = N\n # Solving for the PDE(1)\n h = 1.0/(n-1)\n A = get_A(n) * (1/(h**2))\n b = get_rho(n, Te)\n U = sp.linalg.solve(A, b)\n\n # Reshape the u vector into nxn matrix for heat map plotting\n T = U.reshape((n, n))\n print T\n \n # Embed the surrounding of U matrix into zeros\n Tfull = embed(T, Te)\n\n # Verify that dot function of A matrix and U vector\n # return the same rho value at midpoint\n CheckU = np.dot(A,U)\n\n # Filter very small value into zeros\n for i in range(0,len(CheckU)):\n if (abs(CheckU[i]) < 1e-12):\n CheckU[i] = 0\n\n # Validate that product of A and U matrix is the same as rho vector\n # Will give warning if it is not the same\n # assert np.all(CheckU == b) # working only mynum = 7 and 9 \n\n # Print value of the products at midpoint.\n mid = (n**2-1)/2\n print \"Q1: Value of the dot product A.u1 is %5.3f at (0.5,0.5).\" % (CheckU[mid])\n return Tfull","def block_levinson(y, L):\n d = L.shape[1] # Block dimension\n N = int(L.shape[0]/d) # Number of blocks\n\n # This gets the bottom block row B from the left block column L\n B = np.reshape(L, [d, N, d], order='F')\n B = B.swapaxes(1, 2)\n B = B[..., ::-1]\n B = np.reshape(B, [d, N*d], order='F')\n\n f = np.linalg.inv(L[:d, :]) # \"Forward\" vector\n b = f # \"Backward\" vector\n x = np.dot(f, y[:d]) # Solution vector\n\n Ai = np.eye(2*d)\n G = np.zeros((d*N, 2*d))\n for n in range(2, N+1):\n ef = np.dot(B[:, (N-n)*d:N*d], np.vstack((f, np.zeros((d, d)))))\n eb = np.dot(L[:n*d, :].T, np.vstack((np.zeros((d, d)), b)))\n ex = np.dot(B[:, (N-n)*d:N*d], np.vstack((x, np.zeros((d, 1)))))\n Ai[:d, d:] = eb\n Ai[d:, :d] = ef\n A = np.linalg.inv(Ai)\n l = d*(n-1)\n G[:l, :d] = f\n G[d:l+d, d:] = b\n fn = np.dot(G[:l+d, :], A[:, :d])\n bn = np.dot(G[:l+d, :], A[:, d:])\n f = fn\n b = bn\n x = np.vstack((x, np.zeros((d, 1)))) + np.dot(b, y[(n-1)*d:n*d]-ex)\n\n W = x","def __solve_alternative_linear_problem(self, user):\n result = [0] * self.layout_slots\n de_rand_approach = \"greedy\"\n bins_per_category = []\n bins_cardinality = []\n for _ in range(len(self.categories)):\n bins_per_category.append([])\n bins_cardinality.append([])\n\n for cat in range(len(self.categories)):\n for _ in range(len(self.news_row_pivots) + 1):\n bins_per_category[cat].append([])\n bins_cardinality[cat].append([])\n for _ in range(len(self.news_column_pivots) + 1):\n bins_per_category[cat][-1].append([])\n bins_cardinality[cat][-1].append(0)\n\n for news in self.news_pool:\n category_index = self.categories.index(news.news_category)\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\n bins_per_category[category_index][x][y].append(news)\n bins_cardinality[category_index][x][y] += 1\n\n index = 0\n bin_samples = []\n for cat in range(len(self.categories)):\n for x in range(len(self.news_row_pivots) + 1):\n for y in range(len(self.news_column_pivots) + 1):\n if (y == 0) and (x != 0):\n continue\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\n index += 1\n try:\n selected_news = np.random.choice(bins_per_category[cat][x][y])\n self.sample_quality(selected_news, user, interest_decay=True)\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\n except ValueError:\n bin_samples += [0] * self.layout_slots\n\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\n\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\n slots_assegnation_probabilities = []\n slot_counter = 0\n tmp_slot_probabilities = []\n while slot_counter < self.layout_slots:\n i = slot_counter\n while i < len(linear_problem.x):\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\n i += self.layout_slots\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\n tmp_slot_probabilities.clear()\n slot_counter += 1\n\n slot_promenances = self.real_slot_promenances.copy()\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\n slots_nr = [s for s in range(0, self.layout_slots)]\n for i in range(self.layout_slots):\n if de_rand_approach == \"ordered\":\n k = i\n elif (de_rand_approach == \"greedy\") or (de_rand_approach == \"greedy_max\"):\n k = np.argmax(slot_promenances)\n slot_promenances[k] = 0\n elif de_rand_approach == \"randomized\":\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\n slot_promenances[k] = 0\n else:\n raise RuntimeError(\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \"\n \"'randomized' or 'greedy_max'.\")\n\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\n if de_rand_approach == \"greedy_max\":\n assigning_bin_index = np.argmax(target_slot_probabilities)\n cat_index = int(assigning_bin_index / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin_index)][0]\n y = self.bins_for_position[int(assigning_bin_index)][1]\n\n else:\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\n cat_index = int(assigning_bin / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin)][0]\n y = self.bins_for_position[int(assigning_bin)][1]\n\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\n\n return result","def calcLatLon(northing, easting):\n from math import asin, atan2, cos, log, pow, sin, sqrt\n\n # CONSUS Albers variables (EPSG: 5070)\n RE_NAD83 = 6378137.0\n E_NAD83 = 0.0818187034 # Eccentricity\n D2R = 0.01745329251 # Pi/180\n standardParallel1 = 43.\n standardParallel2 = 47.\n centralMeridian = -114.\n originLat = 30\n originLon = 0\n\n m1 = cos(standardParallel1 * D2R) / \\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel1 * D2R)), 2.0))\n m2 = cos(standardParallel2 * D2R) / \\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel2 * D2R)), 2.0))\n\n def calcPhi(i):\n sinPhi = sin(i * D2R)\n return (1.0 - pow(E_NAD83, 2.0)) * \\\n ((sinPhi/(1.0 - pow((E_NAD83 * sinPhi), 2.0))) -\n 1.0/(2.0 * E_NAD83) *\n log((1.0 - E_NAD83 * sinPhi)/(1.0 + E_NAD83 * sinPhi)))\n\n q0 = calcPhi(originLat)\n q1 = calcPhi(standardParallel1)\n q2 = calcPhi(standardParallel2)\n nc = (pow(m1, 2.0) - pow(m2, 2.0)) / (q2 - q1)\n C = pow(m1, 2.0) + nc * q1\n rho0 = RE_NAD83 * sqrt(C - nc * q0) / nc\n rho = sqrt(pow(easting, 2.0) + pow((rho0 - northing), 2.0))\n q = (C - pow((rho * nc / RE_NAD83), 2.0)) / nc\n beta = asin(q / (1.0 - log((1.0 - E_NAD83) / (1.0 + E_NAD83)) *\n (1.0 - pow(E_NAD83, 2.0))/(2.0 * E_NAD83)))\n a = 1.0 / 3.0 * pow(E_NAD83, 2.0) + 31.0 / 180.0 * \\\n pow(E_NAD83, 4.0) + 517.0 / 5040.0 * pow(E_NAD83, 6.0)\n b = 23.0/360.0 * pow(E_NAD83, 4.0) + 251.0 / 3780.0 * pow(E_NAD83, 6.0)\n c = 761.0/45360.0 * pow(E_NAD83, 6.0)\n theta = atan2(easting, (rho0 - northing))\n\n lat = (beta + a * sin(2.0 * beta) + b * sin(4.0 * beta) +\n c * sin(6.0 * beta))/D2R\n lon = centralMeridian + (theta / D2R) / nc\n coords = [lat, lon]\n\n return coords","def ftlan_E1c(hop, v0, T, m=50, Min_b=10e-10, Min_m=5, kB=1, norm = np.linalg.norm):\n# def Tri_diag(a1, b1):\n# mat = np.diag(b1, -1) + np.diag(a1, 0) + np.diag(b1, 1)\n# e, w = np.linalg.eigh(mat)\n# return e, w\n\n beta = 1./(T * kB)\n E = 0.\n a, b = [], []\n v0 = v0/norm(v0)\n Hv = hop(v0)\n a.append(v0.dot(Hv))\n v1 = Hv - a[0] * v0\n b.append(norm(v1))\n if b[0] < Min_b:\n return 0\n\n v1 = v1/b[0]\n Hv = hop(v1)\n a.append(v1.dot(Hv))\n\n for i in range(1, m - 1):\n v2 = Hv - b[i - 1] * v0 - a[i] * v1\n b.append(norm(v2))\n if abs(b[i]) < Min_b:\n b.pop()\n break\n\n v2 = v2/b[i]\n Hv = hop(v2)\n a.append(v2.dot(Hv))\n v0 = v1.copy()\n v1 = v2.copy()\n \n a = np.asarray(a)\n b = np.asarray(b)\n\n eps, phi = Tri_diag(a, b)\n l = len(eps)\n# Eo = eps[0]\n# eps = eps-Eo\n exp_eps = np.exp(-beta * eps)\n E = np.sum(exp_eps * eps * phi[0, :]**2.)\n Z = np.sum(exp_eps * phi[0, :]**2.)\n# for i in range(len(eps)):\n# E += exp_eps[i] * eps[i] * phi[0, i]**2\n\n# E = E + Eo\n# de = eps[:, np.newaxis] - eps\n# for i in range(l):\n# E += eps[i] * phi[0, i]**2./np.sum(np.exp(-beta*de[:l, i])*(phi[0, :l]**2.))\n return E, Z"],"string":"[\n \"def method2(self):\\n cres=np.zeros(self.NL,dtype=float) # List of invariants\\n # The U matrices from Fukui's method; storage...\\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n for il in range(self.NL):\\n # ... and calculation of U matrices for each layer\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.LDM[il,ix ,iy ,:,:]\\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\\n \\n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\\n \\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\\n \\n return cres\",\n \"def test_el_below_lcl():\\n p = [902.1554, 897.9034, 893.6506, 889.4047, 883.063, 874.6284, 866.2387, 857.887,\\n 849.5506, 841.2686, 833.0042, 824.7891, 812.5049, 796.2104, 776.0027, 751.9025,\\n 727.9612, 704.1409, 680.4028, 656.7156, 629.077, 597.4286, 565.6315, 533.5961,\\n 501.2452, 468.493, 435.2486, 401.4239, 366.9387, 331.7026, 295.6319, 258.6428,\\n 220.9178, 182.9384, 144.959, 106.9778, 69.00213] * units.hPa\\n t = [-3.039381, -3.703779, -4.15996, -4.562574, -5.131827, -5.856229, -6.568434,\\n -7.276881, -7.985013, -8.670911, -8.958063, -7.631381, -6.05927, -5.083627,\\n -5.11576, -5.687552, -5.453021, -4.981445, -5.236665, -6.324916, -8.434324,\\n -11.58795, -14.99297, -18.45947, -21.92021, -25.40522, -28.914, -32.78637,\\n -37.7179, -43.56836, -49.61077, -54.24449, -56.16666, -57.03775, -58.28041,\\n -60.86264, -64.21677] * units.degC\\n td = [-22.08774, -22.18181, -22.2508, -22.31323, -22.4024, -22.51582, -22.62526,\\n -22.72919, -22.82095, -22.86173, -22.49489, -21.66936, -21.67332, -21.94054,\\n -23.63561, -27.17466, -31.87395, -38.31725, -44.54717, -46.99218, -43.17544,\\n -37.40019, -34.3351, -36.42896, -42.1396, -46.95909, -49.36232, -48.94634,\\n -47.90178, -49.97902, -55.02753, -63.06276, -72.53742, -88.81377, -93.54573,\\n -92.92464, -91.57479] * units.degC\\n prof = parcel_profile(p, t[0], td[0]).to('degC')\\n el_p, el_t = el(p, t, td, prof)\\n assert_nan(el_p, p.units)\\n assert_nan(el_t, t.units)\",\n \"def LEIsotropic2D(self):\\n const = self.ymod / ((1+self.Nu) * (1-(2*self.Nu)))\\n a = const * self.Nu\\n b = const * (1-self.Nu)\\n c = const * 0.5 * (1-2*self.Nu)\\n Cmat = np.array(\\n [\\n [b, a, 0],\\n [a, b, 0],\\n [0, 0, c],\\n ], dtype=float)\\n stress_el = Cmat @ self.eps\\n return stress_el, Cmat\",\n \"def test_2():\\n\\n # generate two locusts of points\\n npts = 100\\n epsilon = 0.001\\n # #cluster 1\\n coords1 = generate_locus_of_3d_points(npts, 0.1, 0.1, 0.1, epsilon=epsilon)\\n # cluster 2\\n coords2 = generate_locus_of_3d_points(npts, 0.9, 0.9, 0.9, epsilon=epsilon)\\n\\n # generate orientation vectors for cluster 1\\n vectors1 = generate_aligned_vectors(len(coords1))\\n\\n # calculate dot product between vectors1 and cluster 2\\n r = np.sqrt((0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2 + (0.9 - 0.1) ** 2)\\n # s, vector between coords1 and cluster2\\n s = np.zeros((npts, 3))\\n s[:, 0] = 0.9 - coords1[:, 0]\\n s[:, 1] = 0.9 - coords1[:, 1]\\n s[:, 2] = 0.9 - coords1[:, 2]\\n\\n # calculate dot product between orientation and direction between cluster 1 and 2\\n angles = angles_between_list_of_vectors(vectors1, s)\\n avg_two_costheta_1 = np.mean(np.cos(2.0 * angles))\\n avg_two_costheta_2 = np.mean(2.0 * np.cos(angles) * np.cos(angles) - 1.0)\\n assert np.isclose(\\n avg_two_costheta_1, avg_two_costheta_2\\n ) # test trig identify used in weighting function\\n avg_two_costheta = avg_two_costheta_2\\n\\n # define radial bins\\n rbins = np.array([0.0, 0.1, r + 2.0 * epsilon])\\n\\n # define weights appropiate for weighting function\\n weights1 = np.ones((npts, 4))\\n weights1[:, 1] = vectors1[:, 0]\\n weights1[:, 2] = vectors1[:, 1]\\n weights1[:, 3] = vectors1[:, 2]\\n weights2 = np.ones(npts)\\n\\n # calculate weighted counts\\n weighted_counts, counts = positional_marked_npairs_3d(\\n coords1,\\n coords2,\\n rbins,\\n period=None,\\n weights1=weights1,\\n weights2=weights2,\\n weight_func_id=2,\\n num_threads=1,\\n )\\n\\n msg = \\\"weighted counts do not match expected result given the weighting function\\\"\\n assert np.isclose(\\n weighted_counts[-1], avg_two_costheta * counts[-1], rtol=1.0 / npts\\n ), msg\",\n \"def lagrangePoints(mu):\\n \\n # define l = 1-mu\\n l = 1 - mu\\n \\n # collinear points\\n def eqL1(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)+mu-l)*x**2 + (mu**2*l**2+2*(l**2+mu**2))*x + mu**3-l**3\\n #fval = gamma**5 - (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 + 2*mu*gamma - mu\\n return fval\\n sol_l1 = optimize.root(eqL1, 0.5, method='hybr')\\n l1 = np.array([sol_l1.x[0] , 0, 0])\\n \\n def eqL2(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*l*mu+mu**2)*x**3 + (2*mu*l*(l-mu)-(mu+l))*x**2 + (mu**2*l**2+2*(l**2-mu**2))*x - (mu**3+l**3)\\n #fval = gamma**5 + (3-mu)*gamma**4 + (3-2*mu)*gamma**3 - mu*gamma**2 - 2*mu*gamma - mu\\n return fval\\n sol_l2 = optimize.root(eqL2, 1.5, method='hybr')\\n l2 = np.array([sol_l2.x[0] , 0, 0])\\n \\n def eqL3(x):\\n fval = x**5 + 2*(mu-l)*x**4 + (l**2-4*mu*l+mu**2)*x**3 + (2*mu*l*(l-mu)+(l+mu))*x**2 + (mu**2*l**2+2*(mu**2-l**2))*x + l**3+mu**3\\n return fval\\n sol_l3 = optimize.root(eqL3, -1, method='hybr')\\n l3 = np.array([sol_l3.x[0] , 0, 0])\\n \\n # equilateral points\\n # L4\\n l4 = np.array([np.cos(np.pi/3) - mu , np.sin(np.pi/3), 0])\\n # L5\\n l5 = np.array([np.cos(np.pi/3) - mu , -np.sin(np.pi/3), 0])\\n \\n return _lagrangePointsReturn(l1,l2,l3,l4,l5)\",\n \"def le(self, x, y):\",\n \"def lorentzian2d(p, x, y):\\n #2012-02-04 11:38 IJMC: Created\\n \\n x = array(x, dtype=float).copy()\\n y = array(y, dtype=float).copy()\\n p = array(p).copy()\\n\\n if len(p)==5:\\n p = concatenate((p, [0, 0]))\\n elif len(p)==6:\\n p = concatenate((p, [0]))\\n\\n z = ((x - p[3]) / p[1])**2 + ((y - p[4]) / p[2])**2 + p[5] * (x - p[3]) * (y - p[4])\\n \\n return p[6] + p[0]/(1. + z)\",\n \"def lherzolite():\\n\\n rho = 3270.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 190.; C[2,3] = 0.38; C[2,4] = 2.38; C[2,5] = -0.12\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 67.9; C[3,4] = -2.12; C[3,5] = 1.6\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 63.12; C[4,5] = -0.55\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 66.83\\n\\n return C, rho\",\n \"def dist_vincenty(lat1, lon1, lat2, lon2, iterations=20):\\r\\n if lat1 < -90 or lat1 > 90 or lat2 < -90 or lat2 > 90 or lon1 < -180 or lon1 > 180 or lon2 < -180 or lon2 > 180:\\r\\n raise ValueError(\\r\\n \\\"Latitude values shoulds range from (-90,90) and longitude from (-180,180) but one of the input values is out of bounds. Latitude_1: %f, Logitude_1: %f, Latitude_2: %f, Logitude_2: %f\\\" %\\r\\n (lat1, lon1, lat2, lon2))\\r\\n\\r\\n major, minor, f = 6378137, 6356752.314245, 1 / 298.257223563\\r\\n\\r\\n lat1, lng1, lat2, lng2 = radians(\\r\\n lat1), radians(lon1), radians(lat2), radians(lon2)\\r\\n delta_lng = lng2 - lng1\\r\\n reduced_lat1, reduced_lat2 = atan(\\r\\n (1 - f) * tan(lat1)), atan((1 - f) * tan(lat2))\\r\\n\\r\\n sin_reduced1, cos_reduced1 = sin(reduced_lat1), cos(reduced_lat1)\\r\\n sin_reduced2, cos_reduced2 = sin(reduced_lat2), cos(reduced_lat2)\\r\\n\\r\\n lambda_lng = delta_lng\\r\\n lambda_prime = 2 * pi\\r\\n while abs(lambda_lng - lambda_prime) > 10e-12 and iterations > 0:\\r\\n sin_lambda_lng, cos_lambda_lng = sin(lambda_lng), cos(lambda_lng)\\r\\n\\r\\n sin_sigma = sqrt(\\r\\n (cos_reduced2 * sin_lambda_lng) ** 2 +\\r\\n (cos_reduced1 * sin_reduced2 -\\r\\n sin_reduced1 * cos_reduced2 * cos_lambda_lng) ** 2\\r\\n )\\r\\n if sin_sigma == 0:\\r\\n return 0 # Coincident points\\r\\n\\r\\n cos_sigma = (\\r\\n sin_reduced1 * sin_reduced2 +\\r\\n cos_reduced1 * cos_reduced2 * cos_lambda_lng\\r\\n )\\r\\n sigma = atan2(sin_sigma, cos_sigma)\\r\\n\\r\\n sin_alpha = (cos_reduced1 * cos_reduced2 * sin_lambda_lng / sin_sigma)\\r\\n cos_sq_alpha = 1 - sin_alpha ** 2\\r\\n\\r\\n if cos_sq_alpha != 0:\\r\\n cos2_sigma_m = cos_sigma - 2 * \\\\\\r\\n (sin_reduced1 * sin_reduced2 / cos_sq_alpha)\\r\\n else:\\r\\n cos2_sigma_m = 0.0 # Equatorial line\\r\\n\\r\\n C = f / 16. * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))\\r\\n\\r\\n lambda_prime = lambda_lng\\r\\n lambda_lng = (\\r\\n delta_lng + (1 - C) * f * sin_alpha * (\\r\\n sigma + C * sin_sigma * (\\r\\n cos2_sigma_m + C * cos_sigma * (-1 + 2 * cos2_sigma_m ** 2)\\r\\n )\\r\\n )\\r\\n )\\r\\n iterations -= 1\\r\\n\\r\\n if iterations == 0:\\r\\n raise ValueError(\\\"Vincenty formula failed to converge!\\\")\\r\\n\\r\\n u_sq = cos_sq_alpha * (major ** 2 - minor ** 2) / minor ** 2\\r\\n A = 1 + u_sq / 16384. * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))\\r\\n B = u_sq / 1024. * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))\\r\\n delta_sigma = B * sin_sigma * (\\r\\n cos2_sigma_m + B / 4. * (cos_sigma * (-1 + 2 * cos2_sigma_m ** 2) -\\r\\n B / 6. * cos2_sigma_m * (-3 + 4 * sin_sigma ** 2) *\\r\\n (-3 + 4 * cos2_sigma_m ** 2))\\r\\n )\\r\\n s = minor * A * (sigma - delta_sigma)\\r\\n\\r\\n return round(s, 3) # round to 1mm precision\\r\",\n \"def potentialSolver5(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def I(x, y, l, p):\\n \\n return 0.5 / (mu * c) * A0**2 * ( u(x, y, l, p) )**2\",\n \"def __init__(self, \\n nd = 2, \\n goal = np.array([1.0,1.0]),\\n state_bound = [[0,1],[0,1]],\\n nA = 4,\\n action_list = [[0,1],[0,-1],[1,0],[-1,0]],\\n<<<<<<< HEAD:archive-code/puddleworld.py\\n ngrid = [10.0,10.0],\\n maxStep = 40):\\n ngrid = [40, 40]\\n x_vec = np.linspace(0,1,ngrid[0])\\n y_vec = np.linspace(0,1,ngrid[1])\\n for x in x_vec:\\n for y in y_vec:\\n if ~self.inPuddle([x,y]):\\n puddle.append([x,y])\\n # puddle is a closed loop \\n outpuddlepts = np.asarray(puddle)\\n \\\"\\\"\\\"\\n\\n\\n # Horizontal wing of puddle consists of \\n # 1) rectangle area xch1<= x <=xc2 && ych1-radius <= y <=ych2+radius\\n # (xchi,ychi) is the center points (h ==> horizantal)\\n # x, y = state[0], state[1]\\n xch1, ych1 = 0.3, 0.7\\n xch2, ych2 = 0.65, ych1\\n radius = 0.1\\n\\n\\n #Vertical wing of puddle consists of \\n # 1) rectangle area xcv1-radius<= x <=xcv2+radius && ycv1 <= y <= ycv2\\n # where (xcvi,ycvi) is the center points (v ==> vertical)\\n xcv1 = 0.45; ycv1=0.4;\\n xcv2 = xcv1; ycv2 = 0.8;\\n\\n # % 2) two half-circle at end edges of rectangle\\n \\n # POINTS ON HORIZANTAL LINES OF PUDDLE BOUNDARY\\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n puddle.append([xcv1-radius,ych1-radius])\\n \\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1-radius])\\n \\n for x in np.arange(xch1,xcv1-radius,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n \\n puddle.append([xcv1-radius,ych1+radius])\\n\\n\\n for x in np.arange(xcv1+radius,xch2,self.meshsize[0]/2):\\n puddle.append([x,ych1+radius])\\n\\n # POINTS ON VERTICAL LINES OF PUDDLE BOUNDARY\\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1-radius,y])\\n \\n for y in np.arange(ycv1,ych1-radius,self.meshsize[1]/2):\\n puddle.append([xcv1+radius,y])\\n \\\"\\\"\\\"\\n for y in np.arrange():\\n puddle.append([])\\n \\n for y in np.arrange():\\n puddle.append([])\\n \\\"\\\"\\\"\\n\\n # HALF CIRCLES\\n ngridTheta = 10\\n thetaVec = np.linspace(0,pi,ngridTheta)\\n\\n for t in thetaVec:\\n puddle.append([xch1+radius*np.cos(pi/2+t),ych1+radius*np.sin(pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xch2+radius*np.cos(-pi/2+t),ych2+radius*np.sin(-pi/2+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv1+radius*np.cos(pi+t),ycv1+radius*np.sin(pi+t)])\\n\\n for t in thetaVec:\\n puddle.append([xcv2+radius*np.cos(t),ycv2+radius*np.sin(t)])\\n\\n \\n outpuddlepts = np.asarray(puddle)\\n return outpuddlepts\",\n \"def light_source_directions():\\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\\n [-0.05939919, -0.33739538, 0.93948714],\\n [-0.05710194, -0.21230722, 0.97553319],\\n [-0.05360061, -0.07800089, 0.99551134],\\n [-0.04919816, 0.05869781, 0.99706274],\\n [-0.04399823, 0.19019233, 0.98076044],\\n [-0.03839991, 0.31049925, 0.9497977],\\n [-0.03280081, 0.41611025, 0.90872238],\\n [-0.18449839, -0.43989616, 0.87889232],\\n [-0.18870114, -0.32950199, 0.92510557],\\n [-0.1901994, -0.20549935, 0.95999698],\\n [-0.18849605, -0.07269848, 0.97937948],\\n [-0.18329657, 0.06229884, 0.98108166],\\n [-0.17500445, 0.19220488, 0.96562453],\\n [-0.16449474, 0.31129005, 0.93597008],\\n [-0.15270716, 0.4160195, 0.89644202],\\n [-0.30139786, -0.42509698, 0.85349393],\\n [-0.31020115, -0.31660118, 0.89640333],\\n [-0.31489186, -0.19549495, 0.92877599],\\n [-0.31450962, -0.06640203, 0.94692897],\\n [-0.30880699, 0.06470146, 0.94892147],\\n [-0.2981084, 0.19100538, 0.93522635],\\n [-0.28359251, 0.30729189, 0.90837601],\\n [-0.26670649, 0.41020998, 0.87212122],\\n [-0.40709586, -0.40559588, 0.81839168],\\n [-0.41919869, -0.29999906, 0.85689732],\\n [-0.42618633, -0.18329412, 0.88587159],\\n [-0.42691512, -0.05950211, 0.90233197],\\n [-0.42090385, 0.0659006, 0.90470827],\\n [-0.40860354, 0.18720162, 0.89330773],\\n [-0.39141794, 0.29941372, 0.87013988],\\n [-0.3707838, 0.39958255, 0.83836338],\\n [-0.499596, -0.38319693, 0.77689378],\\n [-0.51360334, -0.28130183, 0.81060526],\\n [-0.52190667, -0.16990217, 0.83591069],\\n [-0.52326874, -0.05249686, 0.85054918],\\n [-0.51720021, 0.06620003, 0.85330035],\\n [-0.50428312, 0.18139393, 0.84427174],\\n [-0.48561334, 0.28870793, 0.82512267],\\n [-0.46289771, 0.38549809, 0.79819605],\\n [-0.57853599, -0.35932235, 0.73224555],\\n [-0.59329349, -0.26189713, 0.76119165],\\n [-0.60202327, -0.15630604, 0.78303027],\\n [-0.6037003, -0.04570002, 0.7959004],\\n [-0.59781529, 0.06590169, 0.79892043],\\n [-0.58486953, 0.17439091, 0.79215873],\\n [-0.56588359, 0.27639198, 0.77677747],\\n [-0.54241965, 0.36921337, 0.75462733],\\n [0.05220076, -0.43870637, 0.89711304],\\n [0.05199786, -0.33138635, 0.9420612],\\n [0.05109826, -0.20999284, 0.97636672],\\n [0.04919919, -0.07869871, 0.99568366],\\n [0.04640163, 0.05630197, 0.99733494],\\n [0.04279892, 0.18779527, 0.98127529],\\n [0.03870043, 0.30950341, 0.95011048],\\n [0.03440055, 0.41730662, 0.90811441],\\n [0.17290651, -0.43181626, 0.88523333],\\n [0.17839998, -0.32509996, 0.92869988],\\n [0.18160174, -0.20480196, 0.96180921],\\n [0.18200745, -0.07490306, 0.98044012],\\n [0.17919505, 0.05849838, 0.98207285],\\n [0.17329685, 0.18839658, 0.96668244],\\n [0.1649036, 0.30880674, 0.93672045],\\n [0.1549931, 0.41578148, 0.89616009],\\n [0.28720483, -0.41910705, 0.8613145],\\n [0.29740177, -0.31410186, 0.90160535],\\n [0.30420604, -0.1965039, 0.9321185],\\n [0.30640529, -0.07010121, 0.94931639],\\n [0.30361153, 0.05950226, 0.95093613],\\n [0.29588748, 0.18589214, 0.93696036],\\n [0.28409783, 0.30349768, 0.90949304],\\n [0.26939905, 0.40849857, 0.87209694],\\n [0.39120402, -0.40190413, 0.8279085],\\n [0.40481085, -0.29960803, 0.86392315],\\n [0.41411685, -0.18590756, 0.89103626],\\n [0.41769724, -0.06449957, 0.906294],\\n [0.41498764, 0.05959822, 0.90787296],\\n [0.40607977, 0.18089099, 0.89575537],\\n [0.39179226, 0.29439419, 0.87168279],\\n [0.37379609, 0.39649585, 0.83849122],\\n [0.48278794, -0.38169046, 0.78818031],\\n [0.49848546, -0.28279175, 0.8194761],\\n [0.50918069, -0.1740934, 0.84286803],\\n [0.51360856, -0.05870098, 0.85601427],\\n [0.51097962, 0.05899765, 0.8575658],\\n [0.50151639, 0.17420569, 0.84742769],\\n [0.48600297, 0.28260173, 0.82700506],\\n [0.46600106, 0.38110087, 0.79850181],\\n [0.56150442, -0.35990283, 0.74510586],\\n [0.57807114, -0.26498677, 0.77176147],\\n [0.58933134, -0.1617086, 0.7915421],\\n [0.59407609, -0.05289787, 0.80266769],\\n [0.59157958, 0.057798, 0.80417224],\\n [0.58198189, 0.16649482, 0.79597523],\\n [0.56620006, 0.26940003, 0.77900008],\\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\\n return L\",\n \"def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(1/((epsinf1+epsinf2)/2) + (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) + (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2))\\n #epsx = (1/2)*(eps1+eps2)\\n #epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n #epsx = (1/2)*epsinf1*(1-(f_t1*(v**2 - vl1**2 + 1j*v*gl1)/(v**2 - vt1**2 + 1j*v*gt1))-\\\\\\n # (f_t2*(v**2 - vl2**2 + 1j*v*gl2)/(v**2 - vt2**2 + 1j*v*gt2)))\\n #epsz = 1/((1/2)*(1/epsinf2)*(1+(f_l1*(v**2 - vt1**2 +1j*v*gl1)/(v**2 - vl1**2 +1j*v*gl1))+\\\\\\n # (f_l2*(v**2 - vt2**2 +1j*v*gl2)/(v**2 - vl2**2 +1j*v*gl2))))\\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def _holt__(x, xi, p, y, l, b, s, m, n, max_seen):\\n alpha, beta, phi, alphac, betac, y_alpha = _holt_init(x, xi, p, y, l, b)\\n for i in range(1, n):\\n l[i] = (y_alpha[i - 1]) + (alphac * (l[i - 1]))\\n return sqeuclidean(l, y)\",\n \"def os2latlng(E, N):\\n\\n OSGB_F0 = 0.9996012717\\n N0 = -100000.0\\n E0 = 400000.0\\n\\n a = 6377563.396\\n b = 6356256.909\\n eSquared = ab2ecc(a, b)\\n\\n phi0 = math.radians(49.0)\\n lambda0 = math.radians(-2.0)\\n phi = 0.0\\n lmb = 0.0\\n n = (a - b) / (a + b)\\n M = 0.0\\n phiPrime = ((N - N0) / (a * OSGB_F0)) + phi0\\n\\n while True:\\n M = (b * OSGB_F0) \\\\\\n * (((1 + n + ((5.0 / 4.0) * n * n) + ((5.0 / 4.0) * n * n * n)) \\\\\\n * (phiPrime - phi0)) \\\\\\n - (((3 * n) + (3 * n * n) + ((21.0 / 8.0) * n * n * n)) \\\\\\n * math.sin(phiPrime - phi0) \\\\\\n * math.cos(phiPrime + phi0)) \\\\\\n + ((((15.0 / 8.0) * n * n) + ((15.0 / 8.0) * n * n * n)) \\\\\\n * math.sin(2.0 * (phiPrime - phi0)) \\\\\\n * math.cos(2.0 * (phiPrime + phi0))) \\\\\\n - (((35.0 / 24.0) * n * n * n) \\\\\\n * math.sin(3.0 * (phiPrime - phi0)) \\\\\\n * math.cos(3.0 * (phiPrime + phi0))))\\n\\n phiPrime += (N - N0 - M) / (a * OSGB_F0)\\n if ((N - N0 - M) >= 0.001):\\n break\\n\\n v = a * OSGB_F0 * math.pow(1.0 - eSquared * sinSquared(phiPrime), -0.5)\\n rho = a \\\\\\n * OSGB_F0 \\\\\\n * (1.0 - eSquared) \\\\\\n * math.pow(1.0 - eSquared * sinSquared(phiPrime), -1.5)\\n\\n etaSquared = (v / rho) - 1.0\\n\\n VII = math.tan(phiPrime) / (2 * rho * v)\\n VIII = (math.tan(phiPrime) / (24.0 * rho * math.pow(v, 3.0))) \\\\\\n * (5.0 \\\\\\n + (3.0 * tanSquared(phiPrime)) \\\\\\n + etaSquared \\\\\\n - (9.0 * tanSquared(phiPrime) * etaSquared))\\n IX = (math.tan(phiPrime) / (720.0 * rho * math.pow(v, 5.0))) \\\\\\n * (61.0 \\\\\\n + (90.0 * tanSquared(phiPrime)) \\\\\\n + (45.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\\n X = sec(phiPrime) / v\\n XI = (sec(phiPrime) / (6.0 * v * v * v)) \\\\\\n * ((v / rho) + (2 * tanSquared(phiPrime)))\\n XII = (sec(phiPrime) / (120.0 * math.pow(v, 5.0))) \\\\\\n * (5.0 \\\\\\n + (28.0 * tanSquared(phiPrime)) \\\\\\n + (24.0 * tanSquared(phiPrime) * tanSquared(phiPrime)))\\n XIIA = (sec(phiPrime) / (5040.0 * math.pow(v, 7.0))) \\\\\\n * (61.0 \\\\\\n + (662.0 * tanSquared(phiPrime)) \\\\\\n + (1320.0 * tanSquared(phiPrime) * tanSquared(phiPrime)) \\\\\\n + (720.0\\n * tanSquared(phiPrime) \\\\\\n * tanSquared(phiPrime) \\\\\\n * tanSquared(phiPrime)))\\n\\n phi = phiPrime \\\\\\n - (VII * math.pow(E - E0, 2.0)) \\\\\\n + (VIII * math.pow(E - E0, 4.0)) \\\\\\n - (IX * math.pow(E - E0, 6.0))\\n\\n lmb = lambda0 \\\\\\n + (X * (E - E0)) \\\\\\n - (XI * math.pow(E - E0, 3.0)) \\\\\\n + (XII * math.pow(E - E0, 5.0)) \\\\\\n - (XIIA * math.pow(E - E0, 7.0))\\n\\n return OSGB36toWGS84(math.degrees(phi), math.degrees(lmb))\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def compute_loss_lasso(y, tx, w, lambda_):\\n e = y - tx.dot(w)\\n\\n return e.dot(e)/(2 * len(e)) + lambda_ * sum(abs(w))\",\n \"def img2heliovec(bxImg,byImg,bzImg,lon,lat,lonc,latc,pAng):\\n a11 = -np.sin(latc)*np.sin(pAng)*np.sin(lon - lonc) + np.cos(pAng)*np.cos(lon - lonc)\\n a12 = np.sin(latc)*np.cos(pAng)*np.sin(lon - lonc) + np.sin(pAng)*np.cos(lon - lonc)\\n a13 = -np.cos(latc)*np.sin(lon - lonc)\\n a21 = -np.sin(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.cos(lat)*np.cos(latc)*np.sin(pAng)\\n a22 = np.sin(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.cos(lat)*np.cos(latc)*np.cos(pAng)\\n a23 = -np.cos(latc)*np.sin(lat)*np.cos(lon - lonc) + np.sin(latc)*np.cos(lat)\\n a31 = np.cos(lat)*(np.sin(latc)*np.sin(pAng)*np.cos(lon - lonc) + np.cos(pAng)*np.sin(lon - lonc)) - np.sin(lat)*np.cos(latc)*np.sin(pAng)\\n a32 = -np.cos(lat)*(np.sin(latc)*np.cos(pAng)*np.cos(lon - lonc) - np.sin(pAng)*np.sin(lon - lonc)) + np.sin(lat)*np.cos(latc)*np.cos(pAng)\\n a33 = np.cos(lat)*np.cos(latc)*np.cos(lon - lonc) + np.sin(lat)*np.sin(latc)\\n\\n bxHelio = a11 * bxImg + a12 * byImg + a13 * bzImg\\n byHelio = a21 * bxImg + a22 * byImg + a23 * bzImg\\n bzHelio = a31 * bxImg + a32 * byImg + a33 * bzImg\\n\\n return bxHelio,byHelio,bzHelio\",\n \"def calc_lampam_2(ss):\\n if isinstance(ss, list):\\n lampam = np.zeros((len(ss), 12), float)\\n for index in range(len(ss)):\\n lampam[index] = calc_lampam_2(ss[index])\\n return lampam\\n if ss.ndim == 2 and ss.shape[0] > 1:\\n lampam = np.zeros((ss.shape[0], 12), float)\\n for index in range(ss.shape[0]):\\n lampam[index] = calc_lampam_2(ss[index])\\n return lampam\\n\\n n_plies_in_panels = np.size(ss) # laminate ply count\\n\\n theta2 = np.deg2rad(2*ss.astype(float))\\n theta4 = 2*theta2\\n cos_sin = np.concatenate((\\n np.cos(theta2),\\n np.cos(theta4),\\n np.sin(theta2),\\n np.sin(theta4))).reshape((4, n_plies_in_panels))\\n\\n for_the_top = np.arange(n_plies_in_panels)\\n z_0 = np.ones(n_plies_in_panels)\\n z_2 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**3 \\\\\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**3\\n z_1 = ((1-n_plies_in_panels/2)*z_0+for_the_top)**2 \\\\\\n - ((1-n_plies_in_panels/2)*z_0+for_the_top - 1)**2\\n\\n return np.array([\\n (1/n_plies_in_panels)*np.matmul(cos_sin, z_0),\\n (2/n_plies_in_panels**2)*np.matmul(cos_sin, z_1),\\n (4/n_plies_in_panels**3)*np.matmul(cos_sin, z_2)]).reshape(12)\",\n \"def lap2D(self, lat):\\n lap = np.roll(lat, 1, 0) + np.roll(lat, -1, 0) + \\\\\\n np.roll(lat, 1, 1) + np.roll(lat, -1, 1) - \\\\\\n 4. * lat\\n lap = 1./self.dx**2. * lap\\n # print(lap[50][50])\\n return(lap)\",\n \"def offset(x, y, L):\\n length = x.size\\n offsetx = np.zeros((length, 2))\\n offsety = np.zeros((length, 2))\\n dx = np.zeros(length-1)\\n dy = np.zeros(length-1)\\n dxL = np.zeros(length-1)\\n dyL = np.zeros(length-1)\\n xl = np.zeros(length) # counterclockwise\\n xr = np.zeros(length) # clockwise\\n yl = np.zeros(length)\\n yr = np.zeros(length)\\n xl0 = np.zeros(length)\\n xr0 = np.zeros(length)\\n yl0 = np.zeros(length)\\n yr0 = np.zeros(length) \\n for i in range(0, length-1):\\n dx[i] = x[i+1]-x[i]\\n dy[i] = y[i+1]-y[i]\\n for i in range(0, length-1):\\n r = np.sqrt(dx[i]**2 + dy[i]**2)\\n dxL[i] = dx[i]*L/r\\n dyL[i] = dy[i]*L/r\\n xl0[i] = -dyL[i] + x[i]\\n yl0[i] = dxL[i] + y[i]\\n xr0[i] = dyL[i] + x[i]\\n yr0[i] = -dxL[i] + y[i]\\n xl0[length-1] = xl0[length-2] + dx[length-2]\\n yl0[length-1] = yl0[length-2] + dy[length-2]\\n xr0[length-1] = xr0[length-2] + dx[length-2]\\n yr0[length-1] = yr0[length-2] + dy[length-2]\\n xl[0] = xl0[0]\\n yl[0] = yl0[0]\\n xl[length-1] = xl0[length-1]\\n yl[length-1] = yl0[length-1]\\n xr[0] = xr0[0]\\n yr[0] = yr0[0]\\n xr[length-1] = xr0[length-1]\\n yr[length-1] = yr0[length-1]\\n for i in range(1, length-1):\\n a = np.array([[dy[i-1], -dx[i-1]], [dy[i], -dx[i]]])\\n bl = np.array([dy[i-1]*xl0[i-1]-dx[i-1]*yl0[i-1], dy[i]*xl0[i]-dx[i]*yl0[i]])\\n br = np.array([dy[i-1]*xr0[i-1]-dx[i-1]*yr0[i-1], dy[i]*xr0[i]-dx[i]*yr0[i]])\\n theta = (dx[i-1]*dx[i]+dy[i-1]*dy[i])/(dx[i-1]**2+dy[i-1]**2)**0.5/(dx[i]**2+dy[i]**2)**0.5\\n if theta > 1 - 1e-10:\\n xl[i] = xl0[i]\\n yl[i] = yl0[i]\\n xr[i] = xr0[i]\\n yr[i] = yr0[i]\\n else:\\n pl = np.linalg.solve(a, bl)\\n xl[i] = pl[0]\\n yl[i] = pl[1]\\n pr = np.linalg.solve(a, br)\\n xr[i] = pr[0]\\n yr[i] = pr[1]\\n offsetx[:, 0], offsetx[:, 1] = xl, xr\\n offsety[:, 0], offsety[:, 1] = yl, yr\\n return offsetx, offsety\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def dndt2(jx, iy, h, n, u, v, dx, dy) :\\n p5 = np.float32(0.5)\\n depth_jm0im0 = h[jx, iy ]+n[jx, iy]\\n depth_jp1im0 = h[jx+1,iy] +n[jx+1,iy]\\n depth_jm1im0 = h[jx-1,iy] +n[jx-1,iy]\\n depth_jm0ip1 = h[jx, iy+1]+n[jx, iy+1]\\n depth_jm0im1 = h[jx, iy-1]+n[jx, iy-1]\\n \\n hx_jp1 = u[jx+1,iy]*(depth_jm0im0 + depth_jp1im0)*p5\\n hx_jm0 = u[jx, iy]*(depth_jm1im0 + depth_jm0im0)*p5\\n \\n \\n hy_ip1 = v[jx,iy+1]*(depth_jm0im0 + depth_jm0ip1)*p5\\n hy_im0 = v[jx,iy ]*(depth_jm0im1 + depth_jm0im0)*p5\\n \\n # assume u and v are zero on edge\\n dhx = (hx_jp1-hx_jm0)/dx#[jx,iy]\\n dhy = (hy_ip1-hy_im0)/dy#[jx,iy]\\n\\n \\n return ( -dhx-dhy )\",\n \"def nnl_combine(r, s2, N=10, debug=False, alpha=0.05, rang=5, rang_N=1000, EPS=1E-15):\\n\\n def est(rhat, delta2):\\n\\n # .maximum(,) operates element wise\\n rhat = np.sum(r / np.maximum(s2 + delta2, EPS)) / \\\\\\n (np.sum(1.0 / np.maximum(s2 + delta2, EPS)))\\n delta2 = np.sum(((r - rhat)**2 - s2) / np.maximum(s2 + delta2, EPS)**2) / \\\\\\n np.sum(1.0 / np.maximum(s2 + delta2, EPS)**2)\\n\\n # protection\\n rhat = np.abs(rhat)\\n delta2 = np.abs(delta2)\\n\\n return rhat, delta2\\n\\n # Iterate\\n rhat = np.mean(r)\\n delta2 = np.var(r)\\n for i in range(N):\\n rhat, delta2 = est(rhat,delta2)\\n if debug:\\n _2logL = nnl_2logL(rhat=rhat, delta2=delta2, r=r, s2=s2)\\n print(__name__ + f'.nnl_combine: iter {i}: rhat = {rhat:0.3}, delta2 = {delta2:0.3} | 2lnL = {_2logL:0.5e}')\\n \\n # ....................................................................\\n # Profiled log-likelihood ratio for the uncertainties\\n\\n x2LL_hat = nnl_2logL(rhat=rhat, delta2=delta2, r=r, s2=s2)\\n \\n ### RHAT\\n theta_val = np.linspace(rhat/rang, rhat*rang, rang_N)\\n x2LL = np.zeros(len(theta_val))\\n for i in range(len(x2LL)):\\n x2LL[i] = nnl_2logL(rhat=theta_val[i], delta2=delta2, r=r, s2=s2)\\n\\n ind = chi2range(x2LL=x2LL, x2LL_hat=x2LL_hat, alpha=alpha)\\n \\n if len(ind) >= 2:\\n rhat_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\\n else:\\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on rhat, setting zero', 'red')\\n rhat_err = np.array([0,0])\\n \\n # --------------------------------------------------------------------\\n ### DELTA2\\n theta_val = np.linspace(delta2/rang, delta2*rang, rang_N)\\n x2LL = np.zeros(len(theta_val))\\n for i in range(len(x2LL)):\\n x2LL[i] = nnl_2logL(rhat=rhat, delta2=theta_val[i], r=r, s2=s2)\\n\\n ind = chi2range(x2LL=x2LL, x2LL_hat=x2LL_hat, alpha=alpha)\\n\\n if len(ind) >= 2:\\n delta2_err = np.array([theta_val[ind[0]], theta_val[ind[-1]]])\\n else:\\n cprint(__name__ + f'.nnl_combine: WARNING: Could not obtain uncertainty on delta2, setting zero', 'red')\\n delta2_err = np.array([0,0])\\n\\n # Check for NaN\\n if np.isnan(rhat):\\n cprint(__name__ + f'.nnl_combine: WARNING: rhat is NaN, setting zero', 'red')\\n if np.isnan(delta2):\\n cprint(__name__ + f'.nnl_combine: WARNING: delta2 is NaN, setting zero', 'red')\\n\\n return rhat, delta2, rhat_err, delta2_err\",\n \"def lambert1(lat, lon, orglat, orglon, iopt):\\n\\n radearth = 6378.135 # equitorial earth radius\\n f = 298.26 # 1/f wgs 72 model values\\n dtr = 3.141592654 / 180.0\\n\\n lon1 = mod(lon + 720.0, 360.0)\\n orglon1 = mod(orglon + 720.0, 360.0)\\n #\\n # compute local radius of the earth at center of image\\n #\\n # eradearth = 6378.0 # use fixed nominal value\\n eradearth = radearth\\n if iopt == 2: # local radius\\n era = 1.0 - 1.0 / f\\n eradearth = (\\n radearth\\n * era\\n / sqrt(era * era * cos(orglat * dtr) ** 2 + sin(orglat * dtr) ** 2)\\n )\\n\\n denom = (\\n 1.0\\n + sin(orglat * dtr) * sin(lat * dtr)\\n + cos(orglat * dtr) * cos(lat * dtr) * cos(dtr * (lon1 - orglon1))\\n )\\n if np.all(denom > 0.0):\\n ak = sqrt(2.0 / denom)\\n else:\\n print(\\\"*** division error in lambert1 routine ***\\\")\\n ak = 1.0\\n\\n x = ak * cos(lat * dtr) * sin(dtr * (lon1 - orglon1))\\n y = ak * (\\n cos(dtr * orglat) * sin(dtr * lat)\\n - sin(dtr * orglat) * cos(dtr * lat) * cos(dtr * (lon1 - orglon1))\\n )\\n x = x * eradearth\\n y = y * eradearth\\n return x, y\",\n \"def _maping(x,y,l,a):\\n newx = (x**2 *(l* ((x**2 + y**2)**(a/2) - 1) + 2) - l * y**2 *((x**2 + y**2)**(a/2) - 1))/(x**2 + y**2) \\n newy = (2 * x* y *(l* ((x**2 + y**2)**(a/2) - 1) + 1))/(x**2 + y**2)\\n return newx, newy\",\n \"def potentialSolver4(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def nodalLaplacian(self):\\n if getattr(self, '_nodalLaplacian', None) is None:\\n print('Warning: Laplacian has not been tested rigorously.')\\n # The number of cell centers in each direction\\n n = self.vnC\\n # Compute divergence operator on faces\\n if(self.dim == 1):\\n D1 = sdiag(1./self.hx) * ddx(self.nCx)\\n L = - D1.T*D1\\n elif(self.dim == 2):\\n D1 = sdiag(1./self.hx) * ddx(n[0])\\n D2 = sdiag(1./self.hy) * ddx(n[1])\\n L1 = sp.kron(speye(n[1]+1), - D1.T * D1)\\n L2 = sp.kron(- D2.T * D2, speye(n[0]+1))\\n L = L1 + L2\\n elif(self.dim == 3):\\n D1 = sdiag(1./self.hx) * ddx(n[0])\\n D2 = sdiag(1./self.hy) * ddx(n[1])\\n D3 = sdiag(1./self.hz) * ddx(n[2])\\n L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)\\n L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))\\n L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))\\n L = L1 + L2 + L3\\n self._nodalLaplacian = L\\n return self._nodalLaplacian\",\n \"def pontos(self):\\n \\n self.sc = 1. \\n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\\n self.px_index = len(self.x)\\n #self.py_index = len(self.x)/2\\n\\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n \\n self.x = self.x[::-1]\\n self.y = -self.y[::-1] \\n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\\n\\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \\n \\n self.coordi = np.array(self.coord)\\n \\n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \\n self.cgi = np.array(self.cg)\\n \\n self.thi = 0. + self.dth \\n self.th = float(self.thi) \\n \\n self.coordnav(self.dx,self.dy,self.dth)\",\n \"def HOG(img, x, y):\\n #TODO: write a HOG descriptor here\\n des=[]\\n row=0\\n sub_image = img[x-8:x+8,y-8:y+8]\\n while row < len(sub_image):\\n col=0\\n while col < len(sub_image[0]):\\n temp_vector = [0 for i in range(8)]\\n new_subimage = sub_image[row:row+4,col:col+4]\\n x_gradient = cv2.Sobel(new_subimage,ddepth=-1,dx=1,dy=0)\\n y_gradient = cv2.Sobel(new_subimage,ddepth=-1,dx=0,dy=1)\\n theta = np.empty([x_gradient.shape[0],x_gradient.shape[1]])\\n for i in range(len(x_gradient)):\\n for j in range(len(x_gradient[0])):\\n if x_gradient[i,j] == 0:\\n theta[i,j] = 90\\n else:\\n theta[i,j] = np.arctan(y_gradient[i,j]/x_gradient[i,j])*(180/np.pi)\\n theta_iter = theta.flatten() #To avoid nested for loops for 4x4 theta\\n for i in range(len(theta_iter)):\\n if theta_iter[i] < 45:\\n temp_vector[0]=temp_vector[0]+1\\n elif theta_iter[i] >= 45 and theta_iter[i] < 90:\\n temp_vector[1]=temp_vector[1]+1\\n elif theta_iter[i] >= 90 and theta_iter[i] < 135:\\n temp_vector[2]=temp_vector[2]+1\\n elif theta_iter[i] >= 135 and theta_iter[i] < 180:\\n temp_vector[3]=temp_vector[3]+1\\n elif theta_iter[i] >= 180 and theta_iter[i] < 225:\\n temp_vector[4]=temp_vector[4]+1\\n elif theta_iter[i] >= 225 and theta_iter[i] < 270:\\n temp_vector[5]=temp_vector[5]+1\\n elif theta_iter[i] >= 270 and theta_iter[i] < 315:\\n temp_vector[6]=temp_vector[6]+1\\n elif theta_iter[i] >= 315 and theta_iter[i] < 360:\\n temp_vector[7]=temp_vector[7]+1\\n des.extend(temp_vector)\\n col=col+4\\n row=row+4\\n return des\",\n \"def __init__(self, lattice, lp, xytup=None, NL=None, KL=None, PVx=None, PVy=None,\\n BL_nm=None, NL_nm=None, KL_nm=None,\\n Omg=None, OmK=None, matrix=None, eigval=None, eigvect=None, eps=1e-8, overwrite=False):\\n # xytup is a tuple of inner points, outer points. Define self.xy to be all sites, including immobile ones\\n self.lattice = lattice\\n # lp contains Omg, Omk, als. With weights, Omg = 1.5, otherwise Omg = 1.0\\n # Omk = k_m l^2 / I omega -> 0.86 in original experiments\\n # aoverl = 0.0305/.038\\n self.lp = lp\\n self.inner_indices = None\\n self.outer_indices = None\\n\\n if xytup is None:\\n # Create self.xy and self.xy_inner\\n self.xy = lattice.xy\\n if 'roi' in self.lp:\\n self.xy_inner = le.pts_in_polygon(self.xy, self.lp['roi'])\\n else:\\n # get boundary of the lattice and denote these particles as the outer particles\\n # boundary = le.extract_boundary(self.xy, self.lattice.NL, self.lattice.KL, self.lattice.BL,\\n # check=False)\\n boundary = self.lattice.get_boundary()\\n if boundary is None:\\n self.xy_inner = self.xy\\n elif isinstance(boundary, tuple):\\n # There are multiple boundaries. Exclude all of them from inner_indices\\n inners = np.arange(len(self.xy))\\n outers = []\\n for bndy in boundary:\\n inners = np.setdiff1d(inners, np.array(bndy))\\n outers.append(bndy)\\n\\n self.inner_indices = np.hstack(inners)\\n self.outer_indices = np.hstack(outers)\\n self.xy_inner = self.xy[self.inner_indices]\\n else:\\n self.inner_indices = np.setdiff1d(np.arange(len(self.xy)), np.array(boundary))\\n self.outer_indices = np.array(boundary)\\n self.xy_inner = self.xy[self.inner_indices]\\n else:\\n self.xy = xytup[1]\\n self.xy_inner = xytup[0]\\n\\n if NL is not None and KL is not None:\\n self.NL = NL\\n self.KL = KL\\n # determine if shortrange or longrange or intermediate interaction_range from supplied NL\\n # if lp['intrange'] == 1:\\n # nl_meshfn_exten = '_shortrange'\\n if lp['intrange'] > 0:\\n nl_meshfn_exten = '_intrange{0:04d}'.format(mglat.lp['interaction_range'])\\n else:\\n nl_meshfn_exten = ''\\n # Get PVxy if not supplied\\n if PVx is not None and PVy is not None:\\n self.PVx, self.PVy = PVx, PVy\\n else:\\n if (KL > -eps).all():\\n self.PVx = np.zeros_like(NL, dtype=float)\\n self.PVy = np.zeros_like(NL, dtype=float)\\n else:\\n raise RuntimeError('periodic KL is supplied, but PVx and PVy are not supplied')\\n else:\\n self.NL, self.KL, self.PVx, self.PVy, nl_meshfn_exten = mgfns.create_NL_KL_pv(self)\\n\\n # print 'self.xy_inner = ', np.shape(self.xy_inner)\\n # print 'self.xy = ', np.shape(self.xy)\\n if self.inner_indices is None or self.outer_indices is None:\\n self.outer_indices, self.inner_indices, self.total2inner = self.outer_inner(self.xy, self.xy_inner)\\n\\n # Add lattice properties to gyro_lattice_properties, by convention, but don't overwrite params\\n for key in self.lattice.lp:\\n if key not in self.lp:\\n self.lp[key] = self.lattice.lp[key]\\n\\n ########################################################################\\n self.lp['meshfn_exten'] = '_magnetic' + nl_meshfn_exten + '_aol' + sf.float2pstr(self.lp['aoverl'])\\n # For magnetic class, OmK is bond dependent: OmK = 3 mu_0 M^2/ (pi a^5) for each bond\\n if self.lp['Omk'] != -1.0:\\n self.lp['meshfn_exten'] += '_Omk' + sf.float2pstr(self.lp['Omk'])\\n\\n # Build OmK array for couplings\\n self.OmK, lp_Omk, omk_meshfn_exten = mgfns.build_OmK(self, self.lp, None)\\n\\n # Form Omg\\n if Omg == 'auto' or Omg is None:\\n if 'Omg' in self.lp:\\n self.Omg = self.lp['Omg'] * np.ones_like(self.xy_inner[:, 0])\\n else:\\n print 'giving Omg the default value of -1s...'\\n self.Omg = -1.0 * np.ones_like(self.xy_inner[:, 0])\\n if self.lp['Omg'] != -1.0:\\n self.lp['meshfn_exten'] += '_Omg' + sf.float2pstr(self.lp['Omg'])\\n else:\\n self.Omg = Omg\\n if 'Omg' in self.lp:\\n if (self.Omg != self.lp['Omg'] * np.ones(np.shape(self.xy_inner)[0])).any():\\n self.lp['meshfn_exten'] += '_Omgspec'\\n self.lp['Omg'] = -5000\\n else:\\n # Check if the values of all elements are identical\\n kinds = np.nonzero(self.Omg)\\n if len(kinds[0]) > 0:\\n # There are some nonzero elements in Omg. Check if all the same\\n value = self.Omg[kinds[0]]\\n if (Omg[kinds] == value).all():\\n self.lp['Omg'] = value\\n else:\\n self.lp['Omg'] = -5000\\n else:\\n self.lp['Omg'] = 0.0\\n if 'ABDelta' in self.lp:\\n if np.abs(self.lp['ABDelta']) > eps:\\n self.lp['meshfn_exten'] += '_ABd{0:0.3f}'.format(self.lp['ABDelta']).replace('.', 'p').replace('-', 'n')\\n else:\\n self.lp['ABDelta'] = 0.\\n\\n # First check for gaussian disorder\\n if 'V0_pin_gauss' in self.lp and 'V0_spring_gauss' in self.lp:\\n if abs(self.lp['V0_pin_gauss']) > eps or (self.lp['V0_spring_gauss']) > eps:\\n self.lp['dcdisorder'] = True\\n self.lp['meshfn_exten'] += '_pinV' + sf.float2pstr(self.lp['V0_pin_gauss'])\\n self.lp['meshfn_exten'] += '_sprV' + sf.float2pstr(self.lp['V0_spring_gauss'])\\n if 'pinconf' not in self.lp:\\n self.lp['pinconf'] = 0\\n elif self.lp['pinconf'] > 0:\\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\\n else:\\n self.lp['dcdisorder'] = False\\n\\n # If no gaussian disorder check for flat disorder\\n if 'V0_pin_flat' in self.lp and 'V0_spring_flat' in self.lp and not self.lp['dcdisorder']:\\n if abs(self.lp['V0_pin_flat']) > eps or (self.lp['V0_spring_flat']) > eps:\\n self.lp['dcdisorder'] = True\\n self.lp['meshfn_exten'] += '_pinVflat' + sf.float2pstr(self.lp['V0_pin_flat'])\\n self.lp['meshfn_exten'] += '_sprVflat' + sf.float2pstr(self.lp['V0_spring_flat'])\\n if 'pinconf' not in self.lp:\\n self.lp['pinconf'] = 0\\n elif self.lp['pinconf'] > 0:\\n self.lp['meshfn_exten'] += '_conf{0:04d}'.format(self.lp['pinconf'])\\n else:\\n self.lp['dcdisorder'] = False\\n\\n # If neither gaussian nor flat, input no disorder\\n if not self.lp['dcdisorder']:\\n self.lp['V0_pin_gauss'] = 0.\\n self.lp['V0_spring_gauss'] = 0.\\n self.lp['V0_pin_flat'] = 0.\\n self.lp['V0_spring_flat'] = 0.\\n self.lp['pinconf'] = 0\\n self.lp['dcdisorder'] = False\\n\\n vpin_has_gaussian = self.lp['V0_pin_gauss'] > eps or self.lp['V0_spring_gauss'] > eps\\n vpin_has_flat = self.lp['V0_pin_flat'] > eps or self.lp['V0_spring_flat'] > eps\\n if abs(self.lp['ABDelta']) > eps or vpin_has_gaussian or vpin_has_flat:\\n # In order to load the random (V0) or alternating (AB) pinning sites, look for a txt file with the pinnings\\n # that also has specifications in its meshfn exten, but IGNORE other parts of meshfnexten, if they exist.\\n # Form abbreviated meshfn exten\\n pinmfe = self.get_pinmeshfn_exten()\\n\\n print 'Trying to load offset/disorder to pinning frequencies: '\\n print dio.prepdir(self.lp['meshfn']) + pinmfe\\n # Attempt to load from file\\n if not overwrite:\\n try:\\n self.load_pinning(meshfn=self.lp['meshfn'])\\n # self.Omg = np.loadtxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt')\\n # raise RuntimeError('This means an erronous Omg was saved --where was it saved?')\\n print 'Loaded ABDelta and/or dcdisordered pinning frequencies.'\\n define_Omg_now = False\\n except IOError:\\n define_Omg_now = True\\n else:\\n define_Omg_now = True\\n\\n if define_Omg_now:\\n print 'Could not load ABDelta and/or dcdisordered pinning frequencies, defining them here...'\\n # Make Omg from scratch\\n if abs(self.lp['ABDelta']) > eps:\\n asites, bsites = glatfns.ascribe_absites(self.lattice)\\n self.Omg[asites[self.inner_indices]] += self.lp['ABDelta']\\n self.Omg[bsites[self.inner_indices]] -= self.lp['ABDelta']\\n if vpin_has_flat or vpin_has_gaussian:\\n self.add_dcdisorder()\\n\\n # Save non-standard Omg\\n if 'save_pinning_to_hdf5' in self.lp:\\n if self.lp['save_pinning_to_hdf5']:\\n force_hdf5pin = True\\n else:\\n force_hdf5pin = False\\n else:\\n force_hdf5pin = False\\n self.save_Omg(infodir=self.lp['meshfn'], histogram=False, force_hdf5=force_hdf5pin, overwrite=overwrite)\\n # self.plot_Omg()\\n # np.savetxt(dio.prepdir(self.lp['meshfn']) + pinmfe + '.txt', self.Omg)\\n # self.plot_Omg()\\n\\n ########################################################################\\n\\n # Non magnetic --> nm: taken from lat.NL, lat.KL, these are the inner particles (xy_in) connectivity M x M\\n if BL_nm is not None:\\n self.BL_nm = BL_nm\\n if NL_nm is not None and KL_nm is not None:\\n self.NL_nm = NL_nm\\n self.KL_nm = KL_nm\\n else:\\n self.NL_nm, self.KL_nm = le.BL2NLandKL(self.BL_nm)\\n else:\\n # Remove self.outer_indices from lattice, and use resulting BL to get NL_nm and KL_nm\\n # print 'magnetic_gyro_lattice_class: BL = ', self.lattice.BL\\n # print 'magnetic_gyro_lattice_class: keep = ', self.inner_indices\\n xytmp, self.NL_nm, self.KL_nm, self.BL_nm, self.PVxydict = \\\\\\n le.remove_pts(self.inner_indices, self.lattice.xy, self.lattice.BL, PVxydict=self.lattice.PVxydict,\\n PV=self.lattice.PV)\\n\\n # print 'lp[meshfn_exten] = ', self.lp['meshfn_exten']\\n # Get inner boundary\\n self.inner_boundary = mgfns.calc_boundary_inner(self, check=False)\\n # Use dh to get indices of xy_inner that are on the 'inner' network's boundary\\n # Note match_values returns inds such that vals[inds] ~= arr\\n if self.inner_boundary is not None:\\n self.inner_boundary_inner = dh.match_values(self.inner_boundary, self.inner_indices)\\n else:\\n self.inner_boundary_inner = None\\n # print 'self.inner_indices = ', self.inner_indices\\n # print 'self.inner_boundary = ', self.inner_boundary\\n # print 'self.inner_boundary_inner = ', self.inner_boundary_inner\\n # sys.exit()\\n\\n # Other attributes that can be calculated\\n self.matrix = matrix\\n self.eigval = eigval\\n self.eigvect = eigvect\\n self.localization = None\\n self.edge_localization = None\\n self.ipr = None\",\n \"def lcn(x,ishape,size=9):\\n # Function borrowed from bengioe_util\\n inshape = (x.shape[0],1,ishape[0],ishape[1])\\n p = x.reshape(inshape)\\n #p = (p-TT.mean(p))/T.std(p)\\n g = gaussian(size,1.591/size)\\n g/=g.sum()\\n g = numpy.float32(g.reshape((1,1,size,size)))\\n mean = TT.nnet.conv.conv2d(p,TT.constant(g),\\n None,\\n (1,1,size,size),\\n 'full').reshape(\\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\\n mean = mean[:,:,\\n size/2:ishape[0]+size/2,\\n size/2:ishape[1]+size/2]\\n v = (p - mean)#.dimshuffle('x','x',0,1)\\n var = TT.nnet.conv.conv2d(TT.sqr(v),TT.constant(g),\\n None,\\n (1,1,size,size),\\n 'full').reshape(\\n (x.shape[0],1)+(ishape[0]+size-1,)*2)\\n var = var[:,:,\\n size/2:ishape[0]+size/2,\\n size/2:ishape[1]+size/2]\\n std = TT.sqrt(var)\\n std_mean = TT.mean(TT.mean(std,axis=3),axis=2).dimshuffle(0,1,'x','x')\\n out = v / TT.maximum(std,std_mean)\\n return (out + 2.5 )/5# - out.min()\",\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 ldfe(n=3):\\n\\n # We will use the following coordinate system.\\n #\\n # | z, top\\n # |\\n # |\\n # |\\n # o------- x, right\\n # /\\n # /\\n # /\\n # / y, front\\n\\n # Cube inside the octant that touches the sphere at\\n a = 1 / sqrt(3)\\n\\n # We have three important faces of the cube.\\n # Start with the front face and refine it in N segments.\\n x = linspace(0, a, n + 1)\\n z = linspace(0, a, n + 1)\\n\\n # Then delta Omega_ij = [x_i,x_i+1] x [z_j,z_j+1]\\n # Now go through every cell.\\n points = zeros((1 * 1 * 4 * n * n, 3)) # 1/3 of the octants\\n weights = zeros(1 * 1 * 4 * n * n)\\n square = zeros(1 * 1 * 4 * n * n)\\n counter = 0\\n rhos0 = 0.1 * ones(4)\\n for i in range(n):\\n for j in range(n):\\n x0, x1, z0, z1 = x[i], x[i + 1], z[j], z[j + 1]\\n\\n omegas = computeomegas(x0, x1, z0, z1)\\n areas = computeareas(omegas, x0, x1, z0, z1)\\n print(\\\"\\\\n\\\\nOptimiztation for:\\\")\\n print(\\\"Domain:\\\")\\n print([x0, x1, z0, z1])\\n\\n rhos = optimizeposition_leastsquares(areas, omegas, x0, x1, z0, z1,\\n rhos0)\\n rhos0 = rhos # take the optimal parameter of this cell as the starting value for the optimizer in the next cell\\n dummy = rand()\\n for k in range(4):\\n points[counter, :] = project(omegas[k](rhos[k]))\\n weights[counter] = areas[k]\\n square[counter] = dummy\\n counter += 1\\n scatterplot(points, weights, square)\\n return points, weights\",\n \"def comprehensiveLOOEvaluation(directory=defaultDirectory(), \\n pruneGlobal = True, numLayers = 2, \\n numNodesPerLayer = 200, randSeed = 1,\\n trainPer = .6, valPer = .25, testPer = 0.15,\\n totalPer = 1, batchSize = 64,\\n numEpochs = 1000, learningRate = 0.001, \\n l2Reg = 0.0001, modelFilePrefix = '',\\n useGRU = False,\\n dropoutI = 0.2, dropoutH = 0.2, trainMode = 'continue',\\n randSeed2 = None, center = False, prependMean = False):\\n \\n trainModes = ['continue', 'overwrite', 'continue-each']\\n \\n if trainMode.lower() not in trainModes:\\n raise ValueError(\\\"Parameter 'trainMode' must be either 'continue', 'overwrite', or 'continue-each'.\\\")\\n \\n np.random.seed(randSeed) #control permutation of data\\n # prune global coordinate data?\\n if pruneGlobal:\\n pruneRange = range(0, 18)\\n else:\\n pruneRange = None\\n structs = loadDataset(directory=directory, LOUO=True, \\n delRange=pruneRange, trainPer=trainPer,\\n valPer = valPer, testPer=testPer, totalPer=totalPer,\\n preExt = '.left', prune=True)\\n\\n u=0\\n losses = []\\n accs = []\\n balAccs = []\\n finAccs = []\\n cmEpochs = []\\n outDirectory = nameModelFile('', useGRU, numLayers, numNodesPerLayer, randSeed,\\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\\n center, prependMean)\\n if not os.path.isdir(outDirectory):\\n os.mkdir(outDirectory)\\n if randSeed2 is not None: #control randomization of training (for Keras at least)\\n np.random.seed(randSeed2)\\n for struct in structs:\\n modelFile = modelFilePrefix + 'LOU-' + str(u)\\n modelFile = nameModelFile(modelFile, useGRU, numLayers, numNodesPerLayer, randSeed,\\n trainPer, valPer, testPer, totalPer, dropoutI, dropoutH, l2Reg,\\n center, prependMean)\\n u += 1\\n if (os.path.isfile(outDirectory + '\\\\\\\\' + 'Keras' + modelFile + '.json') \\n and os.path.isfile(outDirectory + '\\\\\\\\' + 'Keras' + modelFile + '_Weights.h5')):\\n #if we have already trained for leaving out this user\\n if trainMode == 'continue': #continue until each user has a model\\n trainMode2 = 'skip' \\n elif trainMode == 'continue-each': # continue training previous models\\n trainMode2 = 'continue'\\n else:\\n trainMode2 = 'overwrite'\\n else:\\n trainMode2 = trainMode\\n\\n if center:\\n \\\"\\\"\\\"\\n Center the labeled markers on their mean. \\n \\\"\\\"\\\"\\n from Postures import centerData\\n struct = list(struct)\\n labeledMarkerData = struct[0][:,:,18:].reshape((-1, 11, 3))\\n labeledMarkerData = centerData(labeledMarkerData, True, prependMean).reshape((struct[0].shape[0], struct[0].shape[1], -1))\\n struct[0] = np.concatenate([struct[0][:,:,0:18], labeledMarkerData], axis = 2)\\n if prependMean:\\n struct[8] += 3\\n\\n\\n cmEpoch, loss, acc, balAcc, finAcc = trainGestureRNN(numLayers=numLayers, numNodesPerLayer=numNodesPerLayer,\\n useGRU=useGRU, batchSize=batchSize, \\n numEpochs = numEpochs, learningRate=learningRate,\\n l1Reg=0, l2Reg = l2Reg, dropoutI=dropoutI, dropoutH=dropoutH,\\n sequences = struct[0], classes = struct[1],\\n trainRange = struct[2], valRange = struct[3],\\n testRange = struct[4], numClasses = struct[5],\\n numObservations = struct[6], numSequences = struct[7],\\n numFeatures = struct[8],\\n modelFile=modelFile, \\n outDirectory=outDirectory, trainMode=trainMode2,\\n callbacks = [EarlyStopping(patience=20)])\\n #catch our breath.... Really, give the user a chance to insert Ctrl-C\\n time.sleep(2)\\n losses += [loss]\\n accs += [acc]\\n balAccs += [balAcc]\\n finAccs += [finAcc]\\n cmEpochs += [cmEpoch]\\n losses = np.asarray(losses)\\n accs = np.asarray(accs)*100\\n balAccs = np.asarray(balAccs)*100\\n finAccs = np.asarray(finAccs)*100\\n trainPer, valPer, _, _ = normalizePercentages(trainPer, valPer, 0, 1)\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Leave One User Out Evaluation\\\\nTest Results for ' + str(numLayers) + '-Layer, ' \\n + str(numNodesPerLayer) + ' Nodes-Per-Layer ' + ('GRU' if useGRU else 'LSTM') + ' Networks\\\\n'\\n + 'Trained with ' + (\\\"%0.2f\\\" % (dropoutI*100)) + '% Input Dropout, '\\n + (\\\"%0.2f\\\" % (dropoutH*100)) + '% Hidden Dropout, and ' + str(l2Reg) + ' L2 Regularization\\\\n'\\n + str(numEpochs) + ' Maximum Epochs at ' + (\\\"%0.2f\\\" % trainPer) + '/' + (\\\"%0.2f\\\" % valPer) + ' Training/Validation Split\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Loss: ' + str(np.mean(losses)) + ' +/- ' + str(np.std(losses)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Loss: ' + str(np.percentile(losses, 25))\\n + ', ' + str(np.median(losses)) \\n + ', ' + str(np.percentile(losses, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Accuracy: ' + str(np.mean(accs)) + ' +/- ' + str(np.std(accs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Accuracy: ' + str(np.percentile(accs, 25))\\n + ', ' + str(np.median(accs)) \\n + ', ' + str(np.percentile(accs, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Balanced Accuracy: ' + str(np.mean(balAccs)) + ' +/- ' + str(np.std(balAccs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Balanced Accuracy: ' + str(np.percentile(balAccs, 25))\\n + ', ' + str(np.median(balAccs))\\n + ', ' + str(np.percentile(balAccs, 75)) +'\\\\n')\\n sys.stdout.write('\\\\n')\\n sys.stdout.write('Final-Frame Accuracy: ' + str(np.mean(finAccs)) + ' +/- ' + str(np.std(finAccs)) +'\\\\n')\\n sys.stdout.write('25%, 50%, 75% Quartile Final-Frame Accuracy: ' + str(np.percentile(finAccs, 25))\\n + ', ' + str(np.median(finAccs))\\n + ', ' + str(np.percentile(finAccs, 75)) +'\\\\n')\",\n \"def do_test_latents(self, Y):\\r\\n assert not self.likelihood.is_heteroscedastic\\r\\n N_test = Y.shape[0]\\r\\n input_dim = self.Z.shape[1]\\r\\n means = np.zeros((N_test, input_dim))\\r\\n covars = np.zeros((N_test, input_dim))\\r\\n\\r\\n dpsi0 = -0.5 * self.input_dim * self.likelihood.precision\\r\\n dpsi2 = self.dL_dpsi2[0][None, :, :] # TODO: this may change if we ignore het. likelihoods\\r\\n V = self.likelihood.precision * Y\\r\\n\\r\\n #compute CPsi1V\\r\\n if self.Cpsi1V is None:\\r\\n psi1V = np.dot(self.psi1.T, self.likelihood.V)\\r\\n tmp, _ = linalg.dtrtrs(self._Lm, np.asfortranarray(psi1V), lower=1, trans=0)\\r\\n tmp, _ = linalg.dpotrs(self.LB, tmp, lower=1)\\r\\n self.Cpsi1V, _ = linalg.dtrtrs(self._Lm, tmp, lower=1, trans=1)\\r\\n\\r\\n dpsi1 = np.dot(self.Cpsi1V, V.T)\\r\\n\\r\\n start = np.zeros(self.input_dim * 2)\\r\\n\\r\\n for n, dpsi1_n in enumerate(dpsi1.T[:, :, None]):\\r\\n args = (self.kern, self.Z, dpsi0, dpsi1_n.T, dpsi2)\\r\\n xopt, fopt, neval, status = SCG(f=latent_cost, gradf=latent_grad, x=start, optargs=args, display=False)\\r\\n\\r\\n mu, log_S = xopt.reshape(2, 1, -1)\\r\\n means[n] = mu[0].copy()\\r\\n covars[n] = np.exp(log_S[0]).copy()\\r\\n\\r\\n return means, covars\",\n \"def euc_dist(self, squared=True):\",\n \"def linear_LS_triangulation(u1, P1, u2, P2):\\n A = np.zeros((4, 3))\\n b = np.zeros((4, 1))\\n\\n # Create array of triangulated points\\n x = np.zeros((3, len(u1)))\\n\\n # Initialize C matrices\\n C1 = np.array(linear_LS_triangulation_C)\\n C2 = np.array(linear_LS_triangulation_C)\\n\\n for i in range(len(u1)):\\n # Derivation of matrices A and b:\\n # for each camera following equations hold in case of perfect point matches:\\n # u.x * (P[2,:] * x) = P[0,:] * x\\n # u.y * (P[2,:] * x) = P[1,:] * x\\n # and imposing the constraint:\\n # x = [x.x, x.y, x.z, 1]^T\\n # yields:\\n # (u.x * P[2, 0:3] - P[0, 0:3]) * [x.x, x.y, x.z]^T + (u.x * P[2, 3] - P[0, 3]) * 1 = 0\\n # (u.y * P[2, 0:3] - P[1, 0:3]) * [x.x, x.y, x.z]^T + (u.y * P[2, 3] - P[1, 3]) * 1 = 0\\n # and since we have to do this for 2 cameras, and since we imposed the constraint,\\n # we have to solve 4 equations in 3 unknowns (in LS sense).\\n #\\n # Build C matrices, to construct A and b in a concise way\\n C1[:, 2] = u1[i, :]\\n C2[:, 2] = u2[i, :]\\n\\n # Build A matrix:\\n # [\\n # [ u1.x * P1[2,0] - P1[0,0], u1.x * P1[2,1] - P1[0,1], u1.x * P1[2,2] - P1[0,2] ],\\n # [ u1.y * P1[2,0] - P1[1,0], u1.y * P1[2,1] - P1[1,1], u1.y * P1[2,2] - P1[1,2] ],\\n # [ u2.x * P2[2,0] - P2[0,0], u2.x * P2[2,1] - P2[0,1], u2.x * P2[2,2] - P2[0,2] ],\\n # [ u2.y * P2[2,0] - P2[1,0], u2.y * P2[2,1] - P2[1,1], u2.y * P2[2,2] - P2[1,2] ]\\n # ]\\n A[0:2, :] = C1.dot(P1[0:3, 0:3]) # C1 * R1\\n A[2:4, :] = C2.dot(P2[0:3, 0:3]) # C2 * R2\\n\\n # Build b vector:\\n # [\\n # [ -(u1.x * P1[2,3] - P1[0,3]) ],\\n # [ -(u1.y * P1[2,3] - P1[1,3]) ],\\n # [ -(u2.x * P2[2,3] - P2[0,3]) ],\\n # [ -(u2.y * P2[2,3] - P2[1,3]) ]\\n # ]\\n b[0:2, :] = C1.dot(P1[0:3, 3:4]) # C1 * t1\\n b[2:4, :] = C2.dot(P2[0:3, 3:4]) # C2 * t2\\n b *= -1\\n\\n # Solve for x vector\\n cv2.solve(A, b, x[:, i:i + 1], cv2.DECOMP_SVD)\\n\\n return np.transpose(x), np.ones(len(u1), dtype=bool)\",\n \"def compute_ul_ur(self, dt):\\n\\n g = self.grid\\n # compute the piecewise linear slopes\\n # here we define the range cells considered, including 1 ghost cell\\n # on each side\\n ib = g.ng-1\\n ie = g.ng + g.N\\n\\n u = g.u\\n \\n # initialize empty arrays\\n dc = np.zeros((g.N+2*g.ng))\\n dl = np.zeros((g.N+2*g.ng))\\n dr = np.zeros((g.N+2*g.ng))\\n \\n dc[ib:ie+1] = 0.5*(u[ib+1:ie+2] - u[ib-1:ie ])\\n dl[ib:ie+1] = u[ib+1:ie+2] - u[ib :ie+1]\\n dr[ib:ie+1] = u[ib :ie+1] - u[ib-1:ie ]\\n\\n # minmod()\\n # fabs is the absolute value for real valued inputs\\n # where does np.where(condition,if true keep this value, else this)\\n # d1 = 2.0*np.where(np.fabs(dl) < np.fabs(dr), dl, dr)\\n d1 = np.zeros((len(dl)))\\n for i in range(len(dl)):\\n if np.fabs(dl[i]) < np.fabs(dr[i]):\\n d1[i] = dl[i]\\n else:\\n d1[i] = dr[i]\\n d1 = 2.0*d1\\n \\n d2 = np.zeros((len(dc)))\\n for i in range(len(dc)):\\n if np.fabs(dc[i]) < np.fabs(d1[i]):\\n d2[i] = dc[i]\\n else:\\n d2[i] = d1[i] \\n \\n # d2 = np.where(np.fabs(dc) < np.fabs(d1), dc, d1)\\n ldeltau = np.zeros((len(d2)))\\n for i in range(len(d2)):\\n if dl[i]*dr[i] > 0.0:\\n ldeltau[i] = d2[i]\\n else:\\n ldeltau[i] = 0.0\\n # ldeltau = np.where(dl*dr > 0.0, d2, 0.0)\\n\\n # interface states. \\n # Note from hydro_examples:\\n # note that there are 1 more interfaces than zones\\n ul = np.zeros((g.N+2*g.ng))\\n ur = np.zeros((g.N+2*g.ng))\\n\\n ur[ib:ie+2] = u[ib:ie+2] - \\\\\\n 0.5*(1.0 + u[ib:ie+2]*dt/self.grid.dx)*ldeltau[ib:ie+2]\\n\\n ul[ib+1:ie+2] = u[ib:ie+1] + \\\\\\n 0.5*(1.0 - u[ib:ie+1]*dt/self.grid.dx)*ldeltau[ib:ie+1]\\n\\n return ul, ur\",\n \"def cayley_menger_det_no_linalg(x2, y2, z2, xb2, yb2, zb2):\\n xs = x2 + xb2\\n ys = y2 + yb2\\n zs = z2 + zb2\\n buf1 = ys + zs\\n buf1 -= xs\\n buf2 = x2 * xb2\\n buf1 *= buf2 # buf1 has first term, halved\\n np.multiply(y2, yb2, out=buf2)\\n buf3 = xs + zs\\n buf3 -= ys\\n buf2 *= buf3 # buf2 has second term\\n buf1 += buf2 # buf1 is sum of two terms, halved\\n np.multiply(z2, zb2, out=buf3)\\n np.add(xs, ys, out=buf2) # reuse buf2\\n buf2 -= zs\\n buf3 *= buf2 # buf3 has third term\\n buf1 += buf3 # buf1 is sum of 3 first terms, halved\\n buf1 *= 2\\n np.subtract(x2, xb2, out=buf2)\\n np.subtract(y2, yb2, out=buf3)\\n buf2 *= buf3\\n np.subtract(z2, zb2, out=buf3)\\n buf2 *= buf3\\n buf1 += buf2 # buf1 is sum of 4 first terms\\n np.multiply(xs, ys, out=buf3)\\n buf3 *= zs\\n buf1 -= buf3\\n return buf1\",\n \"def computeNormalAndCurvature():\\n radius = 50\\n for i,j in pts:\\n nb_pts = ti.cast(0, ti.f32)\\n accu_0 = ti.cast(0, ti.f32)\\n accu_1 = ti.cast(0, ti.f32)\\n accu_2 = ti.cast(0, ti.f32)\\n accu_3 = ti.cast(0, ti.f32)\\n accu_4 = ti.cast(0, ti.f32)\\n accu_5 = ti.cast(0, ti.f32)\\n accu_6 = ti.cast(0, ti.f32)\\n accu_7 = ti.cast(0, ti.f32)\\n accu_8 = ti.cast(0, ti.f32)\\n z = 0\\n for x in range(i-radius, i+radius):\\n for y in range(j-radius, j+radius):\\n if ti.is_active(block1, [x,y]):\\n accu_0 += x * x\\n accu_1 += x * y\\n accu_2 += x * z\\n accu_3 += y * y\\n accu_4 += y * z\\n accu_5 += z * z\\n accu_6 += x\\n accu_7 += y\\n accu_8 += z\\n nb_pts += 1\\n accu_0 /= nb_pts\\n accu_1 /= nb_pts\\n accu_2 /= nb_pts\\n accu_3 /= nb_pts\\n accu_4 /= nb_pts\\n accu_5 /= nb_pts\\n accu_6 /= nb_pts\\n accu_7 /= nb_pts\\n accu_8 /= nb_pts\\n cov_mat_0 = accu_0 - accu_6 * accu_6\\n cov_mat_1 = accu_1 - accu_6 * accu_7\\n cov_mat_2 = accu_2 - accu_6 * accu_8\\n cov_mat_4 = accu_3 - accu_7 * accu_7\\n cov_mat_5 = accu_4 - accu_7 * accu_8\\n cov_mat_8 = accu_5 - accu_8 * accu_8\\n cov_mat_3 = cov_mat_1\\n cov_mat_6 = cov_mat_2\\n cov_mat_7 = cov_mat_5\\n\\n # Compute eigen value and eigen vector\\n # Make sure in [-1, 1]\\n scale = ti.max(1.0, ti.abs(cov_mat_0))\\n scale = ti.max(scale, ti.abs(cov_mat_1))\\n scale = ti.max(scale, ti.abs(cov_mat_2))\\n scale = ti.max(scale, ti.abs(cov_mat_3))\\n scale = ti.max(scale, ti.abs(cov_mat_4))\\n scale = ti.max(scale, ti.abs(cov_mat_5))\\n scale = ti.max(scale, ti.abs(cov_mat_6))\\n scale = ti.max(scale, ti.abs(cov_mat_7))\\n scale = ti.max(scale, ti.abs(cov_mat_8))\\n if scale > 1.0:\\n cov_mat_0 /= scale\\n cov_mat_1 /= scale\\n cov_mat_2 /= scale\\n cov_mat_3 /= scale\\n cov_mat_4 /= scale\\n cov_mat_5 /= scale\\n cov_mat_6 /= scale\\n cov_mat_7 /= scale\\n cov_mat_8 /= scale\\n \\n # Compute roots\\n eigen_val_0 = ti.cast(0, ti.f32)\\n eigen_val_1 = ti.cast(0, ti.f32)\\n eigen_val_2 = ti.cast(0, ti.f32)\\n \\n c0 = cov_mat_0 * cov_mat_4 * cov_mat_8 \\\\\\n + 2 * cov_mat_3 * cov_mat_6 * cov_mat_7 \\\\\\n - cov_mat_0 * cov_mat_7 * cov_mat_7 \\\\\\n - cov_mat_4 * cov_mat_6 * cov_mat_6 \\\\\\n - cov_mat_8 * cov_mat_3 * cov_mat_3\\n c1 = cov_mat_0 * cov_mat_4 \\\\\\n - cov_mat_3 * cov_mat_3 \\\\\\n + cov_mat_0 * cov_mat_8 \\\\\\n - cov_mat_6 * cov_mat_6 \\\\\\n + cov_mat_4 * cov_mat_8 \\\\\\n - cov_mat_7 * cov_mat_7\\n c2 = cov_mat_0 + cov_mat_4 + cov_mat_8\\n \\n if ti.abs(c0) < 0.00001:\\n eigen_val_0 = 0\\n d = c2 * c2 - 4.0 * c1\\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\\n d = 0.0\\n sd = ti.sqrt(d)\\n eigen_val_2 = 0.5 * (c2 + sd)\\n eigen_val_1 = 0.5 * (c2 - sd)\\n else:\\n s_inv3 = ti.cast(1.0 / 3.0, ti.f32)\\n s_sqrt3 = ti.sqrt(3.0)\\n c2_over_3 = c2 * s_inv3\\n a_over_3 = (c1 - c2 * c2_over_3) * s_inv3\\n if a_over_3 > 0:\\n a_over_3 = 0\\n \\n half_b = 0.5 * (c0 + c2_over_3 * (2 * c2_over_3 * c2_over_3 - c1))\\n q = half_b * half_b + a_over_3 * a_over_3 * a_over_3\\n if q > 0:\\n q = 0\\n \\n rho = ti.sqrt(-a_over_3)\\n theta = ti.atan2(ti.sqrt(-q), half_b) * s_inv3\\n cos_theta = ti.cos(theta)\\n sin_theta = ti.sin(theta)\\n eigen_val_0 = c2_over_3 + 2 * rho * cos_theta\\n eigen_val_1 = c2_over_3 - rho * (cos_theta + s_sqrt3 * sin_theta)\\n eigen_val_2 = c2_over_3 - rho * (cos_theta - s_sqrt3 * sin_theta)\\n temp_swap = ti.cast(0, ti.f32)\\n \\n # Sort in increasing order.\\n if eigen_val_0 >= eigen_val_1:\\n temp_swap = eigen_val_1\\n eigen_val_1 = eigen_val_0\\n eigen_val_0 = temp_swap\\n if eigen_val_1 >= eigen_val_2:\\n temp_swap = eigen_val_2\\n eigen_val_2 = eigen_val_1\\n eigen_val_1 = temp_swap\\n if eigen_val_0 >= eigen_val_1:\\n temp_swap = eigen_val_1\\n eigen_val_1 = eigen_val_0\\n eigen_val_0 = temp_swap\\n \\n if eigen_val_0 <= 0:\\n eigen_val_0 = 0\\n d = c2 * c2 - 4.0 * c1\\n if d < 0.0: # no real roots ! THIS SHOULD NOT HAPPEN!\\n d = 0.0\\n sd = ti.sqrt(d)\\n eigen_val_2 = 0.5 * (c2 + sd)\\n eigen_val_1 = 0.5 * (c2 - sd)\\n # end of compute roots\\n\\n eigen_value = eigen_val_1 * scale # eigen value for 2D SDF\\n # eigen value for 3D SDF\\n #eigen_value = eigen_val_0 * scale\\n\\n #print(\\\"eigen_val_0 \\\", eigen_val_0)\\n #print(\\\"eigen_val_1 \\\", eigen_val_1)\\n #print(\\\"eigen_val_2 \\\", eigen_val_2)\\n \\n # TODO\\n #scaledMat.diagonal ().array () -= eigenvalues (0)\\n #eigenvector = detail::getLargest3x3Eigenvector<Vector> (scaledMat).vector;\\n\\n # Compute normal vector (TODO)\\n #visual_norm[i,j][0] = eigen_val_0 #eigen_vector[0]\\n #visual_norm[i,j][1] = eigen_val_1 #eigen_vector[1]\\n #visual_norm[i,j][2] = eigen_val_2 #eigen_vector[2]\\n\\n # Compute the curvature surface change\\n eig_sum = cov_mat_0 + cov_mat_1 + cov_mat_2\\n visual_curv[i,j][0] = 0\\n if eig_sum != 0:\\n visual_curv[i,j][0] = eigen_val_1 # true curvature is: ti.abs(eigen_value / eig_sum)\",\n \"def calc_refl(velocity, shotloc_x, shotloc_z, layer_idxs):\\n solver_dg = pykonal.EikonalSolver(coord_sys=\\\"cartesian\\\")\\n solver_dg.vv.min_coords = velocity.min_coords\\n solver_dg.vv.node_intervals = velocity.node_intervals\\n solver_dg.vv.npts = velocity.npts\\n solver_dg.vv.values = velocity.values\\n\\n #shotloc = 2.56 # km\\n src_idx = (int((shotloc_x - velocity.min_coords[0])/velocity.node_intervals[0]), int(shotloc_z/velocity.node_intervals[1]), 0)\\n solver_dg.tt.values[src_idx] = 0\\n solver_dg.unknown[src_idx] = False\\n solver_dg.trial.push(*src_idx)\\n solver_dg.solve()\\n\\n solver_ug = pykonal.EikonalSolver(coord_sys=\\\"cartesian\\\")\\n solver_ug.vv.min_coords = solver_dg.vv.min_coords\\n solver_ug.vv.node_intervals = solver_dg.vv.node_intervals\\n solver_ug.vv.npts = solver_dg.vv.npts\\n solver_ug.vv.values = solver_dg.vv.values\\n\\n for ix in range(solver_ug.tt.npts[0]):\\n #idx = (ix, solver_ug.tt.npts[1]-1, 0)\\n idx = (ix, layer_idxs[ix], 0)\\n solver_ug.tt.values[idx] = solver_dg.tt.values[idx]\\n #print(idx, solver_dg.tt.values[idx])\\n solver_ug.unknown[idx] = False\\n solver_ug.trial.push(*idx)\\n solver_ug.solve()\\n \\n return solver_ug.tt.values[:,0,0]\",\n \"def test_lfc_pos_area_below_lcl():\\n p = [902.1554, 897.9034, 893.6506, 889.4047, 883.063, 874.6284, 866.2387, 857.887,\\n 849.5506, 841.2686, 833.0042, 824.7891, 812.5049, 796.2104, 776.0027, 751.9025,\\n 727.9612, 704.1409, 680.4028, 656.7156, 629.077, 597.4286, 565.6315, 533.5961,\\n 501.2452, 468.493, 435.2486, 401.4239, 366.9387, 331.7026, 295.6319, 258.6428,\\n 220.9178, 182.9384, 144.959, 106.9778, 69.00213] * units.hPa\\n t = [-3.039381, -3.703779, -4.15996, -4.562574, -5.131827, -5.856229, -6.568434,\\n -7.276881, -7.985013, -8.670911, -8.958063, -7.631381, -6.05927, -5.083627,\\n -5.11576, -5.687552, -5.453021, -4.981445, -5.236665, -6.324916, -8.434324,\\n -11.58795, -14.99297, -18.45947, -21.92021, -25.40522, -28.914, -32.78637,\\n -37.7179, -43.56836, -49.61077, -54.24449, -56.16666, -57.03775, -58.28041,\\n -60.86264, -64.21677] * units.degC\\n td = [-22.08774, -22.18181, -22.2508, -22.31323, -22.4024, -22.51582, -22.62526,\\n -22.72919, -22.82095, -22.86173, -22.49489, -21.66936, -21.67332, -21.94054,\\n -23.63561, -27.17466, -31.87395, -38.31725, -44.54717, -46.99218, -43.17544,\\n -37.40019, -34.3351, -36.42896, -42.1396, -46.95909, -49.36232, -48.94634,\\n -47.90178, -49.97902, -55.02753, -63.06276, -72.53742, -88.81377, -93.54573,\\n -92.92464, -91.57479] * units.degC\\n prof = parcel_profile(p, t[0], td[0]).to('degC')\\n lfc_p, lfc_t = lfc(p, t, td, prof)\\n assert_nan(lfc_p, p.units)\\n assert_nan(lfc_t, t.units)\",\n \"def _calc_longitudes(self):\\n assert self.tracers\\n\\n # zp is z unit vector at all times, shape 501 x 3\\n zp = np.cross(self.p0_positions, self.p0_velocities)\\n zp = zp / np.linalg.norm(zp, axis=-1)[:, None]\\n\\n # xp and yp are x and y unit vectors\\n xp = self.p0_positions\\n xp = xp / np.linalg.norm(xp, axis=-1)[:, None]\\n yp = np.cross(zp, xp)\\n\\n # project particle positions into orbital x-y plane\\n p1_xp = np.sum(self.p1_positions * xp[:, None, :], axis=-1)\\n p1_yp = np.sum(self.p1_positions * yp[:, None, :], axis=-1)\\n p2_xp = np.sum(self.p2_positions * xp[:, None, :], axis=-1)\\n p2_yp = np.sum(self.p2_positions * yp[:, None, :], axis=-1)\\n\\n # get longitudes\\n p1_phi = np.arctan2(p1_yp, p1_xp)\\n p2_phi = np.arctan2(p2_yp, p2_xp)\\n\\n # add/subtract multiples of 2pi for particles on higher wraps.\\n dp = np.vstack((np.zeros((1, self.N1)), np.diff(p1_phi, axis=0)))\\n for j in range(self.N1):\\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\\n for i in range(changes.size):\\n p1_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\\n dp = np.vstack((np.zeros((1, self.N2)), np.diff(p2_phi, axis=0)))\\n for j in range(self.N2):\\n changes = np.where(np.abs(dp[:, j]) > 1.1 * pi)[0]\\n for i in range(changes.size):\\n p2_phi[changes[i]:, j] -= 2 * pi * np.sign(dp[changes[i], j])\\n\\n return p1_phi, p2_phi\",\n \"def weyl_coordinates(U: np.ndarray) -> np.ndarray:\\n import scipy.linalg as la\\n\\n pi2 = np.pi / 2\\n pi4 = np.pi / 4\\n\\n U = U / la.det(U) ** (0.25)\\n Up = transform_to_magic_basis(U, reverse=True)\\n # We only need the eigenvalues of `M2 = Up.T @ Up` here, not the full diagonalization.\\n D = la.eigvals(Up.T @ Up)\\n\\n d = -np.angle(D) / 2\\n d[3] = -d[0] - d[1] - d[2]\\n cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)\\n\\n # Reorder the eigenvalues to get in the Weyl chamber\\n cstemp = np.mod(cs, pi2)\\n np.minimum(cstemp, pi2 - cstemp, cstemp)\\n order = np.argsort(cstemp)[[1, 2, 0]]\\n cs = cs[order]\\n d[:3] = d[order]\\n\\n # Flip into Weyl chamber\\n if cs[0] > pi2:\\n cs[0] -= 3 * pi2\\n if cs[1] > pi2:\\n cs[1] -= 3 * pi2\\n conjs = 0\\n if cs[0] > pi4:\\n cs[0] = pi2 - cs[0]\\n conjs += 1\\n if cs[1] > pi4:\\n cs[1] = pi2 - cs[1]\\n conjs += 1\\n if cs[2] > pi2:\\n cs[2] -= 3 * pi2\\n if conjs == 1:\\n cs[2] = pi2 - cs[2]\\n if cs[2] > pi4:\\n cs[2] -= pi2\\n\\n return cs[[1, 0, 2]]\",\n \"def cie_luv(self):\\n K = Fraction(29, 3) ** 3\\n e = Fraction(6, 29) ** 3\\n XYZ = self.cie_xyz\\n yr = XYZ[1] / D65[1]\\n L = 116 * yr ** Fraction(1, 3) - 16 if yr > e else K * yr\\n u = 13 * L * (U(*XYZ) - U(*D65))\\n v = 13 * L * (V(*XYZ) - V(*D65))\\n return (L, u, v)\",\n \"def __init__(self, u1=(1,0,0), u2=(0,1,0), u3=(0,0,1)):\\n u1 = vec3(u1)\\n u2 = vec3(u2)\\n u3 = vec3(u3)\\n\\n if triple_scalar_product(u1, u2, u3) != 1:\\n print >> sys.stderr, \\\"!! Invalid lattice vectors: u1 = %s, u2 = %s, u3 = %s\\\" % (u1,u2,u3)\\n self.e1 = vec3(1,0,0)\\n self.e2 = vec3(0,1,0)\\n self.e3 = vec3(0,0,1)\\n else:\\n s1 = square(u1)\\n s2 = square(u2)\\n d12 = dot(u1, u2)\\n d23 = dot(u2, u3)\\n d13 = dot(u1, u3)\\n alpha = -d12/s1\\n gamma = -(alpha*d13 + d23)/(alpha*d12 + s2)\\n beta = -(d13 + gamma*d12)/s1\\n self.e1 = u1\\n self.e2 = u2 + alpha*u1\\n self.e3 = u3 + beta*u1 + gamma*u2\\n\\n if verbose:\\n print(\\\"e1 = %s\\\" % self.e1)\\n print(\\\"e2 = %s\\\" % self.e2)\\n print(\\\"e3 = %s\\\" % self.e3)\\n\\n self.L1 = length(self.e1)\\n self.L2 = length(self.e2)\\n self.L3 = length(self.e3)\\n self.n1 = self.e1/self.L1\\n self.n2 = self.e2/self.L2\\n self.n3 = self.e3/self.L3\\n self.cells = []\\n\\n v0 = vec3(0,0,0)\\n self.v = [v0,\\n v0 + self.e3,\\n v0 + self.e2,\\n v0 + self.e2 + self.e3,\\n v0 + self.e1,\\n v0 + self.e1 + self.e3,\\n v0 + self.e1 + self.e2,\\n v0 + self.e1 + self.e2 + self.e3]\\n\\n # Compute bounding box of cuboid\\n xs = [vk.x for vk in self.v]\\n ys = [vk.y for vk in self.v]\\n zs = [vk.z for vk in self.v]\\n vmin = vec3(min(xs), min(ys), min(zs))\\n vmax = vec3(max(xs), max(ys), max(zs))\\n\\n # Extend to nearest integer coordinates\\n ixmin = int(floor(vmin.x))\\n ixmax = int(ceil(vmax.x))\\n iymin = int(floor(vmin.y))\\n iymax = int(ceil(vmax.y))\\n izmin = int(floor(vmin.z))\\n izmax = int(ceil(vmax.z))\\n if verbose:\\n print(\\\"ixmin, ixmax = %d, %d\\\" % (ixmin,ixmax))\\n print(\\\"iymin, iymax = %d, %d\\\" % (iymin,iymax))\\n print(\\\"izmin, izmax = %d, %d\\\" % (izmin,izmax))\\n\\n # Determine which cells (and which faces within those cells) are non-trivial\\n for ix in range(ixmin, ixmax):\\n for iy in range(iymin, iymax):\\n for iz in range(izmin, izmax):\\n shift = vec3(-ix, -iy, -iz)\\n faces = [Plane(self.v[0] + shift, +self.n1),\\n Plane(self.v[4] + shift, -self.n1),\\n Plane(self.v[0] + shift, +self.n2),\\n Plane(self.v[2] + shift, -self.n2),\\n Plane(self.v[0] + shift, +self.n3),\\n Plane(self.v[1] + shift, -self.n3)]\\n\\n c = Cell(ix, iy, iz)\\n skipcell = False\\n for f in faces:\\n r = UnitCubeTest(f)\\n if r == +1:\\n # Unit cube is completely above this plane; this cell is empty\\n continue\\n elif r == 0:\\n # Unit cube intersects this plane; keep track of it\\n c.faces.append(f)\\n elif r == -1:\\n skipcell = True\\n break\\n\\n if skipcell or len(c.faces) == 0:\\n if verbose:\\n print(\\\"Skipping cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n continue\\n else:\\n self.cells.append(c)\\n if verbose:\\n print(\\\"Adding cell at (%d,%d,%d)\\\" % (ix,iy,iz))\\n\\n # For the identity remapping, use exactly one cell\\n if len(self.cells) == 0:\\n self.cells.append(Cell())\\n\\n # Print the full list of cells\\n if verbose:\\n print(\\\"%d non-empty cells\\\" % len(self.cells))\\n for c in self.cells:\\n print(\\\"Cell at (%d,%d,%d) has %d non-trivial planes\\\" % (c.ix,\\n c.iy, c.iz, len(c.faces)))\",\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def _apply_array_spatial12_lowfilling_python(self, h1e: 'Nparray',\\n h2e: 'Nparray') -> 'Nparray':\\n out = self._apply_array_spatial1(h1e)\\n\\n norb = self.norb()\\n nalpha = self.nalpha()\\n nbeta = self.nbeta()\\n lena = self.lena()\\n lenb = self.lenb()\\n nlt = norb * (norb + 1) // 2\\n\\n h2ecomp = numpy.zeros((nlt, nlt), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for k in range(norb):\\n for l in range(k + 1, norb):\\n h2ecomp[ijn, k + l * (l + 1) // 2] = (h2e[i, j, k, l] -\\n h2e[i, j, l, k] -\\n h2e[j, i, k, l] +\\n h2e[j, i, l, k])\\n\\n if nalpha - 2 >= 0:\\n alpha_map, _ = self._core.find_mapping(-2, 0)\\n intermediate = numpy.zeros(\\n (nlt, int(binom(norb, nalpha - 2)), lenb), dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n work = self.coeff[source, :] * parity\\n intermediate[ijn, target, :] += work\\n\\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in alpha_map[(i, j)]:\\n out[source, :] -= intermediate[ijn, target, :] * parity\\n\\n if self.nalpha() - 1 >= 0 and self.nbeta() - 1 >= 0:\\n alpha_map, beta_map = self._core.find_mapping(-1, -1)\\n intermediate = numpy.zeros((norb, norb, int(binom(\\n norb, nalpha - 1)), int(binom(norb, nbeta - 1))),\\n dtype=self._dtype)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n sign = ((-1)**(nalpha - 1)) * paritya\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = self.coeff[sourcea, sourceb] * sign * parityb\\n intermediate[i, j, targeta, targetb] += 2 * work\\n\\n intermediate = numpy.tensordot(h2e, intermediate, axes=2)\\n\\n for i in range(norb):\\n for j in range(norb):\\n for sourcea, targeta, paritya in alpha_map[(i,)]:\\n sign = ((-1)**nalpha) * paritya\\n for sourceb, targetb, parityb in beta_map[(j,)]:\\n work = intermediate[i, j, targeta, targetb] * sign\\n out[sourcea, sourceb] += work * parityb\\n\\n if self.nbeta() - 2 >= 0:\\n _, beta_map = self._core.find_mapping(0, -2)\\n intermediate = numpy.zeros((nlt, lena, int(binom(norb, nbeta - 2))),\\n dtype=self._dtype)\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, parity in beta_map[(i, j)]:\\n work = self.coeff[:, source] * parity\\n intermediate[ijn, :, target] += work\\n\\n intermediate = numpy.tensordot(h2ecomp, intermediate, axes=1)\\n\\n for i in range(norb):\\n for j in range(i + 1, norb):\\n ijn = i + j * (j + 1) // 2\\n for source, target, sign in beta_map[(min(i, j), max(i,\\n j))]:\\n out[:, source] -= intermediate[ijn, :, target] * sign\\n return out\",\n \"def LLE(data, n_components=2, n_neighbors=10):\\n # Compute the nearest neighbors\\n _, neighbors_idx = AffiinityMAt(data,n_neighbor=n_neighbors,kernel_method='Linear')\\n\\n n = data.shape[0]\\n w = np.zeros((n, n))\\n for i in range(n):\\n # Center the neighbors matrix\\n k_indexes = neighbors_idx[i, :]\\n neighbors = data[k_indexes, :] - data[i, :]\\n\\n # Compute the corresponding gram matrix\\n gram_inv = np.linalg.pinv(np.dot(neighbors, neighbors.T))\\n\\n # Setting the weight values according to the lagrangian\\n lambda_par = 2/np.sum(gram_inv)\\n w[i, k_indexes] = lambda_par*np.sum(gram_inv, axis=1)/2\\n m = np.subtract(np.eye(n), w)\\n values, u = np.linalg.eigh(np.dot(np.transpose(m), m))\\n return u[:, 1:n_components+1]\",\n \"def needleman_wunsch1(x,y,lodict=None,gop=-2.5, gep=-1.75, local=False):\\n n,m = len(x),len(y)\\n dp = np.zeros((n+1,m+1))\\n pointers = np.zeros((n+1,m+1),np.int32)\\n for i in range(1,n+1):\\n dp[i,0] = dp[i-1,0]+(gep if i>1 else gop)\\n pointers[i,0]=1\\n for j in range(1,m+1):\\n dp[0,j] = dp[0,j-1]+(gep if j>1 else gop)\\n pointers[0,j]=2\\n for i in range(1,n+1):\\n for j in range(1,m+1):\\n if not lodict:\\n if x[i-1] == y[j-1]:\\n match = dp[i-1,j-1]+1\\n else:\\n match = dp[i-1,j-1]-1\\n else:\\n match = dp[i-1,j-1]+lodict[x[i-1],y[j-1]]\\n insert = dp[i-1,j]+(gep if pointers[i-1,j]==1 else gop)\\n delet = dp[i,j-1]+(gep if pointers[i,j-1]==2 else gop)\\n max_score = max([match,insert,delet])\\n dp[i,j] = max_score\\n pointers[i,j] = [match,insert,delet].index(max_score)\\n alg = []\\n i,j = n,m\\n while(i>0 or j>0):\\n pt = pointers[i,j]\\n if pt==0:\\n i-=1\\n j-=1\\n alg = [[x[i],y[j]]]+alg\\n if pt==1:\\n i-=1\\n alg = [[x[i],'-']]+alg\\n if pt==2:\\n j-=1\\n alg = [['-',y[j]]]+alg\\n return dp[-1,-1], alg\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts) \\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def probability(N_dr, L_opmin, L_opmax, L_min, L_max, L_d):\\n opening_nomullignas = []\\n opening_withmullignas = []\\n sum_nomulligans = 0\\n sum_withmulligans = 0\\n mulligan_coeff = 0\\n\\n for i in range(L_opmin, min(L_opmax + 1, 8)): # first make a list of tuples of the form:\\n # (number_of_lands_in_opening_hand, probability_of_drawing_such_a_hand)\\n a = hypergeom(i, 7, 60, L_d)\\n opening_nomullignas.append((i, a))\\n mulligan_coeff = mulligan_coeff + a # this will be used later for calculating the probability of\\n # taking the mulligan and is used as a coefficient before the mulligan sum\\n for (x, y) in opening_nomullignas: # use the list of tuples to calculate the first part of equation 5\\n partial_nomulligans = 0\\n for j in range(L_min - x, L_max - x + 1):\\n partial_nomulligans = partial_nomulligans + hypergeom(j, N_dr, 53, L_d - x)\\n sum_nomulligans = sum_nomulligans + partial_nomulligans * y\\n\\n mulligan_coeff = 1 - mulligan_coeff # probability of mulliganing\\n for i in range(L_opmin, min(L_opmax + 1, 7)): # doing the same thing as before, but drawing 6 instead of 7 cards\\n a = hypergeom(i, 6, 60, L_d)\\n opening_withmullignas.append((i, a))\\n\\n for (x, y) in opening_withmullignas:\\n partial_withmulligans = 0\\n for j in range(L_min - x, L_max - x + 1):\\n partial_withmulligans = partial_withmulligans + hypergeom(j, N_dr, 54, L_d - x)\\n sum_withmulligans = sum_withmulligans + partial_withmulligans * y\\n total_withmulligans = mulligan_coeff * sum_withmulligans\\n\\n return total_withmulligans + sum_nomulligans\",\n \"def l2p(x, y):\\n \\n return square_size[0]*x, square_size[1]*y\",\n \"def l2_norm(self):\\n return (self.x**2 + self.y**2 + self.z**2)**0.5\",\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 vincenty(lat1, lon1, lat2, lon2,\\n r_major=6378.1370, r_minor=6356.752314, r_sphere=None):\\n lat1 = m.radians(lat1)\\n lat2 = m.radians(lat2)\\n lon1 = m.radians(lon1)\\n lon2 = m.radians(lon2)\\n \\n if (r_sphere is not None):\\n r_major = r_sphere\\n r_minor = r_sphere\\n f = 0.0\\n else:\\n f = (r_major-r_minor)/r_major\\n \\n U1 = m.atan((1.0-f) * m.tan(lat1))\\n U2 = m.atan((1.0-f) * m.tan(lat2))\\n L = lon2 - lon1\\n \\n epsilon = 1E-12 # Accuracy (10E-12 -> ~ 0.06mm)\\n max_iter = 500\\n lam = L\\n \\n cU1 = m.cos(U1)\\n cU2 = m.cos(U2)\\n sU1 = m.sin(U1)\\n sU2 = m.sin(U2)\\n \\n for i in range(max_iter):\\n lam_old = lam\\n sLam = m.sin(lam)\\n cLam = m.cos(lam)\\n sin_sig = m.sqrt((cU2*sLam)**2 + (cU1*sU2 - sU1*cU2*cLam)**2)\\n cos_sig = sU1*sU2 + cU1*cU2*cLam\\n sig = m.atan2(sin_sig,cos_sig)\\n sin_alp = (cU1*cU2*sLam) / sin_sig\\n cos2_alp = 1.0 - sin_alp**2\\n if (cos2_alp == 0.0):\\n # equitorial line\\n cos_2sigm = 100\\n C = 0.0\\n else:\\n cos_2sigm = cos_sig - (2.0*sU1*sU2)/cos2_alp\\n C = f/16.0 * cos2_alp * (4.0 + f*(4.0-3.0*cos2_alp))\\n lam = L + (1.0 - C) * f * sin_alp * \\\\\\n (sig + C * sin_sig * (cos_2sigm + C * cos_sig * \\\\\\n (-1.0 + 2.0 * cos_2sigm**2)))\\n if ((m.fabs(lam - lam_old)) <= epsilon):\\n # Found a solution in i iters...\\n break\\n elif (i == max_iter):\\n # Catch the out of iters case, never seen this.\\n raise Exception(\\\"Failed to solve for distance\\\")\\n \\n usq = cos2_alp * ((r_major**2 - r_minor**2) / r_minor**2)\\n A = 1 + usq/16384 * (4096 + usq*(-768 + usq*(320 - 175*usq)))\\n B = usq/1024 * (256 + usq*(-128 + usq*(74 - 47*usq)))\\n del_sig = B * sin_sig * (cos_2sigm + 0.25*B*(cos_sig*( \\\\\\n -1 + 2*cos_2sigm**2) - (1.0/6.0)*B*cos_2sigm * ( \\\\\\n -3 + 4*sin_sig**2) * (-3 + 4 * cos_2sigm**2)))\\n s = r_minor * A * (sig - del_sig)\\n alp1 = m.atan2(cU2*m.sin(lam),(cU1*sU2-sU1*cU2*m.cos(lam)))\\n alp2 = m.atan2(cU1*m.sin(lam),(cU1*sU2*m.cos(lam)-sU1*cU2))\\n\\n return (s, m.degrees(alp1), m.degrees(alp2))\",\n \"def l2(x, y):\\n return np.sum(((x - y) ** 2))\",\n \"def laplace_2d(x_loc, y_loc, u):\\n\\n assert u.shape == (x_loc.shape[0], y_loc.shape[0])\\n\\n dx = x_loc[1:] - x_loc[0:-1]\\n dy = y_loc[1:] - y_loc[0:-1]\\n\\n u_sol = u.copy()\\n error = 1\\n while error > 1e-3:\\n u = u_sol.copy()\\n u_sol[1:-1, 1:-1] = (dy[0:-1] * dy[1:] * (u_sol[2:, 1:-1] + u_sol[0:-2, 1:-1]) \\\\\\n + dx[0:-1] * dx[1:] * (u_sol[1:-1, 2:] + u_sol[1:-1, 0:-2])) \\\\\\n / (2 * (dy[0:-1] * dy[1:] + dx[0:-1] * dx[1:]))\\n\\n u_sol[0, :] = 0\\n u_sol[-1, :] = y_loc\\n u_sol[:, 0] = u_sol[:, 1]\\n u_sol[:, -1] = u_sol[:, -2]\\n\\n error = np.abs(np.sum(np.abs(u_sol[:]) - np.abs([u])) / np.sum(np.abs(u[:])))\\n return u_sol\",\n \"def LD(x, y, lodict={}):\\n return needleman_wunsch(x, y, lodict=lodict, gop=-1, gep=-1)\",\n \"def helical_consistency(p2i, p1):\\n\\tfrom pixel_error import angle_diff\\n\\tfrom math import cos,pi\\n\\tfrom utilities import getvec\\n\\tfrom pixel_error import angle_error\\n\\tfrom EMAN2 import Vec2f\\n\\tn =len(p1[0])\\n\\tprint n\\n\\tqtm = -1.0e10\\n\\tfor lf in xrange(0,181,180):\\n\\t\\tp2 = []\\n\\t\\tp2.extend(p2i)\\n\\t\\tif( lf == 180):\\n\\t\\t\\ttflip = Transform({\\\"type\\\":\\\"spider\\\",\\\"theta\\\":180.0})\\n\\t\\t\\tfor j in xrange(n):\\n\\t\\t\\t\\tt2 = Transform({\\\"type\\\":\\\"spider\\\",\\\"phi\\\":p2[0][j],\\\"theta\\\":p2[1][j],\\\"psi\\\":p2[2][j]})\\n\\t\\t\\t\\tt2.set_trans( Vec2f( -p2[3][j], -p2[4][j] ) )\\n\\t\\t\\t\\tt2 = t2*tflip\\n\\t\\t\\t\\td = t2.get_params(\\\"spider\\\")\\n\\t\\t\\t\\tp2[0][j] = d[\\\"phi\\\"]\\n\\t\\t\\t\\tp2[1][j] = d[\\\"theta\\\"]\\n\\t\\t\\t\\tp2[2][j] = d[\\\"psi\\\"]\\n\\t\\t\\t\\tp2[3][j] = -d[\\\"tx\\\"]\\n\\t\\t\\t\\tp2[4][j] = -d[\\\"ty\\\"]\\n\\t\\ttt1 = [0.0]*n\\n\\t\\ttt2 = [0.0]*n\\n\\t\\tmirror = [False]*n\\n\\t\\tln = 0\\n\\t\\tfor j in xrange( n ):\\n\\t\\t\\tt1 = getvec(p1[0][j],p1[1][j])\\n\\t\\t\\tt2 = getvec(p2[0][j],p2[1][j])\\n\\t\\t\\ttm = getvec(180.0+p2[0][j],180.0-p2[1][j])\\n\\t\\t\\ttt1[j] = t1[0]*t2[0]+t1[1]*t2[1]+t1[2]*t2[2]\\n\\t\\t\\ttt2[j] = t1[0]*tm[0]+t1[1]*tm[1]+t1[2]*tm[2]\\n\\t\\t\\tif(abs(tt1[j])<1.0e-7): tt1[j] = 0.0\\n\\t\\t\\tif(abs(tt2[j])<1.0e-7): tt2[j] = 0.0\\n\\t\\t\\tif(tt1[j]>tt2[j]):\\n\\t\\t\\t\\tmirror[j] = True\\n\\t\\t\\t\\tln+=1\\n\\t\\tprint \\\" FLIP \\\",lf\\n\\t\\tif(ln < n//2):\\n\\t\\t\\tprint \\\"mirror \\\",ln\\n\\t\\t\\tfor j in xrange( n ):\\n\\t\\t\\t\\tp2[0][j] += 180.0\\n\\t\\t\\t\\tp2[1][j] = 180.0-p2[1][j]\\n\\t\\t\\t\\tp2[2][j] = -p2[2][j]\\n\\t\\t\\t\\tp2[4][j] = -p2[4][j]\\n\\t\\t\\t\\tmirror[j] = not(mirror[j])\\n\\t\\telse:\\n\\t\\t\\tprint \\\" straight\\\", ln\\n\\t\\tphi1 = []\\n\\t\\tphi2 = []\\n\\t\\tagree = []\\n\\t\\tfor j in xrange(n):\\n\\t\\t\\tif(mirror[j]):\\n\\t\\t\\t\\tphi1.append(p1[0][j])\\n\\t\\t\\t\\tphi2.append(p2[0][j])\\n\\t\\t\\t\\tagree.append(j)\\n\\t\\tprint len(phi1)\\n\\t\\tdelta_phi = angle_diff( phi2, phi1 )\\n\\t\\tprint \\\"close form diff===\\\", delta_phi\\n\\n\\t\\tphi1 = []\\n\\t\\tphi2 = []\\n\\t\\terrorm = []\\n\\t\\tfor j in xrange( len( p1[0]) ):\\n\\t\\t\\tp2[0][j] = (p2[0][j] + delta_phi + 360)%360.0\\n\\t\\t\\tif(mirror[j]):\\n\\t\\t\\t\\tphi1.append(p1[0][j])\\n\\t\\t\\t\\tphi2.append(p2[0][j])\\n\\t\\t\\t\\terrorm.append(angle_error( [ p2[0][j] ], [ p1[0][j] ]))\\n\\t\\tqt = sum(errorm)/len(errorm)\\n\\t\\tprint len(errorm),qt\\n\\t\\tif(qt > qtm):\\n\\t\\t\\tqtm = qt\\n\\t\\t\\tp2o = []\\n\\t\\t\\tp2o.extend(p2)\\n\\t\\t\\terrormo = []\\n\\t\\t\\tphi1o = []\\n\\t\\t\\tphi2o = []\\n\\t\\t\\terrormo.extend(errorm)\\n\\t\\t\\tphi1o.extend(phi1)\\n\\t\\t\\tphi2o.extend(phi2)\\n\\t\\t\\n\\treturn p2o, errormo, agree, delta_phi, phi1o, phi2o\",\n \"def cross_junctions(I, bounds, Wpts):\\n #--- FILL ME IN ---\\n\\n Ipts = np.zeros((2, 48))\\n\\n#parameters\\n alpha = 0.15 #typically 0.04 to 0.06\\n threshold = 1500 #default 2000\\n sigma = 2\\n ws = 12 #window size for saddle point\\n\\n#building Harris Detecter\\n I = I/255.0\\n gradx, grady = np.gradient(I)\\n IxIx = gaussian_filter(gradx*gradx,sigma)\\n IxIy = gaussian_filter(gradx*grady,sigma)\\n IyIy = gaussian_filter(grady*grady,sigma)\\n print(I.shape)\\n\\n #get harris score\\n cand_score = []\\n cand_index = []\\n cand = []\\n s_cand = []\\n\\n for j in range(len(I)):\\n for i in range(len(I[0])):\\n a11 = IxIx[j][i]\\n a12 = IxIy[j][i]\\n a21 = a12\\n a22 = IyIy[j][i]\\n A = np.array([[a11, a12],[a21, a22]])\\n ev0, ev1 = np.linalg.eigvals(A)\\n h_score = ev0*ev1 - alpha*(ev0+ev1)**2\\n cand_score.append(-h_score)\\n cand_index.append([i, j])\\n\\n #get the coordinates of the top 5000 scores\\n sorted_ind = np.argsort(cand_score)\\n sorted_score = np.sort(cand_score).tolist()\\n\\n for ind in sorted_ind[:threshold]:\\n cand.append(cand_index[ind])\\n s_cand = sorted_score[:threshold]\\n\\n\\n#clustering\\n #using homography to project candidate points to a up-front view\\n new_bbox = np.array([[0, 100, 100, 0],[0, 0, 80, 80]])\\n H = dlt_homography(bounds, new_bbox)\\n cand = np.array(cand).T\\n cand = np.vstack((cand, np.ones(cand.shape[1])))\\n Ho_cand = np.matmul(H,cand).T\\n for pt in Ho_cand:\\n pt[0] = pt[0]/pt[2]\\n pt[1] = pt[1]/pt[2]\\n Ho_cand = Ho_cand[:,:2]\\n Ho_cand = Ho_cand.tolist()\\n\\n #get rid of points that are not in the boundry\\n temp_Ho_cand = []\\n temp_s_cand = []\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0]>=100) or (pt[0]<0) or (pt[1]>=80) or (pt[1]<0):\\n continue\\n else:\\n temp_Ho_cand.append(pt)\\n temp_s_cand.append(s_cand[i])\\n Ho_cand = np.array(temp_Ho_cand)\\n s_cand = temp_s_cand\\n #divide candidates into clusters\\n assignment = []\\n assignment_score = []\\n\\n #first put in the point that has the highest score\\n assignment.append([Ho_cand[0]])\\n assignment_score.append([s_cand[0]])\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n if min(dist) > 6:\\n assignment.append([pt])\\n assignment_score.append([s_cand[i]])\\n\\n assignment = np.array(assignment)\\n\\n #assign points to clusters\\n for i in range(len(Ho_cand)):\\n pt = Ho_cand[i]\\n if (pt[0] == Ho_cand[0][0]) and (pt[1] == Ho_cand[0][1]):\\n continue\\n dist = []\\n for c in assignment:\\n dist.append(np.linalg.norm(pt - c[0]))\\n index = np.argsort(dist)[-1]\\n np.append(assignment[index], pt)\\n assignment_score[index].append(s_cand[i])\\n\\n #get centroids for each cluster\\n Ho_centroids = []\\n for i in range(len(assignment)):\\n cl = assignment[i]\\n cl = np.array(cl)\\n Ho_centroids.append([np.mean(cl.T[0]),np.mean(cl.T[1])])\\n assignment_score[i] = sum(assignment_score[i])\\n\\n print(len(assignment_score))\\n\\n Ho_centroids = np.array(Ho_centroids)\\n #get rid of edge points\\n\\n xmin = np.amin(Ho_centroids.T[0])\\n xmax = np.amax(Ho_centroids.T[0]) \\n ymin = np.amin(Ho_centroids.T[1])\\n ymax = np.amax(Ho_centroids.T[1])\\n\\n final_cand = []\\n final_score = []\\n for i in range(len(Ho_centroids)):\\n pt = Ho_centroids[i]\\n if (abs(pt[0] - xmin) <= 3) or (abs(pt[0] - xmax) <= 3) or (abs(pt[1] - ymin) <= 3) or (abs(pt[1] - ymax) <= 3):\\n continue\\n else:\\n final_cand.append(pt)\\n final_score.append(assignment_score[i])\\n print(\\\"Number of corner found: \\\")\\n print(len(final_cand))\\n\\n #get rid of fake corners\\n if (len(final_cand)>48):\\n ultimate_cand =[]\\n for ind in np.argsort(final_score)[:48]:\\n ultimate_cand.append(final_cand[ind])\\n final_cand = ultimate_cand\\n print(\\\"real corners count:\\\", len(ultimate_cand))\\n\\n\\n #sort the points\\n final_cand = np.array(final_cand)\\n y_sort_ind = np.argsort(final_cand.T[1])\\n final_cand = final_cand.tolist()\\n rows = []\\n for i in range(6):\\n row = []\\n for ind in y_sort_ind[i*8:(i+1)*8]:\\n row.append(final_cand[ind])\\n rows.append(row)\\n\\n ordered = []\\n for row in rows:\\n r = []\\n x_sort_ind = np.argsort(np.array(row).T[0])\\n for ind in x_sort_ind:\\n r.append(row[ind])\\n ordered.append(r)\\n\\n final_cand = []\\n for row in ordered:\\n for pt in row:\\n final_cand.append(pt)\\n \\n\\n\\n #get coordinates of the centroids in the original frame\\n Ho_centroids = np.array(final_cand)\\n\\n centroids = np.vstack((Ho_centroids.T, np.ones(Ho_centroids.shape[0])))\\n centroids = np.matmul(np.linalg.inv(H), centroids).T\\n for pt in centroids:\\n pt[0] = int(pt[0]/pt[2])\\n pt[1] = int(pt[1]/pt[2])\\n centroids = centroids[:,:2]\\n\\n#finding saddle points around the centroids\\n saddle_points = []\\n for pt in centroids:\\n img = I[int(pt[1]-ws):int(pt[1]+ws), int(pt[0]-ws):int(pt[0]+ws)]\\n saddle = saddle_point(img)\\n saddle = [saddle[0][0]+pt[0]-ws, saddle[1][0]+pt[1]-ws]\\n saddle_points.append(saddle)\\n\\n saddle_points = np.array(saddle_points)\\n #------------------\\n print(saddle_points.T)\\n return saddle_points.T\",\n \"def strassen_dot(x, y):\\n# X = (A B) Y = (E F)\\n# (C D) (G H)\\n# \\n# A through H -- (n/2 x n/2) matrices\\n# \\n# let P1 = A(F-H), P2 = (A+B)H, P3 = (C+D)E, P4 = D(G-E), \\n# \\n# P5 = (A+D)(E+H), P6 = (B-D)(G+H), P7 = (A-C)(E+F)\\n# \\n# XY = (AE+BG AF+BH) = (P5+P4-P2+P6 P1+P2 )\\n# (CE+DG CF+DH) (P3+P4 P1+P5-P3-P7)\\n\\n n = x.shape[0]\\n originalN = n\\n \\n # base case (n<=8)\\n if n <= 8:\\n return brute_multiply(x, y)\\n \\n n_is_power_of_two = (n & (n-1) == 0)\\n\\n if not n_is_power_of_two:\\n # count the closest power of 2 above n\\n # and resize x and y matrices\\n newN = upper_pow_2(n)\\n \\n n = newN\\n \\n nX = np.zeros( (n, n) )\\n# mapping x on to nX:\\n nX[:originalN, :originalN] = x\\n x = nX\\n \\n nY = np.zeros( (n, n) )\\n# mapping y on to nY:\\n nY[:originalN, :originalN] = y\\n y = nY\\n \\n \\n a = x[ 0:n//2, 0:n//2 ]\\n b = x[ 0:n//2, n//2: ]\\n c = x[ n//2:, 0:n//2 ]\\n d = x[ n//2:, n//2: ]\\n\\n e = y[ 0:n//2, 0:n//2 ]\\n f = y[ 0:n//2, n//2: ]\\n g = y[ n//2:, 0:n//2 ]\\n h = y[ n//2:, n//2: ]\\n \\n# let P1 = A(F-H), P2 = (A+B)H, P3 = (C+D)E, P4 = D(G-E), \\n# \\n# P5 = (A+D)(E+H), P6 = (B-D)(G+H), P7 = (A-C)(E+F)\\n \\n # recursively compute 7 (SEVEN) products P1 .. P7\\n p1 = strassen_dot(a, f-h)\\n p2 = strassen_dot(a+b, h)\\n p3 = strassen_dot(c+d, e)\\n p4 = strassen_dot(d, g-e)\\n p5 = strassen_dot(a+d, e+h)\\n p6 = strassen_dot(b-d, g+h)\\n p7 = strassen_dot(a-c, e+f)\\n \\n# do the necessary (clever) additions & substractions with P1..P7\\n \\n# XY = (AE+BG AF+BH) = (P5+P4-P2+P6 P1+P2 )\\n# (CE+DG CF+DH) (P3+P4 P1+P5-P3-P7)\\n res1 = np.hstack( (p5+p4-p2+p6, p1+p2) )\\n res2 = np.hstack( (p3+p4, p1+p5-p3-p7) )\\n res = np.vstack( (res1, res2) )\\n\\n return res[:originalN, :originalN]\",\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 center_flows(L_wprime, U_wprime, L_w3, U_w3, L_overlap, U_overlap):\\n # examine every possible point\\n current_dist_to_edge = -1\\n point = (0,0)\\n #print(\\\"w3 range: [{}, {}]\\\".format(L_w3, U_w3))\\n #print(\\\"w' range: [{}, {}]\\\".format(L_wprime, U_wprime))\\n #print(\\\"overlap range: [{},{}]\\\".format(L_overlap, U_overlap))\\n for y in range(L_w3, U_w3 + 1):\\n #print(\\\"y={}\\\".format(y))\\n LH_bound = max(L_wprime, L_overlap - y)\\n #print(\\\"LH bound = {}\\\".format(LH_bound))\\n RH_bound = min(U_wprime, U_overlap - y)\\n #print(\\\"RH bound = {}\\\".format(RH_bound))\\n for x in range(LH_bound, RH_bound + 1):\\n # w3 UB: 0x + 1y - U_w3 = 0\\n # w3 LB: 0x + 1y - L_w3 = 0\\n # wprime UB: 1x + 0y - U_wprime\\n # wprime LB: 1x + 0y - L_wprime\\n # wprime + w3 UB: 1x + 1y - U_wprime,wk\\n # wprime + w3 LB: 1x + 1y - L_wprime,wk\\n dist_to_edge = min(distance_point_to_line(x, y, 0, -1, U_w3), #0x-1y+U_w3=0\\n distance_point_to_line(x, y, 0, -1, L_w3), #0x-1y+L_w3=0\\n # -1x + 0y + U_wprime = 0\\n distance_point_to_line(x, y, -1, 0, U_wprime),\\n # -1x + 0y + L_wprime = 0\\n distance_point_to_line(x, y, -1, 0, L_wprime),\\n # -1x - 1y + U_overlap = 0\\n distance_point_to_line(x, y, -1, -1, U_overlap),\\n # -1 x - y + L_overlap = 0\\n distance_point_to_line(x, y, -1, -1, L_overlap))\\n if dist_to_edge > current_dist_to_edge:\\n #print(\\\"At point ({},{}), distance to edge increased from {} to {}.\\\"\\\\\\n # .format(x,y,current_dist_to_edge,dist_to_edge))\\n current_dist_to_edge = dist_to_edge\\n point = (x,y)\\n return(point)\",\n \"def secondorder(self):\\n f = self.img\\n x = self.x\\n y = self.y\\n self.x2 = sum(f*x**2)/sum(f) - self.x1**2\\n self.y2 = sum(f*y**2)/sum(f) - self.y1**2\\n self.xy = sum(f*x*y)/sum(f) - self.x1*self.y1\",\n \"def l2(u: np.ndarray, v: np.ndarray) -> np.ndarray:\\n\\n return (u - v) ** 2\",\n \"def fdm_2d(N,L,x,y,h,k):\\n\\n # Create the Laplacian as a 1d sparse matrix using central difference\\n ones = np.ones(N)\\n diagvalues = np.array([ones,-2*ones,ones])\\n offsets = np.array([-1,0,1])\\n lap1d = sps.dia_matrix((diagvalues,offsets), shape=(N,N))/h**2\\n \\n # Represent 2d coordinates as kronecker sum\\n lap = sps.kron(lap1d,sps.diags(np.ones(N))) + \\\\\\n sps.kron(sps.diags(np.ones(N)),lap1d)\\n \\n # potential terms\\n pot_x = np.repeat(x**2,N)\\n pot_y = np.tile(y**2,N)\\n\\n # The whole Hamiltonian in matrix form\\n A = (-1*lap + sps.diags(pot_x) + sps.diags(pot_y))/2\\n\\n # Calculate the k smallest eigenvalues and corresponding eigenvectors\\n E, psi = eigsh(A,k=k,which='SM')\\n\\n\\n # Perturbated potential\\n a = 25\\n pot_new = pot_x + pot_y + gauss_pert(N,a).flatten()\\n\\n # Plot the new potential\\n X,Y = np.meshgrid(x,y)\\n fig = plt.figure()\\n ax = fig.add_subplot(1,2,1,projection='3d')\\n ax.plot_surface(X, Y, pot_new.reshape((N,N)), cmap=cm.coolwarm,\\n linewidth=0, antialiased=False)\\n ax = fig.add_subplot(1,2,2)\\n fig.suptitle(r'Potential with a Gaussian perturbation')\\n ax.imshow(pot_new.reshape(N,N),extent=[-L/2,L/2,-L/2,L/2])\\n plt.savefig(os.path.join(path,'perturbated_potential.png'))\\n\\n # The perturbated Hamiltonian in matrix form\\n A = (-1*lap + sps.diags(pot_new))/2\\n\\n # Calculate the k smallest eigenvalues and corresponding eigenvector\\n # Of the perturbated system\\n E_p, psi_p = eigsh(A,k=k,which='SM')\\n\\n return E,psi,E_p,psi_p\",\n \"def olivine():\\n\\n rho = 3355.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 320.5; C[0,1] = 68.15; C[0,2] = 71.6; C[0,3] = 0.; C[0,4] = 0.; C[0,5] = 0.\\n C[1,0] = C[0,1]; C[1,1] = 196.5; C[1,2] = 76.8; C[1,3] = 0.; C[1,4] = 0.; C[1,5] = 0.\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 233.5; C[2,3] = 0.; C[2,4] = 0.; C[2,5] = 0.\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 64.; C[3,4] = 0.; C[3,5] = 0.\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 77.; C[4,5] = 0.\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 78.7\\n\\n return C, rho\",\n \"def build_coord(norm, d, pts):\\n # Compute the origin as the mean point of the points, and this point has to be on the plane\\n \\n n = len(pts)\\n x_total = 0\\n y_total = 0\\n z_total = 0\\n \\n for i in range(n):\\n x_total += pts[i][0]\\n y_total += pts[i][1]\\n z_total += pts[i][2]\\n\\n x_o = x_total * 1.0 / n\\n y_o = y_total * 1.0 / n\\n z_o = z_total * 1.0 / n\\n p_o = [x_o, y_o, z_o]\\n \\n # Choose p be the projection of a vector in the z-axis to the plane\\n # If the plane is not perpendicular to the z-axis\\n if ((norm[2] != 1) and (norm[2] != -1)): \\n # Choose a point\\n o_z = [x_o, y_o, z_o + 1]\\n \\n [[x_p, y_p, z_p]] = proj_to_plane(norm, d, [o_z])\\n \\n dist = np.linalg.norm([x_p - x_o, y_p - y_o, z_p - z_o])\\n\\n x_c = (x_p - x_o) * 1.0 / dist \\n y_c = (y_p - y_o) * 1.0 / dist\\n z_c = (z_p - z_o) * 1.0 / dist\\n # Thus we have unit vector in x direction\\n e_y = [x_c, y_c, z_c]\\n #Compute the unit vector in y direction\\n e_x = np.cross(e_y, norm).tolist()\\n else:\\n e_x = [1, 0, 0]\\n e_y = [0, 1, 0]\\n \\n return [e_x, e_y, norm] , p_o\",\n \"def illuminator_of_elfes():\\n\\n\\t# Alpha - simplified by taking out the i by multiplying the outerproduct by 2i\\n\\talpha1i = np.matrix([[0, 0, 0, 2], [0, 0, 2, 0], [0, -2, 0, 0], [-2, 0, 0, 0]])\\n\\talpha2i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, 2], [0, 0, -2, 0]])\\n\\talpha3i = np.matrix([[0, 0, 2, 0], [0, 0, 0, -2], [-2, 0, 0, 0], [0, 2, 0, 0]])\\n\\n\\t# Betas - simplified by taking out the i by multiplication of outerprod by 2i\\n\\tbeta1i = np.matrix([[0, 0, 0, 2], [0, 0, -2, 0], [0, 2, 0, 0], [-2, 0, 0, 0]])\\n\\tbeta2i = np.matrix([[0, 0, 2, 0], [0, 0, 0, 2], [-2, 0, 0, 0], [0, -2, 0, 0]])\\n\\tbeta3i = np.matrix([[0, 2, 0, 0], [-2, 0, 0, 0], [0, 0, 0, -2], [0, 0, 2, 0]])\\n\\n\\t# print(\\\"alpha 1\\\")\\n\\t# print(alpha1i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"alpha 2\\\")\\n\\t# print(alpha2i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"alpha 3\\\")\\n\\t# print(alpha3i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 1\\\")\\n\\t# print(beta1i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 2\\\")\\n\\t# print(beta2i)\\n\\t# print(\\\"\\\")\\n\\t# print(\\\"beta 3\\\")\\n\\t# print(beta3i)\\n\\t# print(\\\"\\\")\\n\\n\\t# abperm_comb = [ np.multiply(alpha1i,-1), np.multiply(alpha2i,-1), np.multiply(alpha3i,-1), np.multiply(beta1i,-1), np.multiply(beta2i,-1), np.multiply(beta3i,-1)]\\n\\n\\tabperm_comb = [alpha1i, alpha2i, alpha3i, beta1i, beta2i, beta3i]\\n\\treturn abperm_comb\",\n \"def _computeStikeDip(self):\\n seg = self._group_index\\n groups = np.unique(seg)\\n ng = len(groups)\\n norm_vec = Vector(0, 0, 0)\\n north_vec = Vector(0, 0, 0)\\n up_vec = Vector(0, 0, 0)\\n for i in range(ng):\\n group_segments = np.where(groups[i] == seg)[0]\\n nseg = len(group_segments) - 1\\n for j in range(nseg):\\n ind = group_segments[j]\\n P0 = Point(self._toplons[ind],\\n self._toplats[ind],\\n self._topdeps[ind])\\n P1 = Point(self._toplons[ind + 1],\\n self._toplats[ind + 1],\\n self._topdeps[ind + 1])\\n P2 = Point(self._botlons[ind + 1],\\n self._botlats[ind + 1],\\n self._botdeps[ind + 1])\\n P3 = Point(self._botlons[ind],\\n self._botlats[ind],\\n self._botdeps[ind])\\n P1up = Point(self._toplons[ind + 1],\\n self._toplats[ind + 1],\\n self._topdeps[ind + 1] - 1.0)\\n P1N = Point(self._toplons[ind + 1],\\n self._toplats[ind + 1] + 0.001,\\n self._topdeps[ind + 1])\\n P3up = Point(self._botlons[ind],\\n self._botlats[ind],\\n self._botdeps[ind] - 1.0)\\n P3N = Point(self._botlons[ind],\\n self._botlats[ind] + 0.001,\\n self._botdeps[ind])\\n p0 = Vector.fromPoint(P0)\\n p1 = Vector.fromPoint(P1)\\n p2 = Vector.fromPoint(P2)\\n p3 = Vector.fromPoint(P3)\\n p1up = Vector.fromPoint(P1up)\\n p1N = Vector.fromPoint(P1N)\\n p3up = Vector.fromPoint(P3up)\\n p3N = Vector.fromPoint(P3N)\\n\\n # Sides\\n s01 = p1 - p0\\n s02 = p2 - p0\\n s03 = p3 - p0\\n s21 = p1 - p2\\n s23 = p3 - p2\\n\\n # First triangle\\n t1norm = (s02.cross(s01)).norm()\\n a = s01.mag()\\n b = s02.mag()\\n c = s21.mag()\\n s = (a + b + c) / 2\\n A1 = np.sqrt(s * (s - a) * (s - b) * (s - c)) / 1000\\n\\n # Second triangle\\n t2norm = (s03.cross(s02)).norm()\\n a = s03.mag()\\n b = s23.mag()\\n c = s02.mag()\\n s = (a + b + c) / 2\\n A2 = np.sqrt(s * (s - a) * (s - b) * (s - c)) / 1000\\n\\n # Up and North\\n p1up = (p1up - p1).norm()\\n p3up = (p3up - p3).norm()\\n p1N = (p1N - p1).norm()\\n p3N = (p3N - p3).norm()\\n\\n # Combine\\n norm_vec = norm_vec + A1 * t1norm + A2 * t2norm\\n north_vec = north_vec + A1 * p1N + A2 * p3N\\n up_vec = up_vec + A1 * p1up + A2 * p3up\\n\\n norm_vec = norm_vec.norm()\\n north_vec = north_vec.norm()\\n up_vec = up_vec.norm()\\n\\n # Do I need to flip the vector because it is pointing down (i.e.,\\n # right-hand rule is violated)?\\n flip = np.sign(up_vec.dot(norm_vec))\\n norm_vec = flip * norm_vec\\n\\n # Angle between up_vec and norm_vec is dip\\n self._dip = np.arcsin(up_vec.cross(norm_vec).mag()) * 180 / np.pi\\n\\n # Normal vector projected to horizontal plane\\n nvph = (norm_vec - up_vec.dot(norm_vec) * up_vec).norm()\\n\\n # Dip direction is angle between nvph and north; strike is orthogonal.\\n cp = nvph.cross(north_vec)\\n sign = np.sign(cp.dot(up_vec))\\n dp = nvph.dot(north_vec)\\n strike = np.arctan2(sign * cp.mag(), dp) * 180 / np.pi - 90\\n if strike < -180:\\n strike = strike + 360\\n self._strike = strike\",\n \"def L2_norm(self):\\n analyticals = self.analytical(self.x_values, self.C, self.D)\\n error = analyticals - self.numerical\\n self.L2 = np.sqrt((1/self.gp)*np.sum(error**2))\",\n \"def get_l2_distance(x1, x2, y1, y2):\\n return ((x1-y1)**2 + (x2-y2)**2)**0.5\",\n \"def kl_latent_space(network, *args):\\n\\n z, log_det_J = network(*args)\\n loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\\n return loss\",\n \"def ols_data():\\n\\n xs = [35.3, 29.7, 30.8, 58.8, 61.4, 71.3, 74.4, 76.7, 70.7, 57.5,\\n 46.4, 28.9, 28.1, 39.1, 46.8, 48.5, 59.3, 70, 70, 74.5, 72.1,\\n 58.1, 44.6, 33.4, 28.6]\\n ys = [10.98, 11.13, 12.51, 8.4, 9.27, 8.73, 6.36, 8.50,\\n 7.82, 9.14, 8.24, 12.19, 11.88, 9.57, 10.94, 9.58,\\n 10.09, 8.11, 6.83, 8.88, 7.68, 8.47, 8.86, 10.36, 11.08]\\n\\n\\n # self.Xk = 28.6\\n # self.ypred_k = 0.3091\\n solution = {'slope': -0.0798,\\n 'y_intercept': 13.623,\\n 'n': len(xs),\\n 'pred_x': 28.6,\\n 'pred_error': 0.309}\\n\\n return xs, ys, solution\",\n \"def project_L2(w, l):\\n return w * min(1, 1 / (l ** (1 / 2.0) * np.linalg.norm(w, 2)))\",\n \"def topography(x,y):\\n \\n z = -x/10\\n \\n N = len(x)\\n for i in range(N):\\n # Step\\n if 10 < x[i] < 12:\\n z[i] += 0.4 - 0.05*y[i]\\n \\n # Constriction\\n if 27 < x[i] < 29 and y[i] > 3:\\n z[i] += 2\\n \\n # Pole\\n if (x[i] - 34)**2 + (y[i] - 2)**2 < 0.4**2:\\n z[i] += 2\\n \\n return z\",\n \"def P2l_rec_norm(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 P2l_norm = np.copy(P2l)\\n P2l_norm[2] *= P2l_norm_prefac(2)\\n P2l_norm[3] *= P2l_norm_prefac(3)\\n for ell in ells[4:]:\\n # print ell, P2l[ell-1], P2l[ell-2]\\n a = np.sqrt((4 * ell**2 - 1.) / (ell**2 - 4))\\n b = cost * P2l_norm[ell - 1]\\n c = np.sqrt(((ell - 1.)**2 - 4) /\\n (4 * (ell - 1.)**2 - 1)) * P2l_norm[ell - 2]\\n # print a,b,c\\n P2l_norm[ell] = a * (b - c)\\n # print ell, P2l_norm[ell], P2l_norm_prefac(ell)\\n P2l[ell] = P2l_norm[ell] / P2l_norm_prefac(ell)\\n return P2l\",\n \"def MyKLD(X,Y): \\n mu1,mu2 = tuple(np.mean(X,axis=0))\\n sigma1,sigma2 = tuple(np.std(X,axis=0))\\n m1,m2 = tuple(np.mean(X,axis=0))\\n s1,s2 = tuple(np.std(X,axis=0))\\n rho = np.corrcoef(X,rowvar=False)[0,1]\\n r = np.corrcoef(Y,rowvar=False)[0,1]\\n \\n return (\\n ((mu1-m1)**2/s1**2 - 2*r*(mu1-m1)*(mu2-m2)/(s1*s2) + (mu2-m2)**2/s2**2) /\\n (2 * (1 - r**2)) +\\n ((sigma1**2-s1**2)/s1**2 - 2*r*(rho*sigma1*sigma2-r*s1*s2)/(s1*s2) + \\n (sigma2**2-s2**2)/s2**2) /\\n (2 * (1 - r**2)) +\\n np.log((s1**2 * s2**2 * (1-r**2)) / (sigma1**2 * sigma2**2 * (1-rho**2))) / 2\\n )\",\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 run_gradient_descent2(seed=0):\\n\\n colors = [color for color in matplotlib.colors.cnames]\\n\\n def random_point():\\n return (3 * random.random() - 1, 3 * random.random() - 1)\\n\\n def f(x):\\n \\\"\\\"\\\"has min at (1,0), saddle point at (-1,0)\\\"\\\"\\\"\\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)\\n\\n def df(x):\\n return ((1 - x[0]**2) * f(x), -2 * x[1] * f(x))\\n\\n for color in random.sample(colors, 50):\\n path = take(100, gradient_descent(df, random_point()))\\n for i, (x, y) in enumerate(path):\\n plt.plot(x, y, color=color, marker='*', markersize=25-i/4)\\n\\n plt.show()\",\n \"def beta_gen_lasso(p):\\n cardi = 0.005\\n return np.array([0]*int(p-int(cardi*p)) + [1]*int(cardi*p))\",\n \"def bcL(self, rng=None):\\n if rng is None:\\n rng = random.PRNGKey(1)\\n n = self.n\\n x = onp.sin(self.bcmesh * np.pi)\\n n_y = (np.floor((n + 1) / 2) - 1).astype(int)\\n if rng is not None:\\n coeffs = random.multivariate_normal(rng, np.zeros(16),\\n np.diag(np.ones(16)))\\n else:\\n key = random.randint(random.PRNGKey(1), (1,), 1, 1000)\\n coeffs = random.multivariate_normal(\\n random.PRNGKey(key[0]), np.zeros(16), np.diag(np.ones(16)))\\n left = coeffs[0] * x**3 + coeffs[1] * x**2 + coeffs[2] * x #+ coeffs[3]\\n right = coeffs[4] * x**3 + coeffs[5] * x**2 + coeffs[6] * x #+ coeffs[7]\\n lower = coeffs[8] * x**3 + coeffs[9] * x**2 + coeffs[10] * x #+ coeffs[11]\\n upper = coeffs[12] * x**3 + coeffs[13] * x**2 + coeffs[14] * x #+ coeffs[15]\\n shape = 2 * x.shape\\n source = onp.zeros(shape)\\n source[0, :] = upper\\n source[n_y - 1, n_y - 1:] = lower[:n - n_y + 1]\\n source[n_y - 1:, n_y - 1] = right[:n - n_y + 1]\\n source[:, 0] = left\\n source[-1, :n_y - 1] = right[n:n - n_y:-1]\\n source[:n_y - 1, -1] = lower[n:n - n_y:-1]\\n # because this makes the correct order of boundary conditions\\n return source * (n + 1)**2\",\n \"def d2(x0,y0,x1,y1):\\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)\",\n \"def coordinate_descent(X, y, lam, theta=None, maxit=10000, eta=1e-8):\\n \\n n, m = X.shape\\n \\n # initialize the coefficients\\n if theta is None: theta = np.random.randn(m, 1)\\n \\n # compute squared columns\\n v = np.diag(np.dot(X.T, X))\\n \\n # coordinate optimization\\n i = 0\\n chg = 1\\n theta_old = np.empty((m, 1))\\n Xtheta = np.dot(X, theta)\\n while i < maxit and chg > eta:\\n i += 1\\n theta_old = theta.copy()\\n for j in range(m): \\n Xtheta -= theta[j]*np.atleast_2d(X[:,j]).T\\n alpha = np.dot(X[:,j].T, y - Xtheta)\\n if abs(alpha) > lam: \\n theta[j] = np.sign(alpha) * (abs(alpha) - lam) / v[j]\\n Xtheta += theta[j]*np.atleast_2d(X[:,j]).T\\n else:\\n theta[j] = 0\\n chg = np.sum((theta - theta_old)**2)/np.sum(theta_old**2)\\n \\n return theta, i\",\n \"def p2p_xyz(start_point, end_point, top_left_cor, cellsize, dem):\\n start_cell = (int((start_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((start_point[1] - top_left_cor[1]) / cellsize[1]))\\n end_cell = (int((end_point[0] - top_left_cor[0]) / cellsize[0]),\\n int((end_point[1] - top_left_cor[1]) / cellsize[1]))\\n cells = misc.get_line(start_cell, end_cell) \\n pnts = []\\n elev = []\\n \\n dem_elv = dem[:,1]\\n dem_indx = dem[:,2:4]\\n\\n for cell in cells:\\n x = top_left_cor[0] + cell[0] * cellsize[0] + cellsize[0] / 2\\n y = top_left_cor[1] + cell[1] * cellsize[1] + cellsize[1] / 2\\n #xy_indx=[str(cell[0]),str(cell[1])]\\n z_indx=np.logical_and(np.equal(dem_indx[:,0],cell[0]),np.equal(dem_indx[:,1],cell[1]))\\n try:\\n z=dem_elv[z_indx][0]\\n except (np.sum(z_indx)>1):\\n print(\\\"Oops! That was more than one indices in dem matching the query index (in getCellValue)\\\")\\n #z_indx = [i for i,j in enumerate(dem_indx) if j == xy_indx]\\n z = float(dem_elv[z_indx])\\n pnts.append((x, y))\\n elev.append(z)\\n return pnts, elev\",\n \"def hausdorffDistance13(self,id1,id2):\\n #productive #math\\n profprint()\\n node1 = slicer.mrmlScene.GetNodeByID(id1)\\n polydata1=node1.GetPolyData()\\n node2 = slicer.mrmlScene.GetNodeByID(id2)\\n polydata2=node2.GetPolyData()\\n nb1 = polydata1.GetNumberOfPoints()\\n nb2 = polydata2.GetNumberOfPoints()\\n minimum=None\\n maximum=None\\n JJ,jj=None,None\\n II,ii=None,None\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n polydata1.GetPoint(1,pt1)\\n polydata1.GetPoint(nb1-1,pt2)\\n minVal1=min(pt1[2],pt2[2])\\n maxVal1=max(pt1[2],pt2[2])\\n pt1=[0,0,0]\\n pt2=[0,0,0]\\n pt1b,pt2b=None,None\\n polydata2.GetPoint(1,pt1)\\n polydata2.GetPoint(nb2-1,pt2)\\n minVal2 = min(pt1[2],pt2[2])\\n maxVal2 = max(pt1[2],pt2[2])\\n valueBase=max(minVal1,minVal2)\\n valueTip=min(maxVal1,maxVal2)\\n cellId=vtk.mutable(1)\\n subid=vtk.mutable(1)\\n dist=vtk.mutable(1)\\n cl2=vtk.vtkCellLocator()\\n cl2.SetDataSet(polydata2)\\n cl2.BuildLocator()\\n # Hausforff 1 -> 2\\n minima=[]\\n for i in range(int(nb1/float(100))):\\n pt=[0,0,0]\\n polydata1.GetPoint(100*i,pt)\\n closest=[0,0,0]\\n cl2.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff12 = max(minima)\\n \\n # Hausforff 2 -> 1\\n minima=[]\\n cl1=vtk.vtkCellLocator()\\n cl1.SetDataSet(polydata1)\\n cl1.BuildLocator()\\n for i in range(int(nb2/float(10))):\\n pt=[0,0,0]\\n polydata2.GetPoint(10*i,pt)\\n closest=[0,0,0]\\n cl1.FindClosestPoint(pt,closest,cellId,subid,dist)\\n if abs(closest[2]-pt[2])<=1:\\n minima.append(self.distance(pt,closest))\\n else:\\n minima.append(0)\\n hausdorff21 = max(minima)\\n return max(hausdorff12,hausdorff21)\",\n \"def lloyds_algorithm(X, k, T):\\n n, d = X.shape\\n\\n # Initialize clusters random.\\n clustering = np.random.randint(0, k, (n,))\\n centroids = np.zeros((k, d))\\n\\n # Used to stop if cost isn't improving (decreasing)\\n cost = 0\\n oldcost = 0\\n\\n # Column names\\n # print(\\\"Iterations\\\\tCost\\\")\\n for i in range(T):\\n\\n # Update centroid\\n centroids = np.zeros((k, d))\\n # YOUR CODE HERE\\n numberOfPointsInClusters = np.zeros((k,))\\n for idx, point in enumerate(clustering):\\n numberOfPointsInClusters[point] += 1\\n centroids[point] += X[idx]\\n for n in range(k):\\n if numberOfPointsInClusters[n] == 0:\\n numberOfPointsInClusters[n] = float('-inf')\\n centroids = [centroid / numberOfPointsInClusters[idx] for idx, centroid in enumerate(centroids)]\\n # END CODE\\n\\n # Update clustering\\n\\n # YOUR CODE HERE\\n for idx, point in enumerate(X):\\n clustering[idx] = np.argmin([np.linalg.norm(point - cluster) for cluster in centroids])\\n # END CODE\\n\\n # Compute and print cost\\n cost = 0\\n for j in range(n):\\n cost += np.linalg.norm(X[j] - centroids[clustering[j]]) ** 2\\n # print(i + 1, \\\"\\\\t\\\\t\\\", cost)\\n\\n # Stop if cost didn't improve more than epislon (decrease)\\n if np.isclose(cost, oldcost): break # TODO\\n oldcost = cost\\n\\n return clustering, centroids, cost\",\n \"def pointfind2(plat, plon, lat, lon, pdif=1):\\n\\n\\tdist_min = 1000000.\\n\\t\\n\\t\\n\\tfor i in range(lon.shape[0]):\\n\\t\\tfor j in range(lon.shape[1]):\\n\\t\\t\\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\\n\\t\\t\\tif dist_min > dist:\\n\\t\\t\\t\\tdist_min = dist\\n\\t\\t\\t\\ti_min = i\\n\\t\\t\\t\\tj_min = j\\n\\t\\t\\t\\tlat_min = lat[i,j]\\n\\t\\t\\t\\tlon_min = lon[i,j]\\n\\t\\n\\tprint(i_min,j_min,lat_min,lon_min)\\n\\tgg1 = i_min, j_min\\n\\t\\n\\treturn(gg1, lat_min, lon_min)\",\n \"def frame3dlin_Kg(E,A1,A2,L,Te1,Te2,R=None):\\n Kge1= np.array([\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , (A2*E)/(10*L) , 0 , -((A2+3*A1)*E)/30 , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0],\\n [0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+3*A1)*E)/30 , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , (A1*E)/(10*L) , 0 , ((A2+A1)*E)/60 , 0 , 0 , 0 , -(A1*E)/(10*L) , 0 , -((3*A2+A1)*E)/30 , 0],\\n [0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((A2+A1)*E)/60 , 0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((3*A2+A1)*E)/30]\\n ])\\n Kge2= np.array([\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , (A1*E)/(10*L)],\\n [0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , -(A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , -(A2*E)/(10*L) , 0 , ((A2+3*A1)*E)/30 , 0 , 0 , 0 , (A2*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0],\\n [0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((A2+3*A1)*E)/30 , 0 , -(A2*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A2*E)/(10*L) , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , 0 , 0 , -(A1*E)/(10*L)],\\n [0 , 0 , -((3*A2+3*A1)*E)/(5*L**2) , 0 , (A2*E)/(10*L) , 0 , 0 , 0 , ((3*A2+3*A1)*E)/(5*L**2) , 0 , (A1*E)/(10*L) , 0],\\n [0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0],\\n [0 , 0 , -(A1*E)/(10*L) , 0 , -((A2+A1)*E)/60 , 0 , 0 , 0 , (A1*E)/(10*L) , 0 , ((3*A2+A1)*E)/30 , 0],\\n [0 , (A1*E)/(10*L) , 0 , 0 , 0 , -((A2+A1)*E)/60 , 0 , -(A1*E)/(10*L) , 0 , 0 , 0 , ((3*A2+A1)*E)/30]])\\n\\n Kg = Kge1*Te1 + Kge2*Te2\\n\\n if (R is not None):\\n RR = scipy.linalg.block_diag(R,R,R,R)\\n Kg = np.transpose(RR).dot(Kg.dot(RR))\\n\\n return Kg\",\n \"def test_lu_forward_sub():\\t\\n\\t# test 1\\n\\tL = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\n\\tb = np.array([4, -8, 9, 6])\\n\\n\\ty = lu_forward_sub(L, b) \\t\\t\\n\\ty_soln = np.array([4,0,5,8])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y - y_soln) < 1.e-10\\n\\n\\t# test 2\\n\\tL2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\n\\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\\n\\n\\ty2 = lu_forward_sub(L2, b2) \\t\\t\\n\\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y2 - y_soln2) < 1.e-10\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \\n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\\n \\n for j in range(self.feature_count): # Loop over each feature\\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \\n numerator = single_word_count + self.alpha\\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def epsilon_fit_Chang(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_l1,f_l2,f_t1,f_t2,epsinf1,epsinf2):\\n # Chang PRB38 12369\\n v = 1e4/l_onde\\n \\n epsx = (epsinf1+epsinf2)/2 - (f_t1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_t2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\\n epsz = 1/(((1/2)*(1/epsinf1 + 1/epsinf2)) + (f_l1*(vl1**2 - vt1**2))/(-vl1**2 + v**2 + 1j*v*gl1) + (f_l2*(vl2**2 - vt2**2))/(-vl2**2 + v**2 + 1j*v*gl2))\\n \\n# eps1 = epsinf1*(1 - (f_t1*(vl1**2 - vt1**2))/(vt1**2 - v**2 - 1j*v*gt1))\\n# eps2 = epsinf2*(1 - (f_t2*(vl2**2 - vt2**2))/(vt2**2 - v**2 - 1j*v*gt2))\\n# epsx = (1/2)*(eps1+eps2)\\n# epsz = 1/((1/2)*(1/eps1 + 1/eps2))\\n \\n return (epsx.real + 1j*np.abs(epsx.imag)),(epsz.real + 1j*np.abs(epsz.imag))\",\n \"def laplace2d(get_A, get_rho, N=Mynum, Te=2):\\n # Reduce the row and column of Laplacian matrix by 2 \\n # Reduced row and column will be replace with embed in future\\n # n = N - 2 for embed\\n n = N\\n # Solving for the PDE(1)\\n h = 1.0/(n-1)\\n A = get_A(n) * (1/(h**2))\\n b = get_rho(n, Te)\\n U = sp.linalg.solve(A, b)\\n\\n # Reshape the u vector into nxn matrix for heat map plotting\\n T = U.reshape((n, n))\\n print T\\n \\n # Embed the surrounding of U matrix into zeros\\n Tfull = embed(T, Te)\\n\\n # Verify that dot function of A matrix and U vector\\n # return the same rho value at midpoint\\n CheckU = np.dot(A,U)\\n\\n # Filter very small value into zeros\\n for i in range(0,len(CheckU)):\\n if (abs(CheckU[i]) < 1e-12):\\n CheckU[i] = 0\\n\\n # Validate that product of A and U matrix is the same as rho vector\\n # Will give warning if it is not the same\\n # assert np.all(CheckU == b) # working only mynum = 7 and 9 \\n\\n # Print value of the products at midpoint.\\n mid = (n**2-1)/2\\n print \\\"Q1: Value of the dot product A.u1 is %5.3f at (0.5,0.5).\\\" % (CheckU[mid])\\n return Tfull\",\n \"def block_levinson(y, L):\\n d = L.shape[1] # Block dimension\\n N = int(L.shape[0]/d) # Number of blocks\\n\\n # This gets the bottom block row B from the left block column L\\n B = np.reshape(L, [d, N, d], order='F')\\n B = B.swapaxes(1, 2)\\n B = B[..., ::-1]\\n B = np.reshape(B, [d, N*d], order='F')\\n\\n f = np.linalg.inv(L[:d, :]) # \\\"Forward\\\" vector\\n b = f # \\\"Backward\\\" vector\\n x = np.dot(f, y[:d]) # Solution vector\\n\\n Ai = np.eye(2*d)\\n G = np.zeros((d*N, 2*d))\\n for n in range(2, N+1):\\n ef = np.dot(B[:, (N-n)*d:N*d], np.vstack((f, np.zeros((d, d)))))\\n eb = np.dot(L[:n*d, :].T, np.vstack((np.zeros((d, d)), b)))\\n ex = np.dot(B[:, (N-n)*d:N*d], np.vstack((x, np.zeros((d, 1)))))\\n Ai[:d, d:] = eb\\n Ai[d:, :d] = ef\\n A = np.linalg.inv(Ai)\\n l = d*(n-1)\\n G[:l, :d] = f\\n G[d:l+d, d:] = b\\n fn = np.dot(G[:l+d, :], A[:, :d])\\n bn = np.dot(G[:l+d, :], A[:, d:])\\n f = fn\\n b = bn\\n x = np.vstack((x, np.zeros((d, 1)))) + np.dot(b, y[(n-1)*d:n*d]-ex)\\n\\n W = x\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def calcLatLon(northing, easting):\\n from math import asin, atan2, cos, log, pow, sin, sqrt\\n\\n # CONSUS Albers variables (EPSG: 5070)\\n RE_NAD83 = 6378137.0\\n E_NAD83 = 0.0818187034 # Eccentricity\\n D2R = 0.01745329251 # Pi/180\\n standardParallel1 = 43.\\n standardParallel2 = 47.\\n centralMeridian = -114.\\n originLat = 30\\n originLon = 0\\n\\n m1 = cos(standardParallel1 * D2R) / \\\\\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel1 * D2R)), 2.0))\\n m2 = cos(standardParallel2 * D2R) / \\\\\\n sqrt(1.0 - pow((E_NAD83 * sin(standardParallel2 * D2R)), 2.0))\\n\\n def calcPhi(i):\\n sinPhi = sin(i * D2R)\\n return (1.0 - pow(E_NAD83, 2.0)) * \\\\\\n ((sinPhi/(1.0 - pow((E_NAD83 * sinPhi), 2.0))) -\\n 1.0/(2.0 * E_NAD83) *\\n log((1.0 - E_NAD83 * sinPhi)/(1.0 + E_NAD83 * sinPhi)))\\n\\n q0 = calcPhi(originLat)\\n q1 = calcPhi(standardParallel1)\\n q2 = calcPhi(standardParallel2)\\n nc = (pow(m1, 2.0) - pow(m2, 2.0)) / (q2 - q1)\\n C = pow(m1, 2.0) + nc * q1\\n rho0 = RE_NAD83 * sqrt(C - nc * q0) / nc\\n rho = sqrt(pow(easting, 2.0) + pow((rho0 - northing), 2.0))\\n q = (C - pow((rho * nc / RE_NAD83), 2.0)) / nc\\n beta = asin(q / (1.0 - log((1.0 - E_NAD83) / (1.0 + E_NAD83)) *\\n (1.0 - pow(E_NAD83, 2.0))/(2.0 * E_NAD83)))\\n a = 1.0 / 3.0 * pow(E_NAD83, 2.0) + 31.0 / 180.0 * \\\\\\n pow(E_NAD83, 4.0) + 517.0 / 5040.0 * pow(E_NAD83, 6.0)\\n b = 23.0/360.0 * pow(E_NAD83, 4.0) + 251.0 / 3780.0 * pow(E_NAD83, 6.0)\\n c = 761.0/45360.0 * pow(E_NAD83, 6.0)\\n theta = atan2(easting, (rho0 - northing))\\n\\n lat = (beta + a * sin(2.0 * beta) + b * sin(4.0 * beta) +\\n c * sin(6.0 * beta))/D2R\\n lon = centralMeridian + (theta / D2R) / nc\\n coords = [lat, lon]\\n\\n return coords\",\n \"def ftlan_E1c(hop, v0, T, m=50, Min_b=10e-10, Min_m=5, kB=1, norm = np.linalg.norm):\\n# def Tri_diag(a1, b1):\\n# mat = np.diag(b1, -1) + np.diag(a1, 0) + np.diag(b1, 1)\\n# e, w = np.linalg.eigh(mat)\\n# return e, w\\n\\n beta = 1./(T * kB)\\n E = 0.\\n a, b = [], []\\n v0 = v0/norm(v0)\\n Hv = hop(v0)\\n a.append(v0.dot(Hv))\\n v1 = Hv - a[0] * v0\\n b.append(norm(v1))\\n if b[0] < Min_b:\\n return 0\\n\\n v1 = v1/b[0]\\n Hv = hop(v1)\\n a.append(v1.dot(Hv))\\n\\n for i in range(1, m - 1):\\n v2 = Hv - b[i - 1] * v0 - a[i] * v1\\n b.append(norm(v2))\\n if abs(b[i]) < Min_b:\\n b.pop()\\n break\\n\\n v2 = v2/b[i]\\n Hv = hop(v2)\\n a.append(v2.dot(Hv))\\n v0 = v1.copy()\\n v1 = v2.copy()\\n \\n a = np.asarray(a)\\n b = np.asarray(b)\\n\\n eps, phi = Tri_diag(a, b)\\n l = len(eps)\\n# Eo = eps[0]\\n# eps = eps-Eo\\n exp_eps = np.exp(-beta * eps)\\n E = np.sum(exp_eps * eps * phi[0, :]**2.)\\n Z = np.sum(exp_eps * phi[0, :]**2.)\\n# for i in range(len(eps)):\\n# E += exp_eps[i] * eps[i] * phi[0, i]**2\\n\\n# E = E + Eo\\n# de = eps[:, np.newaxis] - eps\\n# for i in range(l):\\n# E += eps[i] * phi[0, i]**2./np.sum(np.exp(-beta*de[:l, i])*(phi[0, :l]**2.))\\n return E, Z\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5958752","0.5712532","0.56944275","0.56809044","0.5679663","0.5633035","0.5623024","0.5588956","0.55861765","0.55407983","0.5530264","0.55237794","0.552077","0.55181515","0.5517798","0.5506699","0.55033195","0.55033195","0.5500844","0.5489448","0.54821604","0.54716825","0.54696286","0.546767","0.5436634","0.5434536","0.54144037","0.54041255","0.54033786","0.5391802","0.5391151","0.5389904","0.53847086","0.53805435","0.53785145","0.53645927","0.536103","0.5347618","0.5346758","0.5345402","0.5340687","0.5339514","0.533194","0.5329375","0.5298663","0.52948225","0.52920586","0.52865577","0.52863634","0.5281159","0.5268767","0.5268149","0.5267525","0.5266408","0.526487","0.52545357","0.5251215","0.52448034","0.5239049","0.5238238","0.52255416","0.52227217","0.5219564","0.5217098","0.5216373","0.52147907","0.5214451","0.52129537","0.5212178","0.5210076","0.52072823","0.52012175","0.51920563","0.51877207","0.51853883","0.518083","0.51792467","0.51753086","0.51741403","0.517166","0.51709485","0.5166582","0.5165141","0.51496595","0.51454836","0.5131165","0.51258385","0.512445","0.5123007","0.5120196","0.5119984","0.5116753","0.51106846","0.51095605","0.5108389","0.5103246","0.51018304","0.5100636","0.50994897","0.50993836","0.50947237"],"string":"[\n \"0.5958752\",\n \"0.5712532\",\n \"0.56944275\",\n \"0.56809044\",\n \"0.5679663\",\n \"0.5633035\",\n \"0.5623024\",\n \"0.5588956\",\n \"0.55861765\",\n \"0.55407983\",\n \"0.5530264\",\n \"0.55237794\",\n \"0.552077\",\n \"0.55181515\",\n \"0.5517798\",\n \"0.5506699\",\n \"0.55033195\",\n \"0.55033195\",\n \"0.5500844\",\n \"0.5489448\",\n \"0.54821604\",\n \"0.54716825\",\n \"0.54696286\",\n \"0.546767\",\n \"0.5436634\",\n \"0.5434536\",\n \"0.54144037\",\n \"0.54041255\",\n \"0.54033786\",\n \"0.5391802\",\n \"0.5391151\",\n \"0.5389904\",\n \"0.53847086\",\n \"0.53805435\",\n \"0.53785145\",\n \"0.53645927\",\n \"0.536103\",\n \"0.5347618\",\n \"0.5346758\",\n \"0.5345402\",\n \"0.5340687\",\n \"0.5339514\",\n \"0.533194\",\n \"0.5329375\",\n \"0.5298663\",\n \"0.52948225\",\n \"0.52920586\",\n \"0.52865577\",\n \"0.52863634\",\n \"0.5281159\",\n \"0.5268767\",\n \"0.5268149\",\n \"0.5267525\",\n \"0.5266408\",\n \"0.526487\",\n \"0.52545357\",\n \"0.5251215\",\n \"0.52448034\",\n \"0.5239049\",\n \"0.5238238\",\n \"0.52255416\",\n \"0.52227217\",\n \"0.5219564\",\n \"0.5217098\",\n \"0.5216373\",\n \"0.52147907\",\n \"0.5214451\",\n \"0.52129537\",\n \"0.5212178\",\n \"0.5210076\",\n \"0.52072823\",\n \"0.52012175\",\n \"0.51920563\",\n \"0.51877207\",\n \"0.51853883\",\n \"0.518083\",\n \"0.51792467\",\n \"0.51753086\",\n \"0.51741403\",\n \"0.517166\",\n \"0.51709485\",\n \"0.5166582\",\n \"0.5165141\",\n \"0.51496595\",\n \"0.51454836\",\n \"0.5131165\",\n \"0.51258385\",\n \"0.512445\",\n \"0.5123007\",\n \"0.5120196\",\n \"0.5119984\",\n \"0.5116753\",\n \"0.51106846\",\n \"0.51095605\",\n \"0.5108389\",\n \"0.5103246\",\n \"0.51018304\",\n \"0.5100636\",\n \"0.50994897\",\n \"0.50993836\",\n \"0.50947237\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24396,"cells":{"query":{"kind":"string","value":"MajorizationMinimization algorithm for l2penalized UOT"},"document":{"kind":"string","value":"def ot_ul2_solve_mu(C, a, b, reg, nitermax=100000, tol=1e-14, P0=None, verbose=False):\n\n if P0 is None:\n P = a[:, None] * b[None, :]\n else:\n P = P0\n abt = np.maximum(a[:, None] + b[None, :] - C / (2 * reg), 0)\n for i in range(nitermax):\n Pold = P.copy()\n P = P * abt / (P.sum(0, keepdims=True) + P.sum(1, keepdims=True) + 1e-16)\n pmax = P.max()\n P = P * (P > pmax * 1e-16)\n if verbose:\n print(np.linalg.norm(P - Pold))\n if np.linalg.norm(P - Pold) < tol:\n break\n return P"},"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 l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # z >= 0 \n \n c = matrix(n*[0.0] + m*[1.0])\n h = matrix([q, -q])\n\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \n if trans == 'N':\n # y := alpha * [P, -I; -P, -I] * x + beta*y\n u = P*x[:n]\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\n\n else:\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\n\n\n def Fkkt(W): \n\n # Returns a function f(x, y, z) that solves\n #\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\n #\n # On entry bx, bz are stored in x, z.\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\n # returned instead of z). \n\n d1, d2 = W['d'][:m], W['d'][m:]\n D = 4*(d1**2 + d2**2)**-1\n A = P.T * spdiag(D) * P\n lapack.potrf(A)\n\n def f(x, y, z):\n\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \n + mul( .5*D, z[:m]-z[m:] ) )\n lapack.potrs(A, x)\n\n u = P*x[:n]\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\n\n z[:m] = div(u-x[n:]-z[:m], d1)\n z[m:] = div(-u-x[n:]-z[m:], d2)\n\n return f\n\n\n # Initial primal and dual points from least-squares solution.\n\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\n uls = +q\n lapack.gels(+P, uls)\n rls = P*uls[:n] - q \n\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \n s0 = +h\n Fi(x0, s0, alpha=-1, beta=1) \n\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \n # if rls is nonzero and w = 0 otherwise.\n if max(abs(rls)) > 1e-10: \n w = .9/max(abs(rls)) * rls\n else: \n w = matrix(0.0, (m,1))\n z0 = matrix([.5*(1+w), .5*(1-w)])\n\n dims = {'l': 2*m, 'q': [], 's': []}\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\n return sol['x'][:n]","def rwgraph_analyze2(input=(None)):\r\n\r\n\r\n #set up graph and degree distribution arrays\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n Nt=100\r\n M=20000\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n\r\n #set inital conditions and D\r\n y0=np.zeros(n,dtype=int)\r\n y0[j]=200\r\n D=1\r\n #define time for odi Int\r\n t=np.arange(Nt+1,dtype=int)\r\n #set up operators\r\n A = nx.adjacency_matrix(G)\r\n Q = A.toarray().sum(axis=1)\r\n L=np.diag(Q)-A.toarray()\r\n Q_inv=1/Q\r\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\r\n Ls_tran=np.transpose(Ls)\r\n\r\n #convert to sparse operators and include diffusion\r\n L_spar = scipy.sparse.csr_matrix(-D*L)\r\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\r\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\r\n A=nx.adjacency_matrix(G)\r\n L=-D*(scipy.sparse.diags(degree_arr)-A)\r\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\r\n\r\n #define operators\r\n def Lap(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\r\n def Lap_Ls(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\r\n def Lap_Ls_tran(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\r\n\r\n #solutions of different operators\r\n solL=scipy.integrate.odeint(Lap,y0,t)\r\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\r\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\r\n\r\n\r\n #finds eigen values and vectors and puts them into order\r\n def eigen(L):\r\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\r\n idx = eigen_values.argsort()[::-1]\r\n eigen_values = eigen_values[idx]\r\n eigen_vectors = eigen_vectors[:,idx]\r\n return eigen_values,eigen_vectors\r\n\r\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\r\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\r\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\r\n eigen_values_L,eigen_vectors_L=eigen(L)\r\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\r\n\r\n ### could have eigs here as didn't end up using all eigenvalues ####\r\n #eigen values graph\r\n n0=len(eigen_values_L)\r\n eig_nums=np.arange(n0)\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\"x\" ,label='L , D=0.36')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\"|\",label='LS , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\"+\" ,label='L , D=1')\r\n plt.legend(loc=\"lower left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.xlabel('eigen value number')\r\n plt.ylabel('eigenvalue')\r\n plt.title(\"Eigenvlaues of Laplacian Matrixs\")\r\n plt.show()\r\n\r\n print(\"4 biggest eigenvalues for each operater\")\r\n print('L=',eigen_values_L[0:4])\r\n print('Ls=',eigen_values_LS[0:4])\r\n print('Ls_tran=',eigen_values_LS_tran[0:4])\r\n #prints 4 biggest eigen values\r\n #counts node distrubtion by creating dictionary\r\n def result_count(sol,Nt,G):\r\n \"\"\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\"\"\"\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq\r\n\r\n #frequency count of solutions\r\n dict_freq=result_count(solL,Nt,G)\r\n dict_freq2=result_count(solLs,Nt,G)\r\n dict_freq3=result_count(solLs_tran,Nt,G)\r\n\r\n #random walk data\r\n X=rwgraph(G,j,20000,100)\r\n Listnodes7=[]\r\n for i in range(20000):\r\n Listnodes7.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,200,100)\r\n Listnodes8=[]\r\n for i in range(200):\r\n Listnodes8.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,50000,5000)\r\n Listnodes9=[]\r\n for i in range(50000):\r\n Listnodes9.append(G.degree(X[i,5000]))\r\n listfreq7=CountFrequency(Listnodes7)\r\n listfreq8=CountFrequency(Listnodes8)\r\n listfreq9=CountFrequency(Listnodes9)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n z2=[]\r\n z3=[]\r\n z1=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n z_deg1=[]\r\n for i in listfreq7:\r\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq8:\r\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n for i in listfreq8:\r\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\r\n z_deg1.append(i)\r\n #operator solutions compared to node degree frequency\r\n z4,z5,z6=[],[],[]\r\n z_deg4,z_deg5,z_deg6=[],[],[]\r\n for i in dict_freq:\r\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\r\n z_deg4.append(i)\r\n for i in dict_freq2:\r\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\r\n z_deg5.append(i)\r\n for i in dict_freq3:\r\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\r\n z_deg6.append(i)\r\n\r\n plt.figure(figsize=(15, 10))\r\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\r\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\r\n plt.scatter(z_deg4, z4,label='L, Nt=100')\r\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\r\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\r\n plt.ylim((-0.005,0.020))\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n\r\n #code to produce final graph\r\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\r\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\r\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\r\n tarray = np.linspace(0,5,Nt+1)\r\n plt.figure(figsize=(12, 6))\r\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\r\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\r\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\r\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\r\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\r\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\r\n plt.xlabel('time')\r\n plt.ylabel('representive frequency')\r\n plt.legend()\r\n plt.title(\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\")\r\n plt.show()\r\n return None #modify as needed\r","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 add_objective(self): \n \n if \"CSS\" in self.algorithm:\n \n if self.num_hidden == 0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n else:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.add_css_approximation(data_term)\n \n if \"CD\" in self.algorithm and self.num_hidden ==0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n normalizer_term = self.compute_energy(self.x_gibbs, \n self.batch_size)\n \n normalizer_term = -T.mean(normalizer_term)\n \n if \"CD\" in self.algorithm and self.num_hidden > 0:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\n \n normalizer_term = -T.mean(normalizer_term)\n \n # cost is negative log likelihood \n self.cost = T.mean(data_term) + normalizer_term","def prob2():\n # Define the function to be optimized and the initial condition.\n def multimin(x):\n r = np.sqrt((x[0]+1)**2 + x[1]**2)\n return r**2 *(1+ np.sin(4*r)**2)\n x0 = np.array([-2, -2])\n \n info = {}\n info[.5] = opt.basinhopping(multimin, x0, stepsize=0.5,\n minimizer_kwargs={'method':'nelder-mead'})\n info[.2] = opt.basinhopping(multimin, x0, stepsize=0.2,\n minimizer_kwargs={'method':'nelder-mead'})\n\n # Print the results.\n for step in info:\n print(\"Stepsize:\\t{}\\nMinimum:\\t{}\\n\".format(step, info[step].fun))\n\n # Answer the problem question and return the minimum value.\n print(\"0.2 is too small a stepsize to escape the basin of a local min.\")\n return info[.2].fun","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 fit_chowliu(self, data, penalty=0, weights=None):\n # TODO: add score f'n parameter, default to empirical MI? or too complicated?\n def MI2(data, weights):\n \"\"\"Estimate mutual information between all pairs of *binary* {0,1} variables\"\"\"\n pi = np.average(data.astype(float),axis=1,weights=weights)[np.newaxis,:]\n pij = np.cov(data,ddof=0,aweights=weights) + (pi.T.dot(pi));\n p = np.stack( (pij, pi-pij, pi.T-pij, 1+pij-pi-pi.T), axis=2)\n p2 = pi.T.dot(pi)\n q = np.stack( (p2,pi-p2,pi.T-p2,1+p2-pi-pi.T), axis=2)\n MI = (p*(np.log(p+1e-10)-np.log(q+1e-10))).sum(axis=2)\n return MI,pij,pi[0]\n \n n,m = data.shape\n #MI, pij,pi = MI2(to01(data), weights)\n MI, pij,pi = MI2(data, weights) # data should be 0/1, not -1/+1\n from scipy.sparse.csgraph import minimum_spanning_tree as mst\n tree = mst(penalty-MI).tocoo();\n factors = [Factor([Var(i,2)], [1-pi[i],pi[i]]) for i in range(n)]\n for i,j,w in zip(tree.row,tree.col,tree.data):\n if w>0: continue\n (i,j)=(int(i),int(j)) if i<j else (int(j),int(i))\n tij = [1+pij[i,j]-pi[i]-pi[j], pi[i]-pij[i,j], pi[j]-pij[i,j], pij[i,j]]\n fij = Factor([Var(i,2),Var(j,2)],tij);\n fij = fij / fij.sum([i]) / fij.sum([j])\n factors.append(fij)\n self.__init__(factors)","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 method2(self):\n cres=np.zeros(self.NL,dtype=float) # List of invariants\n # The U matrices from Fukui's method; storage...\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n for il in range(self.NL):\n # ... and calculation of U matrices for each layer\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.LDM[il,ix ,iy ,:,:]\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\n \n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\n \n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\n \n return cres","def u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=50): \n # PREMULTIPLIED LHS IS AN EXTRA ARGUMENT! Set it to None and add solver! \n \"\"\"In the following +[[]] and [:-1] are added to keep thing 1dim array of objects and still multiply it elemtwisely\"\"\" \n# #B.append([]) #THIS IS WRONG, CHANGES THE LIST \n# B_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(B+[[]])[:-1], axis = 0) \n# A_ls = np.concatenate([(1/np.sqrt(2*eta0))*A, B_concat], axis = 0) \n# #print(np.array(B).shape) \n# #print(w[0].shape) \n# #print(w, eta) \n# #w.append([]) THIS IS WRONG, CHANGES THE LIST \n# w_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(w+[[]])[:-1], axis = 0) #[:-1] Added as a hack to keep it one-dim array of objects \n# eta_w = np.expand_dims(1/np.sqrt(2*eta),1)*np.array(w) \n# print(eta_w.shape) \n# b_ls = np.concatenate([(1/np.sqrt(2*eta_0))*w_0, eta_w.flatten()], axis = 0) \n #Use correct broadcasting?\n w_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(w+[[]])[:-1], axis = 0) #[:-1] Added as a hack to keep it one-dim array of objects \n b_ls = np.concatenate([(1/np.sqrt(2*eta_0))*w_0, w_concat, (1/np.sqrt(2*eta_lin))*w_lin], axis = 0) \n# print(np.sum(eta_w.flatten() != w_concat)) \n# premultiplied_time_start = time.time() \n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray() \n# premultiplied_time_end = time.time() \n# print('premultiplying took {}'.format(premultiplied_time_end - premultiplied_time_start)) \n# premultiplied_rhs = eta_T_H_stacked.T.dot(b_ls) \n# u_next = nnls_predotted(premultiplied_lhs, premultiplied_rhs, tol=1e-5) \n# print(eta_T_H_stacked.shape, b_ls.shape) \n# A_ls_t_b = eta_T_H_stacked.T.dot(b_ls) \n# w =scipy.sparse.linalg.spsolve_triangular(RT, A_ls_t_b, lower = True) \n# x = scipy.sparse.linalg.spsolve_triangular(R, w, lower = False) \n# u_next = x \n u_next = scipy.optimize.lsq_linear(eta_T_H_L_stacked, b_ls, bounds = (0, np.inf), tol=1e-3, lsmr_tol=1e-3, max_iter=nnls_max_iter, verbose=1).x \n# u = scipy.optimize.lsq_linear(premultiplied_lhs, premultiplied_rhs, bounds = (0, np.inf), tol=1e-5).x \n return u_next","def fit_chowliu(data, penalty=0, weights=None):\n # TODO: add score f'n parameter, default to empirical MI? or too complicated?\n def MI2(data, weights, eps=1e-10):\n \"\"\"Estimate mutual information between all pairs of *binary* {0,1} variables\"\"\"\n pi = np.average(data.astype(float),axis=1,weights=weights)[np.newaxis,:]\n pij = np.cov(data,ddof=0,aweights=weights) + (pi.T.dot(pi));\n p = np.stack( (pij, pi-pij, pi.T-pij, 1+pij-pi-pi.T), axis=2)\n p2 = pi.T.dot(pi)\n q = np.stack( (p2,pi-p2,pi.T-p2,1+p2-pi-pi.T), axis=2)\n MI = (p*(np.log(p+eps)-np.log(q+eps))).sum(axis=2)\n return MI,pij,pi[0]\n \n n,m = data.shape\n MI, pij,pi = MI2(data, weights) # data should be 0/1, not -1/+1\n from scipy.sparse.csgraph import minimum_spanning_tree as mst\n tree = mst(penalty-MI).tocoo();\n factors = [Factor([Var(i,2)], [1-pi[i],pi[i]]) for i in range(n)]\n for i,j,w in zip(tree.row,tree.col,tree.data):\n if w>0: continue\n (i,j)=(int(i),int(j)) if i<j else (int(j),int(i))\n tij = [1+pij[i,j]-pi[i]-pi[j], pi[i]-pij[i,j], pi[j]-pij[i,j], pij[i,j]]\n fij = Factor([Var(i,2),Var(j,2)],tij);\n fij = fij / fij.sum([i]) / fij.sum([j])\n factors.append(fij)\n return Ising(factors)","def limited_information_lower_bound_IL(P0: np.ndarray, P1: np.ndarray,\r\n pi0: np.ndarray, pi1: np.ndarray):\r\n P0, P1 = sanity_check_probabilities(P0, P1)\r\n na = P0.shape[0]\r\n ns = P1.shape[1]\r\n P1_p1 = build_markov_transition_density(P1, pi1)\r\n P0_p0 = build_markov_transition_density(P0, pi0)\r\n _, mu1 = compute_stationary_distribution(P1, pi1)\r\n\r\n d = sp.special.kl_div(P1_p1, P0_p0) + sp.special.kl_div(\r\n 1 - P1_p1, 1 - P0_p0)\r\n\r\n return np.dot(mu1, np.max(d, axis=0))","def minimum_spanning_arborescence(sol):","def minimize(self):\n pass","def Example_2():\r\n print \"\\n** Example_2: Finding the minimum of the Rosenbrock function with 2 variables under constraints **\"\r\n\r\n Ex = optim_wrapper()\r\n X0 = np.zeros(2)\r\n lim = [(-2.0, 2.0)]*2\r\n Ex.set_X0(X0)\r\n Ex.set_lim(lim)\r\n Ex.set_penalties_func(pen)\r\n Ex.set_norm_count(200)\r\n Ex.set_nb_best(100)\r\n Ex.set_obj_func(obj)\r\n Ex.set_wrapper()\r\n Ex.launch_multi_opti()\r\n print Ex\r\n\r\n X_solution = [1.0, 1.0]\r\n res_string = \"Results of the optimisation: {:03.4f}, expected results: {:03.4f}\".format(obj(Ex.get_res()), obj(X_solution))\r\n print res_string\r\n print \"*\" * len(res_string)","def eg3(N_train=1000, N_test=500, depend_ratio_train=0.8, depend_ratio_test=0.2, feature_num=10, stable_ratio=0.4):\n\n def eg3_kernel(n, p, stable_ratio=0.4, depend_ratio=0.8):\n p_stable = int(p * stable_ratio)\n p_noise = p - p_stable\n stable_feature = np.random.randn(n, p_stable)\n noise_feature_dependent = np.zeros([n, p_noise])\n noise_feature_independent = np.random.randn(n, p_noise)\n for i in range(p_noise):\n noise_feature_dependent[:, i] = stable_feature[:, i % p_stable] + stable_feature[:,\n (i + 1) % p_stable] + 2 * np.random.randn(\n n) # still need noise\n noise_depend_label = np.random.uniform(0, 1, n).reshape(-1, 1)\n noise_depend_label = np.concatenate([noise_depend_label] * p_noise, axis=1)\n noise_feature = np.where(noise_depend_label < depend_ratio, noise_feature_dependent, noise_feature_independent)\n\n b = np.zeros([p_stable, 1])\n linear_len = int(p_stable / 2)\n\n for i in range(linear_len): # linear part\n b[i, 0] = (-1) ** i * (i % 3 + 1) * p / 3\n for i in range(linear_len, b.shape[0]): # nonlinear part\n b[i, 0] = p / 2\n\n linear_part = np.matmul(stable_feature[:, :linear_len], b[:linear_len, 0])\n nolinear_part = np.zeros([n, 1])\n for i in range(linear_len, b.shape[0]):\n temp = stable_feature[:, i % p_stable] * stable_feature[:, (i + 1) % p_stable] * b[i, 0]\n temp = temp.reshape(-1, 1)\n nolinear_part += temp\n\n Y = linear_part.reshape(-1, 1) + nolinear_part + np.random.randn(n, 1)\n\n data = {}\n data['stable'] = stable_feature\n data['noise'] = noise_feature\n data['Y'] = Y\n data['params'] = b\n data['kernel'] = 'eg3'\n return data\n\n data_train = eg3_kernel(n=N_train, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_train)\n data_test = eg3_kernel(n=N_test, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_test)\n return data_train, data_test","def __solve_alternative_linear_problem(self, user):\n result = [0] * self.layout_slots\n de_rand_approach = \"greedy\"\n bins_per_category = []\n bins_cardinality = []\n for _ in range(len(self.categories)):\n bins_per_category.append([])\n bins_cardinality.append([])\n\n for cat in range(len(self.categories)):\n for _ in range(len(self.news_row_pivots) + 1):\n bins_per_category[cat].append([])\n bins_cardinality[cat].append([])\n for _ in range(len(self.news_column_pivots) + 1):\n bins_per_category[cat][-1].append([])\n bins_cardinality[cat][-1].append(0)\n\n for news in self.news_pool:\n category_index = self.categories.index(news.news_category)\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\n bins_per_category[category_index][x][y].append(news)\n bins_cardinality[category_index][x][y] += 1\n\n index = 0\n bin_samples = []\n for cat in range(len(self.categories)):\n for x in range(len(self.news_row_pivots) + 1):\n for y in range(len(self.news_column_pivots) + 1):\n if (y == 0) and (x != 0):\n continue\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\n index += 1\n try:\n selected_news = np.random.choice(bins_per_category[cat][x][y])\n self.sample_quality(selected_news, user, interest_decay=True)\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\n except ValueError:\n bin_samples += [0] * self.layout_slots\n\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\n\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\n slots_assegnation_probabilities = []\n slot_counter = 0\n tmp_slot_probabilities = []\n while slot_counter < self.layout_slots:\n i = slot_counter\n while i < len(linear_problem.x):\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\n i += self.layout_slots\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\n tmp_slot_probabilities.clear()\n slot_counter += 1\n\n slot_promenances = self.real_slot_promenances.copy()\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\n slots_nr = [s for s in range(0, self.layout_slots)]\n for i in range(self.layout_slots):\n if de_rand_approach == \"ordered\":\n k = i\n elif (de_rand_approach == \"greedy\") or (de_rand_approach == \"greedy_max\"):\n k = np.argmax(slot_promenances)\n slot_promenances[k] = 0\n elif de_rand_approach == \"randomized\":\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\n slot_promenances[k] = 0\n else:\n raise RuntimeError(\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \"\n \"'randomized' or 'greedy_max'.\")\n\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\n if de_rand_approach == \"greedy_max\":\n assigning_bin_index = np.argmax(target_slot_probabilities)\n cat_index = int(assigning_bin_index / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin_index)][0]\n y = self.bins_for_position[int(assigning_bin_index)][1]\n\n else:\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\n cat_index = int(assigning_bin / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin)][0]\n y = self.bins_for_position[int(assigning_bin)][1]\n\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\n\n return result","def potentialSolver5(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","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 minimize(self):\n raise NotImplementedError","def _checkedMinimizer(self, confs):\n from MMTK.Minimization import SteepestDescentMinimizer # @UnresolvedImport\n minimizer = SteepestDescentMinimizer(self.top.universe)\n\n original_stderr = sys.stderr\n sys.stderr = NullDevice() # Suppresses warnings for minimization\n\n minimized_confs = []\n minimized_energies = []\n self.log.recordStart('minimization')\n for conf in confs:\n self.top.universe.setConfiguration(\n Configuration(self.top.universe, conf))\n x_o = np.copy(self.top.universe.configuration().array)\n e_o = self.top.universe.energy()\n for rep in range(50):\n minimizer(steps=25)\n x_n = np.copy(self.top.universe.configuration().array)\n e_n = self.top.universe.energy()\n diff = abs(e_o - e_n)\n if np.isnan(e_n) or diff < 0.05 or diff > 1000.:\n self.top.universe.setConfiguration(\n Configuration(self.top.universe, x_o))\n break\n else:\n x_o = x_n\n e_o = e_n\n if not np.isnan(e_o):\n minimized_confs.append(x_o)\n minimized_energies.append(e_o)\n\n sys.stderr = original_stderr # Restores error reporting\n\n confs = minimized_confs\n energies = minimized_energies\n self.log.tee(\" minimized %d configurations in \"%len(confs) + \\\n HMStime(self.log.timeSince('minimization')) + \\\n \"\\n the first %d energies are:\\n \"%min(len(confs),10) + \\\n ', '.join(['%.2f'%e for e in energies[:10]]))\n return confs, energies","def _l1m_objective(a,X,*args):\n \n return(np.sum(np.apply_along_axis(_euclidnorm,1,_diffmat_objective(a,X))))","def annealing_objective(x: npt.NDArray[np.float64], *args: Any) -> float:\n blocks = [int(ind) for ind in x]\n\n approx_threshold = args[0]\n upper_limit = args[1]\n psol_configs = args[2]\n dists = args[3]\n utrys = args[4]\n n_cxs = args[5]\n p = args[6]\n w = args[7]\n\n if blocks in psol_configs:\n return 1.2\n\n approx_dist = sum(dists[i][b] for i, b in enumerate(blocks))\n\n if approx_dist > approx_threshold:\n return 1.1\n\n n_cx = w * (sum(n_cxs[i][b] for i, b in enumerate(blocks)) / upper_limit)\n\n if len(psol_configs) == 0:\n return n_cx\n\n distances = [0] * len(psol_configs)\n\n for index, config in enumerate(psol_configs):\n distances[index] = sum(\n utrys[i][config[i]].get_distance_from(utrys[i][b])\n < max(dists[i][config[i]], dists[i][b])\n for i, b in enumerate(blocks)\n ) / len(blocks)\n\n b_dv = (1 - w) * np.percentile(distances, p)\n\n return n_cx + b_dv","def find_stage2_threshold(model_path, u_mode):\n u_modes = ['sub_u', 'unlabeled']\n\n assert u_mode in u_modes\n\n if u_mode == 'sub_u':\n negative = np.load(\"./processed_data/train/sub_u_negative.npy\")\n else:\n negative = np.load(\"./processed_data/train/unlabeled_negative.npy\")\n\n positive = np.load(\"./processed_data/train/raw/train_p.npy\")\n\n\n # begin with sub-u classifier test\n classifier = joblib.load(model_path)\n u_bst_th = 0.0\n u_th = 0.0\n u_index = 0.0\n u_tp = 0.0\n u_fp = 0.0\n while u_th < 1:\n p_result = np.array(classifier.predict_proba(positive[:, :-1])[:, 1])\n sub_u_result = np.array(classifier.predict_proba(negative[:, :-1])[:, 1])\n tp_rate = np.where(p_result >= u_th, 1, 0).sum() / p_result.shape[0]\n fp_rate = np.where(sub_u_result >= u_th, 1, 0).sum() / sub_u_result.shape[0]\n index = math.sqrt(tp_rate * (1 - fp_rate))\n if index >= u_index:\n u_index = index\n u_tp = tp_rate\n u_fp = fp_rate\n u_bst_th = u_th\n print(\"threshold: \" + str(u_th) + \" TP: \"\n + str(tp_rate) + \" FP: \" + str(fp_rate) + \" GMean: \" + str(index) + \"\\n\\n\")\n u_th += _threshold_2_step\n\n\n\n print(model_path + \"\\n \" +\n \"threshold: \" + str(u_bst_th) + \" TP: \" + str(u_tp) + \" FP: \" + str(u_fp) + \" GMean: \" + str(u_index))","def smooth_input(xs, ys, L):\n n = len(xs)\n\n # obj = [1 for i in range(n)]\n # for i in range(2 * n):\n # obj.append(0)\n\n # Create the model\n model = LpProblem(name=\"small-problem\", sense=LpMinimize)\n ws = [LpVariable(name=\"w_{}\".format(i), lowBound=0, upBound=1) for i in range(n)]\n ls = [LpVariable(name=\"L_{}\".format(i), lowBound=0) for i in range(n)]\n zs = [LpVariable(name=\"z_{}\".format(i)) for i in range(n)]\n\n # objective\n model += lpSum(ws)\n\n # constraint 1:\n # sum of Li <= L\n model += (lpSum(ls) <= L * n, \"sum of Li <= L\")\n\n # Constraint 2:\n # w_i >= |z_i - y_i|\n for i in range(n):\n model += (ws[i] + zs[i] >= ys[i], \"C2.a_{}\".format(i))\n model += (ws[i] - zs[i] >= -ys[i], \"C2.b_{}\".format(i))\n\n # Constraint 3\n # |z_i - z_j| <= L_i * dist(x_i, x_j)\n for i in range(n):\n for j in range(n):\n if i != j:\n model += (zs[i] - zs[j] - abs(xs[i] - xs[j]) * ls[i] <= 0, \"C3.a_{}_{}\".format(i, j))\n model += (zs[j] - zs[i] - abs(xs[i] - xs[j]) * ls[i] <= 0, \"C3.b_{}_{}\".format(i, j))\n\n if model.solve() == 1:\n print(\n \"------------------------------------\\nFound solution for the linear program\\n------------------------------------\\n\")\n return [[xs[i], zs[i].value()] for i in range(n)]\n # return [zi.value() for zi in zs], [li.value() for li in ls]\n\n print(\"Linear program: no solution found\")\n exit(1)\n return -1","def cp_apr(X, Y1, R, Minit=None, tol=1e-4, maxiters=1000, maxinner=50,\n epsilon=1e-10, kappatol=1e-10, kappa=1e-2):\n N = X.ndims()\n \n ## Random initialization\n if Minit == None:\n F = tensorTools.randomInit(X.shape, R)\n Minit = ktensor.ktensor(np.ones(R), F);\n nInnerIters = np.zeros(maxiters);\n\n ## Initialize M and Phi for iterations\n M = Minit\n M.normalize(1)\n Phi = [[] for i in range(N)]\n kktModeViolations = np.zeros(N)\n kktViolations = -np.ones(maxiters)\n nViolations = np.zeros(maxiters)\n\n lambda2=0.1\n lambda3=0.1\n sita=np.random.rand(R+1,1);\n ## statistics\n cpStats = np.zeros(7)\n '''\n print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'\n print M.U[0][1,:]\n print M.U[0].shape\n print Demog[1]\n print DemoU[1]\n print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'\n '''\n for iteration in range(maxiters):\n startIter = time.time()\n isConverged = True;\n for n in range(N):\n startMode = time.time()\n ## Make adjustments to M[n] entries that violate complementary slackness\n if iteration > 0:\n V = np.logical_and(Phi[n] > 1, M.U[n] < kappatol)\n if np.count_nonzero(V) > 0:\n nViolations[iteration] = nViolations[iteration] + 1\n #print 'V:',V.shape,V.dtype\n #print 'M.U[n]',M.U[n].shape,M.U[n].dtype\n M.U[n][V > 0] = M.U[n][V > 0] + kappa\n if n==0:\n sita=__solveLinear(M.U[n],Y1,lambda3)\n # lr=LogisticRegression()\n #sita=lr.fit(M.U[n],Y1).coef_\n #print 'sita'\n #print sita\n #print 'demoU'\n #print DemoU[0]\n M, Phi[n], inner, kktModeViolations[n], isConverged = __solveSubproblem1(X, M, n, maxinner, isConverged, epsilon, tol,sita,Y1, lambda2)\n else:\n M, Phi[n], inner, kktModeViolations[n], isConverged = __solveSubproblem0(X, M, n, maxinner, isConverged, epsilon, tol)\n elapsed = time.time() - startMode\n # only write the outer iterations for now\n #cpStats = np.vstack((cpStats, np.array([iteration, n, inner, tensorTools.lsqrFit(X,M), tensorTools.loglikelihood(X,[M]), kktModeViolations[n], elapsed])))\n\n kktViolations[iteration] = np.max(kktModeViolations)\n elapsed = time.time()-startIter\n #cpStats = np.vstack((cpStats, np.array([iter, -1, -1, kktViolations[iter], __loglikelihood(X,M), elapsed])))\n print(\"Iteration {0}: Inner Its={1} with KKT violation={2}, nViolations={3}, and elapsed time={4}\".format(iteration, nInnerIters[iteration], kktViolations[iteration], nViolations[iteration], elapsed))\n if isConverged:\n break\n\n cpStats = np.delete(cpStats, (0), axis=0) # delete the first row which was superfluous\n ### Print the statistics\n #fit = tensorTools.lsqrFit(X,M)\n #ll = tensorTools.loglikelihood(X,[M])\n print(\"Number of iterations = {0}\".format(iteration))\n #print(\"Final least squares fit = {0}\".format(fit))\n #print(\"Final log-likelihood = {0}\".format(ll))\n print(\"Final KKT Violation = {0}\".format(kktViolations[iteration]))\n print(\"Total inner iterations = {0}\".format(np.sum(nInnerIters)))\n \n #modelStats = {\"Iters\" : iter, \"LS\" : fit, \"LL\" : ll, \"KKT\" : kktViolations[iteration]}\n return M, cpStats","def get_Objective(self):\r\n \r\n ans = 0\r\n for i in range(len(self.X.shape)):\r\n ans += self.parameter['phi'][i] * self.parameter['lambda1'] *norm(tl.unfold(self.Wlist[i], i), 'nuc') + (1 / self.parameter['m']) * norm(tl.unfold(self.X - self.Wlist[i] - self.V, i))\r\n\r\n # Augmented part is calculated seperately. \r\n augment_part1 = 0.5 * self.parameter['rho1'] * norm(self.V - self.T + self.F1)\r\n augment_part2 = 0.5 * self.parameter['rho2'] * norm(tl.fold(np.dot(self.Dmatrix, tl.unfold(self.T, 0)), 0, self.T.shape) - self.S + self.F2)\r\n\r\n # Combine the result for final objective function\r\n ans += self.parameter['beta1'] * norm(self.V.reshape(self.totaldim), 1) + self.parameter['beta2'] * norm(self.S.reshape(self.totaldim), 1) + augment_part1 + augment_part2 \r\n return ans","def weight_mm(self,m1,m2):\n lw = 1.\n\n # particle id and isolation\n lw *= self._muIDISOWeight.value(m1.pt(),m1.eta(),'0')\n lw *= self._muIDISOWeight.value(m2.pt(),m2.eta(),'0')\n\n # Trigger\n hlt_sf_run2012_a = (self._muTRIGGERWeight_leg8_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_A.value(m2.pt(),m2.eta(),'0') +\\\n self._muTRIGGERWeight_leg17_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg8_A.value(m2.pt(),m2.eta(),'0') -\\\n self._muTRIGGERWeight_leg17_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_A.value(m2.pt(),m2.eta(),'0'))\n\n hlt_sf_run2012_b = (self._muTRIGGERWeight_leg8_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_B.value(m2.pt(),m2.eta(),'0') +\\\n self._muTRIGGERWeight_leg17_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg8_B.value(m2.pt(),m2.eta(),'0') -\\\n self._muTRIGGERWeight_leg17_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_B.value(m2.pt(),m2.eta(),'0'))\n \n lw *= (0.5*hlt_sf_run2012_a + 0.5*hlt_sf_run2012_b) ##percentage according to the lumi in which they were not prescaled (apparently same efficinecy for AB)\n #lw *= 0.966 ## temporary solution!\n\n if abs(configuration.LeptonTnPfactor)<0.01 :\n return lw\n else:\n return lw + configuration.LeptonTnPfactor*self.uncertainty_mm(m1,m2)","def eg4(N_train=1000, N_test=500, depend_ratio_train=0.8, depend_ratio_test=0.2, feature_num=10, stable_ratio=0.4):\n\n def eg4_kernel(n, p, stable_ratio=0.4, depend_ratio=0.8):\n p_stable = int(p * stable_ratio)\n p_noise = p - p_stable\n noise_feature = np.random.randn(n, p_noise)\n stable_feature_dependent = np.zeros([n, p_stable])\n stable_feature_independent = np.random.randn(n, p_stable)\n for i in range(p_stable):\n stable_feature_dependent[:, i] = noise_feature[:, i % p_noise] + noise_feature[:,\n (i + 1) % p_noise] + 2 * np.random.randn(\n n) # still need noise\n stable_depend_label = np.random.uniform(0, 1, n).reshape(-1, 1)\n stable_depend_label = np.concatenate([stable_depend_label] * p_stable, axis=1)\n stable_feature = np.where(stable_depend_label < depend_ratio, stable_feature_dependent,\n stable_feature_independent)\n\n b = np.zeros([p_stable, 1])\n linear_len = int(p_stable / 2)\n\n for i in range(linear_len): # linear part\n b[i, 0] = (-1) ** i * (i % 3 + 1) * p / 3\n for i in range(linear_len, b.shape[0]): # nonlinear part\n b[i, 0] = p / 2\n\n Y = np.matmul(stable_feature, b) + np.random.randn(n, 1)\n\n data = {}\n data['stable'] = stable_feature\n data['noise'] = noise_feature\n data['Y'] = Y\n data['params'] = b\n data['kernel'] = 'eg4'\n return data\n\n data_train = eg4_kernel(n=N_train, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_train)\n data_test = eg4_kernel(n=N_test, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_test)\n return data_train, data_test","def coarse_to_fine(im1, im2, pyramid1, pyramid2, n_iter=3):\n assert im1.shape == im2.shape\n \n u = np.zeros_like(im1)\n v = np.zeros_like(im1)\n\n #\n # Your code here\n #\n\n # Code inspired by:\n # https://www.youtube.com/watch?v=FhlbUHhNpD4\n\n # descending indices of the gaussian pyramid \n # (from small to big image)\n K = len(pyramid1)\n levels = np.arange(K - 1, -1, -1) # [K - 1, K - 2, ..., 0]\n\n #######################\n # intial estimation #\n #######################\n\n ##################################################\n # print('Level [{}]'.format(K - 1))\n\n # get coarsest images from the gaussian pyramid\n # at level (k - 1)\n im1_k = pyramid1[-1].copy()\n im2_k = pyramid2[-1].copy()\n\n # iterative LK-Algorithm (refine the motion)\n uk, vk = iter_LK(im1_k, im2_k, n_iter)\n\n # expand image to new resolution\n uk_exp = expand(uk) * 2\n vk_exp = expand(vk) * 2\n ###################################################\n\n\n ##############################\n # coarse to fine iteritons #\n ##############################\n\n # iterate over [ K-2, K-3, ..., 0 ] -> all scales except the smallest\n for k in levels[1:]: \n # print('Level [{}]'.format(k))\n\n # get images of current scale from the pyramid\n im1_k = pyramid1[k]\n im2_k = pyramid2[k]\n\n # warp im1 image from pyramid1\n im1_k_warp = warp(im1_k, uk_exp, vk_exp)\n\n # apply LK for iterative refinement on current resolution\n uk, vk = iter_LK(im1_k_warp, im2_k, n_iter)\n\n # add current motion fields (uk, vk) from iter_LK to \n # previous expanded motion fields (uk_exp, vk_exp)\n uk = uk + uk_exp\n vk = vk + vk_exp\n\n # expand the motion fields (uk, vk) to the next higher\n # scale in the gaussian pyramid (to use in next iteration)\n if k > 0: # all other level\n uk_exp = expand(uk) * 2\n vk_exp = expand(vk) * 2\n else: # last level 0 (no expansion needed -> original scale)\n uk_exp = uk\n vk_exp = vk\n\n # print('[', k, ']: uk_exp = ', uk_exp.shape, ' | vk_exp = ', vk_exp.shape)\n\n # print('[FINAL]: u = ', uk_exp.shape, ' | v = ', vk_exp.shape)\n\n # set the final parameter \n # (LK at original resolution)\n u = uk_exp\n v = vk_exp\n\n assert u.shape == im1.shape and \\\n v.shape == im1.shape\n return u, v","def compute_surr_objective(A_hat, old_policy_model, policy_model, j, state_part_mean, state_part_std, config=PPO_config):\n \n def clip(c, epsilon):\n if c < 1-epsilon:\n return 1- epsilon\n elif c > 1+epsilon:\n return 1+ epsilon\n else:\n return c\n \n clipping_param = np.amax([0.01, (1-j/config['J'])*config['clipping']])\n print(\"Clipping parameters: {}\".format(clipping_param))\n #K = PPO_config['K']\n #assert(K==len(A_hat))\n policy_model.to(device)\n old_policy_model.to(device)\n surr_objective = 0\n kl_est_list = []\n for k in range(len(A_hat)):\n for i in range(len(A_hat[k])):\n # CHECK: if the action is an integer corresponding to the state\n curr_state = torch.tensor(A_hat[k][i][0]).float()\n try:\n curr_state_norm_input = torch.cat((curr_state[:,0].unsqueeze(1), (curr_state[:,1:]-state_part_mean)/state_part_std))\n except:\n curr_state_norm_input = torch.cat((curr_state[0].unsqueeze(0), (curr_state[1:]-state_part_mean)/state_part_std))\n\n curr_state_norm_input[np.isnan(curr_state_norm_input)] = 0\n curr_state_norm_input.to(device)\n curr_action = A_hat[k][i][1]\n\n r_theta_ksi = policy_model(curr_state_norm_input.to(device))[curr_action] / old_policy_model(curr_state_norm_input.to(device))[curr_action] \n r_theta_ksi_num = r_theta_ksi.cpu().detach().numpy()\n single_est_from_r = r_theta_ksi_num-1-np.log(r_theta_ksi_num)\n kl_est_list.append(single_est_from_r)\n A_hat_ksi = A_hat[k][i][2] # Estimate the A_hat\n surr_objective += min(r_theta_ksi * A_hat_ksi, clip(r_theta_ksi, clipping_param) * A_hat_ksi)\n surr_objective /= len(A_hat)\n kl_est = np.mean(np.asarray(kl_est_list))\n\n return surr_objective, kl_est","def propose_optimize():\n pass","def l1Min(A, b):\n #set up the matrices\n m,n = A.shape\n solvers.options['show_progress'] = False\n c = np.concatenate([np.ones(n),np.zeros(n)]).astype(float)\n G = np.vstack((np.hstack((-np.eye(n),np.eye(n))), np.hstack((-np.eye(n),-np.eye(n))),np.hstack((-np.eye(n),np.zeros((n,n))))))\n h = np.zeros(3*n).astype(float)\n A = np.hstack((np.zeros((m,n)),A)).astype(float)\n #convert the matrices\n c = matrix(c)\n G = matrix(G)\n h = matrix(h)\n A = matrix(A)\n b = matrix(b.astype(float))\n #solve the matrices\n sol = solvers.lp(c, G, h,A,b)\n\n return np.ravel(sol['x'][n:]),sol['primal objective']","def highpass(R1=10e3,R3=10e3,C1=1e-9,C2=1e-9,G=1.586,Vi=1):\n \n A=Matrix([[0,-1,0,1/G],\n [s*C2*R3/(s*C2*R3+1),0,-1,0],\n [0,G,-G,1],\n [-s*C2-1/R1-s*C1,0,s*C2,1/R1]])\n\n b=Matrix([0,0,0,-Vi*s*C1])\n\n V=A.inv()*b\n #V_lim = [limit(v,G1,oo) for v in V]\n return (A,b,V)","def objective(self):\n pass","def _objective(self,output, expected,device):\r\n #\r\n #output = output.to(device = expected.device) #\r\n \r\n output = torch.where(output == 0,self.saf,output)\r\n #output = torch.where(output == 1,torch.tensor([0.999999],device = device),output)\r\n out1 = torch.mul(-expected,torch.log(output))\r\n #out2 = torch.mul(expected-1,torch.log(1 - output))\r\n #out = torch.add(out1,out2)\r\n return torch.sum(out1, dim = 1)","def potentialSolver4(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def _compute_imprimitivity(self):\n m = floor(self._.d / 2)\n self._.antipodal = all(full_simplify(\n self._.b[i] - self._.c[self._.d - i]) == 0\n for i in range(self._.d) if i != m)\n self._.bipartite = all(a == 0 for a in self._.a)\n if self._.antipodal:\n try:\n self._.r = integralize(\n 1 + self._.b[m] / self._.c[self._.d - m])\n except TypeError:\n raise InfeasibleError(\"covering index not integral\")\n if self._.d >= 2:\n if self._.d == 2:\n b = [self._.b[0]/(self._.b[1]+1)]\n c = [Integer(1)]\n else:\n b = self._.b[:m]\n c = list(self._.c[1:m+1])\n if is_divisible(self._.d, 2):\n c[-1] *= self._.r\n scheme = self._get_class()(tuple(b), tuple(c))\n else:\n scheme = ASParameters(P=[[1]])\n self._.antipodal_subscheme = self.add_subscheme(scheme,\n self.ANTIPODAL)\n if self._.bipartite:\n if self._.d >= 2:\n b = tuple(self._.b[2*i]*self._.b[2*i+1]/self._.c[2]\n for i in range(m))\n c = tuple(self._.c[2*i+1]*self._.c[2*i+2]/self._.c[2]\n for i in range(m))\n scheme = self._get_class()(b, c)\n else:\n scheme = ASParameters(P=[[1]])\n self._.bipartite_subscheme = self.add_subscheme(scheme,\n self.BIPARTITE)","def make_objective(name, data, pset, unconfined_objective=None, bset=None,\n num_points=101, withtail=True):\n h2o = SLD(-0.54, 'h2o')\n melCM = SLD(2.60, 'Melinex CM soln')\n melinex = SLD(2.56, 'Melinex') \n sio2 = SLD(3.47, 'sio2')\n si = SLD(2.07, 'si')\n polymer = SLD(0.85, 'PNIPAM')\n\n # Make sure nothing in our (already fitted) unconfined objective varys.\n\n\n si_l = si(0, 0)\n\n # Silica\n sio2_l = sio2(14.6, 2)\n sio2_l.vfsolv.setp (value=0.003)\n\n polymer_l_mel = area_slabT(adsorbed_amount=200, dry_sld=polymer, rough=2,\n thick=1500, name='polymer')\n\n mellinex_l = melinex(0,14)\n mellinex_l.rough.setp (vary=False, bounds=(1, 20))\n\n h2o_l = h2o(0,10)\n\n structure_mel = si_l | sio2_l | polymer_l_mel | mellinex_l\n\n if unconfined_objective is not None:\n for vp in unconfined_objective.varying_parameters().flattened():\n vp.setp(vary=False)\n unconfined_objective.model.structure[3].adsorbed_amount = polymer_l_mel.adsorbed_amount\n structure_h2o = si_l | sio2_l | unconfined_objective.model.structure[2] | unconfined_objective.model.structure[3] | h2o_l\n else:\n structure_h2o = si_l | h2o_l\n\n\n structure_mel.solvent = h2o\n structure_h2o.solvent = h2o\n\n if unconfined_objective is not None:\n structure_h2o.contract = 1.5\n\n distmodel = DistributionModel(structure_mel, loc_in_struct=2,\n num_structs=num_points, pdf=dist_pdf,\n pdf_kwargs={'loc':1, 'scale':1, 'a':1, 'tail':0.00, 'tail_len':400})\n distmodel.pdf_params[0].setp(value=210)\n distmodel.pdf_params[1].setp(value=6)\n distmodel.pdf_params[2].setp(value=3)\n\n if withtail:\n distmodel.pdf_params[3].setp(value=0.0001)\n distmodel.pdf_params[4].setp(value=400)\n else:\n distmodel.pdf_params[3].setp(value=0, vary=False)\n distmodel.pdf_params[4].setp(value=0, vary=False) \n\n h2omodel = ReflectModel(structure_h2o, name='h2o')\n\n\n sratio = Parameter(value=0.1, name='scale ratio')\n\n model = MetaModel([distmodel, h2omodel], [0.5, 0.5], add_params=[sratio])\n model.scales[0].setp(value=0.97)\n model.scales[1] = model.scales[0]*sratio\n model.bkg.setp(value=0)\n\n obj = Objective(model, data, name=name)\n for key in pset:\n set_param(obj.parameters, key, value=pset[key])\n\n if bset is not None:\n for key in bset:\n set_param(obj.parameters, key, bounds=bset[key])\n\n return obj","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 HaarGOB(treeG):\n # number of level of the chain (or tree)\n Ntr = len(treeG)\n # reorder chain (optional) \n # reordering each level so that in each level the nodes are in the\n # descent order of degrees\n # compute u_l^c for level J_0 (top level)\n clusterJ0 = treeG[Ntr-1]['clusters']\n N0 = len(clusterJ0)\n # generate indicator function on G^c\n chic = np.identity(N0)\n uc = [None]*N0\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\n for l in np.arange(1, N0):\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\n# u = copy.deepcopy(uc)\n treeG[Ntr-1]['u'] = uc\n # compute the next level orthonormal basis ulk and stored into u\n for j_tr in np.arange(0, Ntr-1)[::-1]:\n N1 = len(treeG[j_tr]['clusters'])\n u = [None]*N1\n i = N0\n for l in range(N0):\n clusterl = treeG[j_tr+1]['clusters'][l]\n kl = len(clusterl)\n #for k==1\n ucl = uc[l]\n ul1 = np.zeros(N1)\n for j in range(N0):\n idxj = treeG[j_tr+1]['clusters'][j]\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\n u[l] = ul1\n if kl>1:\n chil = np.zeros((kl,N1))\n for k in range(kl):\n idxl = treeG[j_tr+1]['clusters'][l]\n chil[k,idxl[k]] = 1;\n \n for k in np.arange(1,kl):\n i = i+1\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\n u[i-1] = ulk\n treeG[j_tr]['u'] = u\n # update uc and N0\n# uc = copy.deepcopy(u)\n uc = u\n N0 = N1\n return treeG","def seepage_from_superoperator(U):\n if U.type=='oper':\n sump = 0\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\n bra_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\n qtp.ket([i_list[1]], dim=[3])).dag()\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\n qtp.ket([j_list[1]], dim=[3]))\n p = np.abs((bra_i*U*ket_j).data[0, 0])**2\n sump += p\n sump /= 5 # divide by number of non-computational states\n L1 = 1-sump\n return L1\n elif U.type=='super':\n sump = 0\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\n ket_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\n qtp.ket([i_list[1]], dim=[3]))\n rho_i=qtp.operator_to_vector(qtp.ket2dm(ket_i))\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\n qtp.ket([j_list[1]], dim=[3]))\n rho_j=qtp.operator_to_vector(qtp.ket2dm(ket_j))\n p = (rho_i.dag()*U*rho_j).data[0, 0]\n sump += p\n sump /= 5 # divide by number of non-computational states\n sump=np.real(sump)\n L1 = 1-sump\n return L1","def MILP_1(self,xData,uData):\n print \"\\n\",\"*\"*80,\"\\n\",\"MILP 1: Parameter Estimation\\n\",\"*\"*80 \n model=Model(\"parameters\")\n outflow={}\n d={}\n bigM=500\n Q_out={}\n Q_in={}\n N=max(l[1] for l in xData.keys())\n print \"x Data size is\",N\n N=max(l[1] for l in uData.keys())\n print \"u Data size is\",N\n for l in self.links:\n l.d=model.addVar(lb=0,ub=200,obj=0*l.type==\"road\") \n for t in range(1,N):\n d[l,t]=model.addVar(lb=0,ub=200,obj=1)\n for k in l.outgoing:\n outflow[l,k,t]=model.addVar(lb=0,ub=200)\n self.c[l,k]=model.addVar(lb=20,ub=200)\n self.beta[l,k]=model.addVar(lb=0.2,ub=0.8)\n self.alpha[l,k]=model.addVar(lb=0,ub=1)\n self.M[l,k]=model.addVar(lb=0,ub=200)\n d[\"outflow-1\",l,k,t]=model.addVar(vtype=GRB.BINARY) \n d[\"outflow-2\",l,k,t]=model.addVar(vtype=GRB.BINARY) \n model.update()\n for t in range(1,N):\n for l in self.links:\n if True:\n Q_out[l,t]=LinExpr()\n Q_in[l,t]=LinExpr()\n Q_out[l,t].addConstant(0)\n Q_in[l,t].addConstant(0)\n for k in l.outgoing:\n model.addConstr(outflow[l,k,t]<=self.beta[l,k]*uData[l,t]*xData[l,t])\n model.addConstr(outflow[l,k,t]<=self.M[l,k])\n model.addConstr(outflow[l,k,t]<=self.c[l,k]-self.alpha[l,k]*xData[k,t])\n model.addConstr(outflow[l,k,t]>=self.beta[l,k]*uData[l,t]*xData[l,t]+bigM*d[\"outflow-1\",l,k,t]-bigM)\n model.addConstr(outflow[l,k,t]>=self.M[l,k]+bigM*d[\"outflow-2\",l,k,t]-bigM)\n model.addConstr(outflow[l,k,t]>=self.c[l,k]-self.alpha[l,k]*xData[k,t]-bigM*d[\"outflow-1\",l,k,t]-bigM*d[\"outflow-2\",l,k,t])\n Q_out[l,t].add(outflow[l,k,t])\n for k in l.incoming:\n Q_in[l,t].add(outflow[k,l,t])\n if l.type==\"road\":\n model.addConstr(xData[l,t+1]<=xData[l,t]- Q_out[l,t] + Q_in[l,t] + d[l,t] + l.lambda_arrival) \n else:\n model.addConstr(xData[l,t+1]<=xData[l,t]- uData[l,t]*xData[l,t] + Q_in[l,t] + d[l,t] + l.lambda_arrival)\n for l in self.links:\n sum=LinExpr()\n for k in l.outgoing:\n sum.add(self.beta[l,k])\n model.addConstr(sum>=0)\n \n# J=QuadExpr()\n# for l in self.links:\n# for t in range(1,N):\n# if l.type==\"road\":\n# J.add(d[l,t]*d[l,t])\n# model.setObjective(J)\n model.optimize()\n for l in self.links:\n l.d=l.d.X\n for k in l.outgoing:\n self.beta[l,k]=self.beta[l,k].X\n self.c[l,k]=self.c[l,k].X\n self.alpha[l,k]=self.alpha[l,k].X\n self.M[l,k]=self.M[l,k].X\n for l in self.links:\n for t in range(1,N):\n l.d=max(d[l,t].X,l.d)\n \n \n\n \n if True:\n for t in range(1,N):\n print \"*\"*80,\"time=\",t\n for l in self.links:\n print \"\\n\",l,\"x is\",xData[l,t],\"u is\",uData[l,t],\"x+ is\",xData[l,t+1]\n for k in l.outgoing:\n print k,\"beta:\",self.beta[l,k],\"outflow\",outflow[l,k,t].X","def main():\n if len(sys.argv) != 5:\n exit(\"Usage: python oneta.py train-corpus test-corpus kernel-size output\")\n\n w1Words = dict()\n w2Words = dict()\n W1 = 0\n W2 = 0\n\n D1 = int(sys.argv[3])\n\n sys.stderr.write(\"First scan of training data\\n\")\n \n J = 0\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\n corpus = open(sys.argv[1],\"r\")\n for line in corpus:\n tokens = word_tokenize(line)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if J < D1 and tk_decoded not in w1Words:\n w1Words[tk_decoded] = W1\n W1 += 1\n elif J >= D1 and tk_decoded not in w2Words:\n w2Words[tk_decoded] = W2\n W2 += 1\n J += 1\n corpus.close()\n\n D2 = J - D1\n\n # Partition the corpus into a L-shaped matrix\n sys.stderr.write(\"Building matrices\")\n At = lil_matrix((D1,W1))\n B = lil_matrix((W1,D2))\n Ct = lil_matrix((D2,W2))\n\n corpus = open(sys.argv[1],\"r\")\n\n j = 0\n for line in corpus:\n sys.stderr.write(\".\")\n tokens = word_tokenize(line)\n docsq = 0.\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if j < D1: # tk_decoded in w1words\n tkId = w1Words[tk_decoded]\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\n At[j,tkId] += 1.\n elif tk_decoded in w1Words:\n tkId = w1Words[tk_decoded]\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\n B[tkId,j-D1] += 1.\n else:\n tkId = w2Words[tk_decoded]\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\n Ct[j-D1,tkId] += 1.\n if j < D1:\n At[j,:] /= math.sqrt(docsq)\n else:\n for w in range(0,W1):\n B[w,j-D1] /= math.sqrt(docsq)\n Ct[j-D1,:] /= math.sqrt(docsq)\n j += 1\n\n sys.stderr.write(\"\\nBuild Cn\\n\")\n Cn = zeros((D2,1))\n Ct = Ct.tocsr()\n for i in range(0,D2):\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\n if v == 0:\n Cn[i,0] = 1.\n else:\n Cn[i,0] = v\n\n # Building real matrices\n sys.stderr.write(\"Calculating ATA\\n\")\n ATA = (At * At.transpose()).todense() # D1 x D1\n At = At.tocsr()\n B = B.tocsc()\n\n sys.stderr.write(\"Solve inverse\\n\")\n ATAi = linalg.inv(ATA)\n\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\n sys.stderr.write(\"Calculating projected vectors\\n\")\n\n out = open(sys.argv[4],\"w\")\n testDocs = open(sys.argv[2],\"r\")\n for testDoc in testDocs:\n sys.stderr.write(\".\")\n corpus = open(sys.argv[1],\"r\")\n d1 = zeros((W1,1))\n d2 = zeros((W2,1))\n tokens = word_tokenize(testDoc)\n for token in tokens:\n tk_decoded = token.decode(\"utf-8\")\n if tk_decoded in w1Words:\n d1[w1Words[tk_decoded],0] += 1\n elif tk_decoded in w2Words:\n d2[w2Words[tk_decoded],0] += 1\n norm = sqrt(sum(d1**2) + sum(d2**2))\n d1 /= norm \n d2 /= norm\n v2 = (Ct * d2) / Cn\n v1 = ATAi * (At * (d1 - B * v2))\n for j in range(0,D1+D2):\n out.write(str(j) + \" \")\n out.write(\"||| \")\n for j in range(0,D1):\n out.write(str(v1[j,0]) + \" \")\n for j in range(0,D2):\n out.write(str(v2[j,0]) + \" \")\n out.write(\"\\n\")\n\n out.flush()\n out.close()\n sys.stderr.write(\"\\n\")","def optGM(objective_function: \"function\",\n set_of_mols_par: SetOfMolecules,\n subset_of_mols: SetOfMolecules,\n min_subset_of_mols: SetOfMolecules,\n chg_method: ChargeMethod,\n num_of_samples: int,\n num_of_candidates: int) -> namedtuple:\n\n print(\" Sampling...\")\n samples = lhs(num_of_samples, chg_method.params_bounds)\n\n print(\" Calculating of objective function for samples...\")\n samples_rmsd = [objective_function(sample, chg_method, min_subset_of_mols) for sample in samples]\n\n print(\"\\x1b[2K Selecting candidates...\")\n best_samples = samples[list(map(samples_rmsd.index, nsmallest(num_of_candidates * 100, samples_rmsd)))]\n best_samples_rmsd = [objective_function(sample, chg_method, set_of_mols_par) for sample in best_samples]\n candidates = best_samples[list(map(best_samples_rmsd.index, nsmallest(num_of_candidates, best_samples_rmsd)))]\n\n print(\"\\x1b[2K Local minimizating...\")\n all_loc_min_course = []\n opt_candidates = []\n for params in candidates:\n opt_params, _, loc_min_course = local_minimization(objective_function, subset_of_mols, chg_method, params)\n all_loc_min_course.append(loc_min_course[0])\n opt_candidates.append(opt_params)\n\n opt_candidates_rmsd = [objective_function(candidate, chg_method, set_of_mols_par) for candidate in opt_candidates]\n final_candidate_obj_val = nsmallest(1, opt_candidates_rmsd)\n final_candidate_index = opt_candidates_rmsd.index(final_candidate_obj_val)\n final_candidate = opt_candidates[final_candidate_index]\n\n print(\"\\x1b[2K Final local minimizating...\")\n final_params, final_obj_val, loc_min_course = local_minimization(objective_function, set_of_mols_par, chg_method, final_candidate)\n all_loc_min_course[final_candidate_index].extend(loc_min_course[0])\n\n return namedtuple(\"chgs\", [\"params\",\n \"obj_val\",\n \"loc_min_courses\"])(final_params,\n final_obj_val,\n all_loc_min_course)","def objective(self,w):\n diffs = self.get_y_times_diffs(self.get_split_weights(w))\n #print diffs, sigmoid(diffs)\n obj = -np.sum(np.log(sigmoid(diffs))) #negative, since minimising\n # regularisation\n obj += 0.5 * self.alpha * np.dot(w[:self.interp_index[0]], w[:self.interp_index[0]])\n return obj","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","def potentialSolver3(self, w, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n # Step 1: create *integer* array the same size as u \n x = np.zeros_like(self.phi,dtype=np.int)\n\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\n\n # Step 3: get indices of even (red) and odd (black) points\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\n\n\n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n \n \"\"\"\n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n # Red point update\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n # Black point update\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\n\n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged","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 find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\n\n # Create a new model\n m = Model(\"hamiltonian_cycle\")\n \n # Create variables\n x_vars = {}\n u_vars = {}\n for var1 in permute(G.vertices()):\n for var2 in permute(G.vertices()):\n if var1 != var2:\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\"x_\"+str(var1)+'_'+str(var2))\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\"u_\"+str(var1))\n m.update()\n \n for var in G.vertices():\n if var != START_NODE:\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\n #print(cur_incoming)\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\n \n if var != END_NODE:\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\n #print(cur_outgoing)\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\n \n for var1 in G.vertices():\n for var2 in G.vertices():\n if var1 != var2:\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\n #print(c)\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\n \n # Set objective\n #try:\n edge_weights = permute(G.get_edge_weights(weights))\n if probs_instead_of_weights:\n all_probs = []\n for v in G.vertices():\n if v != END_NODE:\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\n S = logsumexp([x[1] for x in batch_scores])\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\n all_probs.extend(batch_scores)\n edge_weights = all_probs\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\n #except TypeError:\n # return None\n \n m.setObjective(objective,GRB.MINIMIZE)\n m.update()\n code = m.optimize()\n \n try:\n return [k for k,v in x_vars.items() if v.x > 0.98]\n except GurobiError:\n return None","def penaltyFactor(m):\n \"\"\" m in GeV \"\"\"\n if m*m>0.71:\n return math.pow(m*m/0.71,-4)\n else:\n return 1","def reduce(self, threshold):\n def percentage_change(old, new):\n return (old - new) / old\n real_reduction_iterations = 0\n padic_reduction_iterations = 0\n cont_reduction_iterations = 0\n factor = len(self.constants.primes) + 1\n \n print('initial bound',max(self.coefficients['n1_bound'],max(self.coefficients['Z_bounds'])))\n\n # First, go through the real reduction loop.\n current_n1_bound = self.coefficients['n1_bound']\n current_diff_bound = None\n while True:\n real_reduction_iterations += 1\n logging.info(\"Real Reduction - Iteration %d\" % real_reduction_iterations)\n\n large_constant = self.calculate_large_constant(current_n1_bound, factor)\n logging.info(\"Large constant contains %d digits \" % large_constant.ndigits())\n\n # Find a new bound on n_1 - n_k\n new_diff_bound = self.real_reduce(current_n1_bound, large_constant)\n logging.info(\"Current bound on n1: \" + str(current_n1_bound))\n self.update_real_constants(new_diff_bound)\n logging.info(\"new diff bound: \" + str(new_diff_bound))\n logging.info(\"New bound on n1: \" + str(self.coefficients[\"n1_bound\"]))\n logging.info(\"New bound on zi: \" + str(self.coefficients['Z_bounds']))\n \n if percentage_change(current_n1_bound, self.coefficients[\"n1_bound\"]) < self.threshold:\n logging.info(\"New bound did not improve in the real step; real reduction process is done.\")\n factor = factor + 5\n break\n\n current_n1_bound = self.coefficients['n1_bound']\n current_diff_bound = new_diff_bound\n\n # Second, go through the p-adic reduction loop.\n current_Z_bounds = self.coefficients['Z_bounds']\n while True:\n padic_reduction_iterations += 1\n logging.info(\"p-adic Reduction - Iteration %d\" % padic_reduction_iterations)\n\n new_Z_bounds = self.padic_reduce(math.ceil(current_diff_bound))\n logging.info(\"New bound on zi: \" + str(new_Z_bounds))\n logging.info(\"Current bound on n1: \" + str(current_n1_bound))\n new_n1_bound = self.update_padic_constants(new_Z_bounds)\n logging.info(\"New bound on n1: \" + str(new_n1_bound))\n if percentage_change(current_n1_bound, new_n1_bound) < self.threshold:\n logging.info(\"New bound did not improve in the p-adic step; p-adic reduction process is done.\")\n break\n\n current_n1_bound = new_n1_bound\n\n print(current_n1_bound)\n\n return self.constants","def penalty_objective(Z_0, Z_1, Z_2, psi, theta):\n return theta * sum(map(l1_od_norm, Z_0)) + (1 - theta) * sum(map(psi, Z_2 - Z_1))","def minimize_neg_lbl(self):\n if self.spatial_only:\n init_index = 0 # anything should work here\n else:\n init_index = np.mean((self.energy_likelihood._min_index,\n self.energy_likelihood._max_index))\n \n init_ns = np.arange(self.fit_input['N']).mean()\n\n m = Minuit(self._neg_lbl,\n n_s = init_ns,\n gamma = init_index)\n\n m.errors = [1, 0.1]\n m.errordef = Minuit.LIKELIHOOD # 0.5\n \n if self.spatial_only:\n m.fixed['gamma'] = True\n m.limits = [(0, self.fit_input['N']-1),\n (None,None)]\n else:\n m.limits = [(0, self.fit_input['N']-1),\n (self.energy_likelihood._min_index,\n self.energy_likelihood._max_index)]\n\n m.migrad()\n self.minuit = m\n self._best_fit_ns = m.values[\"n_s\"]\n self._best_fit_index = m.values[\"gamma\"]\n return m, self._best_fit_ns, self._best_fit_index","def mole_jameson_insertion_init(D, d, C, L=None, minimize_K=False,\n strain_criterion='all' ):\n\n callback_configurations = []\n if strain_criterion=='proximity_ranking' or strain_criterion=='all':\n callback_configurations.append( \n ( _create_new_criteria_function(lm=0.0,mm=0.0), \"farthest\") )\n \n if strain_criterion=='min_strain':\n #or strain_criterion=='all': # <- this is already is in 'augumented_min_strain'\n callback_configurations.append(\n (_create_new_criteria_function(lm=0.0,mm=1.0), \"farthest\") )\n \n if strain_criterion=='clarke_wright':\n #or strain_criterion=='all': # <- this is already in 'augumented_min_strain'\n callback_configurations.append( \n # when mu = lambda-1, initiate route with savings criteria\n (_create_new_criteria_function(lm=2.0,mm=1.0), \"strain\") )\n \n if strain_criterion=='gaskell' or strain_criterion=='all':\n lambda_mults = [1.25, 1.5, 1.75, 2.0]\n for glm in lambda_mults:\n callback_configurations.append( \n # when mu = lambda-1, initiate route with savings criteria\n (_create_new_criteria_function(lm=glm,mm=glm-1.0), \"strain\") )\n \n if strain_criterion=='augumented_min_strain' or strain_criterion=='all':\n # the lm=2.0, mm=1.0 is already in 'gaskell'\n lambda_mults = [0, 0.5, 1, 1.5] if strain_criterion=='all' else\\\n [0, 0.5, 1, 1.5, 2.0]\n for alm in lambda_mults:\n callback_configurations.append( \n ( _create_new_criteria_function(lm=alm,mm=1.0),\n \"strain\" if alm-1.0==1.0 else \"farthest\" ) )\n \n ## Find the best solution among the active strain criterions \n best_sol = None\n best_f = None\n best_K = None\n interrupted = False\n for strain_function, init_method in callback_configurations:\n \n sol, sol_f, sol_K = None, float('inf'), float('inf')\n try:\n sol = cheapest_insertion_init(D, d, C, L, minimize_K=False,\n emerging_route_count=1,\n initialize_routes_with=init_method,\n insertion_strain_callback=strain_function,\n insert_callback=_try_insert_2opt_and_update)\n sol = _refine_solution(sol, D, d, C, L, minimize_K)\n # LS may make some of the routes empty\n sol = without_empty_routes(sol)\n \n except KeyboardInterrupt as e: #or SIGINT\n # some of the strain function insertion runs was interrupted\n if len(e.args)>0 and type(e.args[0]) is list:\n sol = e.args[0]\n interrupted = True\n \n if sol:\n sol_f = objf(sol, D)\n sol_K = sol.count(0)-1\n if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):\n best_sol = sol\n best_f = sol_f\n best_K = sol_K\n \n if interrupted:\n raise KeyboardInterrupt(best_sol)\n \n return best_sol","def minimization(X, Y, r, L, max_iter):\r\n # Define the number of data points and dimension\r\n N = float(X.shape[0])\r\n d = X.shape[1]\r\n # Calculate the number of classes, q\r\n classes, q = [], 0\r\n for i in Y:\r\n if i not in classes:\r\n classes.append(i)\r\n q += 1\r\n # Calculate averages and M matrix\r\n classes_X = [[] for i in range(q)]\r\n for i, h in enumerate(classes):\r\n for j, k in enumerate(Y):\r\n if k == i:\r\n classes_X[i].append(X[j])\r\n mu_g = []\r\n for i, j in enumerate(classes_X):\r\n mu_g.append(np.mean(j, axis=0))\r\n mu = np.mean(X, axis=0)\r\n M = np.zeros((q, d))\r\n for i in range(q):\r\n M[i] = mu_g[i] - mu\r\n # Calculate sigma_xx\r\n Xc = np.transpose(X[0] - mu)\r\n for i in range(1, int(N)):\r\n Xc = np.vstack((Xc, np.transpose(X[i] - mu)))\r\n sigma_xx = np.matmul(Xc.T, Xc) / N\r\n # Calculate the size of each class\r\n Ng = []\r\n for i in classes:\r\n Ng.append((Y == i).sum())\r\n # Calculate the C matrix\r\n C = np.zeros((q, q))\r\n for i in range(q):\r\n C[i, i] = Ng[i] / N\r\n # Calculate C^(-1/2)\r\n C12 = np.zeros((q, q))\r\n for i in range(q):\r\n C12[i, i] = C[i, i] ** -0.5\r\n # Calculate initial theta\r\n Id = np.identity(r)\r\n z = np.zeros((q - r, r))\r\n theta = np.matmul(C12, np.vstack((Id, z)))\r\n # Initialize flags and error tolerance\r\n CONVERGED = False\r\n MAXITER_REACHED = False\r\n eps = 1e-06\r\n # Define constraints\r\n cons = ({'type': 'eq', 'fun': lambda x: constraint_1(x, q, r, C)},\r\n {'type': 'eq', 'fun': lambda x: constraint_2(x, q, r, C)})\r\n # Initialize error\r\n b = np.random.random((d, r))\r\n error = F_lambda(theta, b, q, d, r, M, C, sigma_xx, L)\r\n cost = []\r\n # Initialize counters for individual algorithm iterations\r\n b_it, theta_it = 0, 0\r\n # Run minimization algorithm\r\n for i in range(max_iter):\r\n # Save value of error from the previous iteration\r\n prev_error = error\r\n if i % 2 == 0:\r\n # Minimize b with respect to fixed theta using BFGS\r\n b_flat = b.flatten()\r\n b_min = minimize(lambda x: F_lambda(\r\n theta, x, q, d, r, M, C, sigma_xx, L), b_flat, method='BFGS')\r\n b = np.reshape(b_min.x, (d, r))\r\n b_it += b_min.nit\r\n # Check if rank(Mb) >= r\r\n test = np.linalg.matrix_rank(np.matmul(M, b))\r\n if test < r:\r\n raise Exception(\"Error: rank(Mb) < r\")\r\n else:\r\n # Minimize theta with respect to fixed b using SLSQP\r\n theta_flat = theta.flatten()\r\n theta_min = minimize(lambda x: F_lambda(\r\n x, b, q, d, r, M, C, sigma_xx, L), theta_flat, method='SLSQP',\r\n constraints=cons)\r\n theta = np.reshape(theta_min.x, (q, r))\r\n theta_it += theta_min.nit\r\n # Check if function has been minimized\r\n error = F_lambda(theta, b, q, d, r, M, C, sigma_xx, L)\r\n cost.append(error)\r\n CONVERGED = abs(error - prev_error) < eps\r\n if CONVERGED:\r\n break\r\n # Check if the maximum number of iterations has been reached\r\n MAXITER_REACHED = i == max_iter - 1\r\n if CONVERGED:\r\n print(\"Overall algorithm iterations: %d\" % i)\r\n print(\"Combined number of iterations for BFGS: %d\" % b_it)\r\n print(\"Combined number of iterations for SLSQP: %d\" % theta_it)\r\n print(\"Total number of iterations: %d\" % (b_it + theta_it))\r\n elif MAXITER_REACHED:\r\n print(\"The maximum number of iterations has been reached.\")\r\n it = np.arange(0, i + 1)\r\n return b, theta, mu, it, cost","def _inexact_alm_l1(imgflt_stack,options):\n # Get basic image information and reshape input\n img_width = imgflt_stack.shape[0]\n img_height = imgflt_stack.shape[1]\n img_size = img_width* img_height\n img_3d = imgflt_stack.shape[2]\n imgflt_stack = np.reshape(imgflt_stack,(img_size, img_3d))\n options['weight'] = np.reshape(options['weight'],imgflt_stack.shape)\n\n # Matrix normalization factor\n temp = np.linalg.svd(imgflt_stack,full_matrices=False,compute_uv=False)\n norm_two = np.float64(temp[0])\n del temp\n\n # A is a low rank matrix that is being solved for\n A = np.zeros(imgflt_stack.shape,dtype=np.float64)\n A_coeff = np.ones((1, img_3d),dtype=np.float64) # per image scaling coefficient, accounts for things like photobleaching\n A_offset = np.zeros((img_size,1),dtype=np.float64) # offset per pixel across all images\n\n # E1 is the additive error. Since the goal is determining the background signal, this is the real signal at each pixel\n E1 = np.zeros(imgflt_stack.shape,dtype=np.float64)\n\n # Normalization factors\n ent1 = np.float64(1) # flatfield normalization\n ent2 = np.float64(10) # darkfield normalization\n\n # Weights\n weight_upd = _dct2(np.mean(np.reshape(A,(img_width, img_height, img_3d)),2))\n\n # Initialize gradient and weight normalization factors\n Y1 = np.float64(0)\n mu = np.float64(12.5)/norm_two\n mu_bar = mu * 10**7\n rho = np.float64(1.5)\n\n # Frobenius norm\n d_norm = np.linalg.norm(imgflt_stack,'fro')\n\n # Darkfield upper limit and offset\n B1_uplimit = np.min(imgflt_stack)\n B1_offset = np.float64(0)\n\n # Perform optimization\n iternum = 0\n converged = False\n while not converged:\n iternum += 1\n\n # Calculate the flatfield using existing weights, coefficients, and offsets\n W_idct_hat = _idct2(weight_upd)\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\n temp_W = np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\n\n # Update the weights\n temp_W = np.reshape(temp_W,(img_width, img_height, img_3d))\n temp_W = np.mean(temp_W,2)\n weight_upd = weight_upd + _dct2(temp_W)\n weight_upd = np.max(np.reshape(weight_upd - options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0) + np.min(np.reshape(weight_upd + options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0)\n W_idct_hat = _idct2(weight_upd)\n\n # Calculate the flatfield using updated weights\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\n\n # Determine the error\n E1 = E1 + np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\n E1 = np.max(np.reshape(E1 - options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0) + np.min(np.reshape(E1 + options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0)\n\n # Calculate the flatfield coefficients by subtracting the errors from the original data\n R1 = imgflt_stack-E1\n A_coeff = np.reshape(np.mean(R1,0)/np.mean(R1),(1, img_3d))\n A_coeff[A_coeff<0] = 0 # pixel values should never be negative\n\n # Calculate the darkfield component if specified by the user\n if options['darkfield']:\n # Get images with predominantly background pixels\n validA1coeff_idx = np.argwhere(A_coeff<1)[:,1]\n R1_upper = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)).astype(np.float64)>(np.float64(np.mean(W_idct_hat))-np.float64(10**-5)))[:,0],:]\n R1_upper = np.mean(R1_upper[:,validA1coeff_idx],0)\n R1_lower = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1))<np.mean(W_idct_hat)+np.float64(10**-5))[:,0],:]\n R1_lower = np.mean(R1_lower[:,validA1coeff_idx],0)\n B1_coeff = (R1_upper-R1_lower)/np.mean(R1)\n k = validA1coeff_idx.size\n\n # Calculate the darkfield offset\n temp1 = np.sum(np.square(A_coeff[0,validA1coeff_idx]))\n temp2 = np.sum(A_coeff[0,validA1coeff_idx])\n temp3 = np.sum(B1_coeff)\n temp4 = np.sum(A_coeff[0,validA1coeff_idx]*B1_coeff)\n temp5 = temp2 * temp3 - k*temp4\n if temp5 == 0:\n B1_offset = np.float64(0)\n else:\n B1_offset = (temp1*temp3-temp2*temp4)/temp5\n B1_offset = np.max(B1_offset,initial=0)\n B1_offset = np.min(B1_offset,initial=B1_uplimit/(np.mean(W_idct_hat)+10**-7))\n B_offset = B1_offset * np.mean(W_idct_hat) - B1_offset*np.reshape(W_idct_hat,(-1,1))\n\n # Calculate darkfield\n A1_offset = np.reshape(np.mean(R1[:,validA1coeff_idx],1),(-1,1)) - np.mean(A_coeff[0,validA1coeff_idx]) * np.reshape(W_idct_hat,(-1,1))\n A1_offset = A1_offset - np.mean(A1_offset)\n A_offset = A1_offset - np.mean(A1_offset) - B_offset\n\n # Update darkfield weights\n W_offset = _dct2(np.reshape(A_offset,(img_width, img_height)))\n W_offset = np.max(np.reshape(W_offset - options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0) \\\n + np.min(np.reshape(W_offset + options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0)\n\n # Calculate darkfield based on updated weights\n A_offset = _idct2(W_offset)\n A_offset = np.reshape(A_offset,(-1,1))\n A_offset = np.max(np.reshape(A_offset - options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0) \\\n + np.min(np.reshape(A_offset + options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0)\n A_offset = A_offset + B_offset\n\n # Loss\n Z1 = imgflt_stack - A - E1\n\n # Update weight regularization term\n Y1 = Y1 + mu*Z1\n\n # Update learning rate\n mu = np.min(mu*rho,initial=mu_bar)\n\n # Stop if loss is below threshold\n stopCriterion = np.linalg.norm(Z1,ord='fro')/d_norm\n if stopCriterion < options['optimization_tol'] or iternum > options['max_iterations']:\n converged = True\n\n # Calculate final darkfield image\n A_offset = A_offset + B1_offset * np.reshape(W_idct_hat,(-1,1))\n\n return A,E1,A_offset","def selection_correction_method1_v2(tree, scale, h_in, h_out):\n #h_in = ROOT.TH1D(\"h_in\", \"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\", 50, 0, 25)\n #h_out = ROOT.TH1D(\"h_out\", \"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\", 50, 0, 25)\n for event in tree:\n cut = [0, 0]\n S15_ch = i_channel(0, event)\n bpm_ch = i_channel(4, event)\n RT = event.DD_Rise[S15_ch]\n S15_w2 = event.DD_AmplADU[S15_ch]\n onset = event.DD_Rise10pct[S15_ch]\n if cut[0]==0:\n # first cut: for inside onset window\n # if event passes the first cuts\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n # calculation of the time of flight\n tof = (cfd_pmt-cfd_bpm)%400\n #cut on tof: time of flight of the neutron\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n # fill histogram inside onset window\n h_in.Fill(energy2)\n cut[0]=1\n break\n if cut[1]==0:\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n tof = (cfd_pmt-cfd_bpm)%400\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n h_out.Fill(energy2)\n cut[1]=1\n break","def CheckCouplings(params, verbose=False):\n l1 = params[0]\n l2 = params[1]\n l3 = params[2]\n gx = params[3]\n m = model_2f(l1, l2, l3, y_t_interpol(np.log(v/mz)), gx)\n minima, success = m.findMinimum() #the boolean success is added because we cannot trust the minima if numpy.optimize.minimize has failed\n if not verbose:\n tolvevh = 2.0\n tolmh = 2.0\n condition0 = abs(minima-v) < tolvevh\n if condition0.any() and success:\n ddVtot = nd.Hessian(m.Vtot_0T)\n hess = ddVtot(minima)\n masses = np.linalg.eigvalsh(hess) #computes masses...\n positive_condition = masses > 0\n if(positive_condition.all()): #we will only check them IF they are positive\n masses = np.sqrt(np.abs(masses))\n condition1 = abs(masses-mh) < tolmh\n if condition1.any():\n stability = m.CheckStability() #we check the stability of the model\n f = open(file_name, 'a')\n line0 = str(l1)+' '+str(l2)+' '+str(l3)+' '+str(gx)+' '+str(minima[0])+' '+str(minima[1])+' '+str(masses[0])+' '+str(masses[1]) #we print everything\n line0 = line0 + ' '+str(stability)\n f.write(line0+'\\n')\n f.write('-'*90+'\\n')\n f.close()\n else:\n \"\"\"\n Just checks the minima of the model m, the masses of the particles and whether it is stable or not\n Output: prints the information\n \"\"\"\n print \"Minimum at T = 0.0: \", minima, success\n print \"Masses: \"\n ddVtot = nd.Hessian(m.Vtot_0T)\n hess = ddVtot(minima)\n print np.sqrt(np.linalg.eigvalsh(hess))\n print 'Stable: ', m.CheckStability()==1","def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\n\n\n obj_lss = np.zeros(max_iter)\n x_zs = np.zeros(max_iter)\n u_norms = np.zeros(max_iter)\n times = np.zeros(max_iter)\n\n ATy = AT_fun(y)\n x_shape = ATy.shape\n d = np.prod(x_shape)\n\n def A_cgs_fun(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x)) + alpha * x\n return vec(y)\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\n\n def compute_p_inv_A(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n\n def A_cgs_fun_init(x):\n x = np.reshape(x, x_shape, order='F')\n y = AT_fun(A_fun(x))\n return vec(y)\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\n\n def compute_init(b, z0):\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\n if info > 0:\n print('cgs convergence to tolerance not achieved')\n elif info <0:\n print('cgs gets illegal input or breakdown')\n z = np.reshape(z, x_shape, order='F')\n return z\n\n # initialize z and u\n z = compute_init(ATy, ATy)\n u = np.zeros(x_shape)\n\n\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\n\n\n start_time = timeit.default_timer()\n\n for iter in range(max_iter):\n\n # x-update\n net_input = z+u\n Wzu, wbook = wavelet_transform(net_input)\n q = soft_threshold(Wzu, lambda_l1/alpha)\n x = inverse_wavelet_transform(q, wbook, x_shape)\n x = np.reshape(x, x_shape)\n\n # z-update\n b = ATy + alpha * (x - u)\n z = compute_p_inv_A(b, z)\n\n # u-update\n u += z - x;\n\n if show_img_progress == True:\n\n fig = plt.figure('current_sol')\n plt.gcf().clear()\n fig.canvas.set_window_title('iter %d' % iter)\n plt.subplot(1,3,1)\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('x')\n plt.subplot(1,3,2)\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('z')\n plt.subplot(1,3,3)\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\n plt.title('netin')\n plt.pause(0.00001)\n\n\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\n x_z = np.sqrt(np.mean(np.square(x-z)))\n u_norm = np.sqrt(np.mean(np.square(u)))\n\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\n\n\n obj_lss[iter] = obj_ls\n x_zs[iter] = x_z\n u_norms[iter] = u_norm\n times[iter] = timeit.default_timer() - start_time\n\n if x_z < solver_tol:\n break\n\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\n 'max_iter':max_iter, 'solver_tol':solver_tol}\n\n\n return (x, z, u, infos)","def _lp_msne(self, self_support, opponent_support, player=1):\n\n # logging.info(f'_lp_msne for player {player}')\n ns, U = len(self.s[player % 2]), self.U[player-1]\n if player != 1:\n U = U.T\n\n f, support_u = np.array([0.0 for _ in range(ns+1)]), U[np.where(self_support == 1)]\n\n a_temp = np.array([[0.] if i == 0 else [-1.] for i in range(support_u.shape[0]+1)])\n Aeq = np.concatenate([a_temp, np.concatenate([np.ones((1, support_u.shape[1])), support_u], axis=0)], axis=1)\n Beq = np.array([[1.] if i == 0 else [0.] for i in range(Aeq.shape[0])])\n # logging.info(f'Aeq: {Aeq}, {Aeq.shape}')\n # logging.info(f'Beq: {Beq}, {Beq.shape}')\n\n si_0 = np.where(self_support == 1)[0][0]\n not_support = U[np.where(self_support == 0)]\n # logging.info(f'not_support: {not_support}, {not_support.shape}')\n\n Aub = not_support - U[[si_0], :]\n Aub = np.concatenate([np.zeros((Aub.shape[0], 1)), Aub], axis=1)\n Bub = np.zeros((Aub.shape[0], 1))\n # logging.info(f'Aub: {Aub}, {Aub.shape}')\n # logging.info(f'Bub: {Bub}, {Bub.shape}')\n\n if not_support.shape[0] == 0 or not_support.shape[1] == 0:\n Aub, Bub = None, None\n\n p_bounds = np.array([(zero_p, one_m) for _ in range(ns)])\n p_bounds[np.where(opponent_support == 0)] = (0, 0)\n\n return linprog(f, A_ub=Aub, b_ub=Bub, A_eq=Aeq, b_eq=Beq, bounds=[(None, None), *p_bounds], method='simplex')","def crossing_minimization(self):\n self.layer_sweep()","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 _optimise(self):\n pass","def auxminrho2(x,m_ind):\n \n f = 0.0\n for k_ind in range(cfg.nomax):\n f -= auxmin_cc_piece(x,k_ind,m_ind) \n\n return f","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 l2Min(A, b):\n #set up the matrices\n solvers.options['show_progress'] = False\n m,n = A.shape\n Q = matrix(2*np.eye(n))\n r = matrix(np.zeros(n))\n A = matrix(A.astype(float))\n b = matrix(b.astype(float))\n #solve the matrices\n sol=solvers.qp(Q, r,A=A,b=b)\n return np.ravel(sol['x']), sol['primal objective']","def second_heuristic(self):\r\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\r\n # aceasta matrice indica valoarea pe care o are mutarea unei piese pe o celula aleasa\r\n # se va aduna la media ponderilor adunate in lista weights\r\n\r\n # mijlocul tablei este punctul cel mai vulnerabil\r\n # in timp ce lateralele sunt sigure,iar linia bazei transforma piesa in rege\r\n\r\n points = [[0, 4, 0, 4, 0, 4, 0, 4],\r\n [4, 0, 3, 0, 3, 0, 3, 0],\r\n [0, 3, 0, 2, 0, 2, 0, 4],\r\n [4, 0, 2, 0, 1, 0, 3, 0],\r\n [0, 3, 0, 1, 0, 2, 0, 4],\r\n [4, 0, 2, 0, 1, 0, 3, 0],\r\n [0, 3, 0, 2, 0, 2, 0, 4],\r\n [4, 0, 4, 0, 4, 0, 4, 0]]\r\n\r\n weights = [0 for i in range(4)]\r\n whites, blacks = 0, 0\r\n for i in range(8):\r\n for j in range(8):\r\n\r\n # numaram discurile de fiecare culoarea\r\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\r\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\r\n\r\n if self.matrix[i][j] in [self.current_player, self.current_player.upper()]:\r\n\r\n # daca e piesa normala\r\n if self.matrix[i][j] == self.current_player:\r\n weights[0] += 4\r\n\r\n # cat de aproape este piesa de a deveni rege ( nr de linii din tabla - cate mai are pana ajunge pe ultima linie)\r\n\r\n # cu cat se apropie piesa mai multe de a deveni rege, scorul creste( negru - rege pentru i=0, alb -rege pentru i =7)\r\n if self.matrix[i][j] == 'n':\r\n weights[1] += (7 - i)\r\n elif self.matrix[i][j] == 'a':\r\n weights[1] += i\r\n else:\r\n # daca e piesa rege\r\n weights[0] += 8\r\n\r\n # cat de aproape este piesa rege de celelalte piese\r\n for d in directions:\r\n if self.matrix[i][j] == self.current_player.upper():\r\n # gaseste pe diagonala in directia d, o piesa adversara,daca exista\r\n x, y = self.find_piesa(i, j, d)\r\n if x and y:\r\n weights[2] += (x - i) * (x - i) + (y - j) * (y - j)\r\n vx = d[0] + i\r\n vy = d[1] + j\r\n back_x = i - d[0]\r\n back_y = j - d[1]\r\n next_x, next_y = vx + d[0], vy + d[1]\r\n # piesele pe care le poate captura jucatorul, daca e piesa rege are un scor mai mare\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\r\n if self.matrix[next_x][next_y] == self.opponent().upper():\r\n weights[3] += 7\r\n else:\r\n weights[3] += 4\r\n # piese care pot fi capturate; la fel daca este piesa rege atunci se scade mai mult scorul\r\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\r\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\r\n if self.matrix[vx][vy] == self.opponent().upper():\r\n weights[3] -= 6\r\n else:\r\n weights[3] -= 3\r\n # adunam piesa la media sumei date pentru a face AI-ul in caz de egalitate a scorului\r\n # sa imi aleaga piesa care ma pozitioneaza mai bine\r\n if self.move:\r\n return sum(weights) / 4 + points[self.move[0]][self.move[1]]\r\n return sum(weights) / 4\r\n\r\n def __str__(self):\r\n s = ' '\r\n for i in range(8):\r\n s += str(i) + ' '\r\n s += '\\n'\r\n for index, line in enumerate(self.matrix):\r\n s += str(chr(index + ord('a'))) + ' '\r\n for el in line:\r\n s += str(el) + ' '\r\n s += '\\n'\r\n\r\n return s","def weber_MS(I,J,x,y,w):\n M = max([((x[i]-x[j])**2 + (y[i]-y[j])**2) for i in I for j in I])\n model = Model(\"weber - multiple source\")\n X,Y,v,u = {},{},{},{}\n xaux,yaux,uaux = {},{},{}\n for j in J:\n X[j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"X(%s)\"%j)\n Y[j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"Y(%s)\"%j)\n for i in I:\n v[i,j] = model.addVar(vtype=\"C\", name=\"v(%s,%s)\"%(i,j))\n u[i,j] = model.addVar(vtype=\"B\", name=\"u(%s,%s)\"%(i,j))\n xaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"xaux(%s,%s)\"%(i,j))\n yaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"yaux(%s,%s)\"%(i,j))\n uaux[i,j] = model.addVar(vtype=\"C\", name=\"uaux(%s,%s)\"%(i,j))\n\n\n\n for i in I:\n model.addCons(quicksum(u[i,j] for j in J) == 1, \"Assign(%s)\"%i)\n for j in J:\n model.addCons(xaux[i,j]*xaux[i,j] + yaux[i,j]*yaux[i,j] <= v[i,j]*v[i,j], \"MinDist(%s,%s)\"%(i,j))\n model.addCons(xaux[i,j] == (x[i]-X[j]), \"xAux(%s,%s)\"%(i,j))\n model.addCons(yaux[i,j] == (y[i]-Y[j]), \"yAux(%s,%s)\"%(i,j))\n model.addCons(uaux[i,j] >= v[i,j] - M*(1-u[i,j]), \"uAux(%s,%s)\"%(i,j))\n\n model.setObjective(quicksum(w[i]*uaux[i,j] for i in I for j in J), \"minimize\")\n\n\n model.data = X,Y,v,u\n return model","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 auxmin_cc_piece(x,k_ind,m_ind):\n \n # Adding new linear function as a last function:\n # The first line. If jk = 1 and k_ind = nomax, this is a new line, otherwise an old one.\n line_start=cfg.nfea*sum(cfg.jk[i] for i in range(k_ind))\n #print line_start,cfg.jk,k_ind,cfg.nomax-1,cfg.jk[k_ind], cfg.xprev,x\n if cfg.jk[k_ind]==1 and k_ind==cfg.nomax-1:\n #print \"hihu0\"\n f_cc=np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\n return f_cc\n else:\n #print \"hihu1\",line_start,k_ind\n f_cc=np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\n if cfg.jk[k_ind]==1:\n return f_cc\n \n # Next lines\n line_start += cfg.nfea\n for j in range(1,cfg.jk[k_ind]-1): # Everything but the first and last.\n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n \n # Minimum of lines\n if f_tmp <= f_cc:\n f_cc = f_tmp\n cfg.min_line[k_ind,m_ind] = j\n line_start += cfg.nfea\n \n # The last line.\n if k_ind==cfg.nomax-1:\n #print \"hihu3\"\n f_tmp = np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\n else: \n \n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\n \n # Minimum of lines\n if f_tmp <= f_cc:\n f_cc = f_tmp\n cfg.min_line[k_ind,m_ind] = cfg.jk[k_ind]-1 \n\n return f_cc","def getAbsNormalizationFactor(deltaE_wkspace,min,max):\n global reducer\n van_mass=reducer.get_default_parameter('vanadium-mass') \n \n Integration(InputWorkspace=deltaE_wkspace,OutputWorkspace='van_int',RangeLower=min,RangeUpper=max,IncludePartialBins='1')\n input_ws = mtd[deltaE_wkspace]\n ei_monovan = input_ws.getRun().getLogData(\"Ei\").value\n data_ws=mtd['van_int']\n nhist = data_ws.getNumberHistograms()\n #print nhist\n\n signal1_sum = 0.0\n weight1_sum = 0.0 \n signal2_sum = 0.0\n weight2_sum = 0.0 \n signal3_sum = 0.0\n weight3_sum = 0.0 \n signal4_sum = 0.0\n weight4_sum = 0.0 \n\n \n ic=0;\n izerc=0;\n for i in range(nhist):\n try:\n det = data_ws.getDetector(i)\n except Exception:\n continue\n if det.isMasked():\n continue\n\n signal = data_ws.readY(i)[0]\n error = data_ws.readE(i)[0]\n \n if signal != signal: #ignore NaN\n continue\n if ((error<=0) or (signal<=0)): # ignore Inf (0 in error are probably 0 in sign\n izerc+=1\n continue\n # Guess which minimizes the value sum(n_i-n)^2/Sigma_i -- this what Libisis had\n weight = 1.0/error\n signal1_sum += signal * weight\n weight1_sum += weight \n # Guess which minimizes the value sum(n_i-n)^2/Sigma_i^2\n weight2 = 1.0/(error*error)\n signal2_sum += signal * weight2\n weight2_sum += weight2 \n # Guess which assumes puassonian distribution with Err=Sqrt(signal) and calculates \n # the function: N_avrg = 1/(DetEfficiency_avrg^-1)*sum(n_i*DetEfficiency_i^-1)\n # where the DetEfficiency = WB_signal_i/WB_average WB_signal_i is the White Beam Vanadium \n # signal on i-th detector and the WB_average -- average WB vanadium signal. \n # n_i is the modified signal \n err_sq = error*error\n weight = err_sq/signal\n signal3_sum += err_sq\n weight3_sum += weight\n # Guess which estimatnes value sum(n_i^2/Sigma_i^2)/sum(n_i/Sigma_i^2) TGP suggestion from 12-2012\n signal4_sum += signal*signal/err_sq\n weight4_sum += signal/err_sq\n \n ic += 1 \n #print 'signal value =' ,signal\n #print 'error value =' ,error \n #print 'average ',signal_sum \n #---------------- Loop finished\n \n if( weight1_sum==0.0 or weight2_sum == 0.0 or weight3_sum == 0.0 or weight4_sum == 0.0) :\n print \"WB integral has been calculated incorrectrly, look at van_int workspace and input workspace: \",deltaE_wkspace\n raise IOError(\" divided by 0 weight\")\n \n integral_monovanLibISIS=signal1_sum / weight1_sum\n integral_monovanSigSq =signal2_sum / weight2_sum \n integral_monovanPuason =signal3_sum / weight3_sum \n integral_monovanTGP =signal4_sum / weight4_sum\n #integral_monovan=signal_sum /(wbVan_sum)\n van_multiplier = (float(reducer.van_rmm)/float(van_mass))\n absnorm_factorLibISIS = integral_monovanLibISIS * van_multiplier\n absnorm_factorSigSq = integral_monovanSigSq * van_multiplier \n absnorm_factorPuason = integral_monovanPuason * van_multiplier \n absnorm_factorTGP = integral_monovanTGP * van_multiplier \n #print 'Monovan integral :' ,integral_monovan \n \n if ei_monovan >= 210.0: \n xsection = 421 # vanadium cross-section in mBarn/sR (402 mBarn/Sr) (!!!modified to fit high energy limit?!!!)\n else: # old textbook cross-section for vanadium for ei=20mEv\n xsection = 400 + (ei_monovan/10) \n\n absnorm_factorLibISIS /= xsection\n absnorm_factorSigSq /= xsection \n absnorm_factorPuason /= xsection \n absnorm_factorTGP /= xsection \n \n sample_multiplier = (float(reducer.sample_mass)/float(reducer.sample_rmm))\n absnorm_factorLibISIS= absnorm_factorLibISIS *sample_multiplier\n absnorm_factorSigSq = absnorm_factorSigSq *sample_multiplier\n absnorm_factorPuason = absnorm_factorPuason *sample_multiplier\n absnorm_factorTGP = absnorm_factorTGP *sample_multiplier\n \n if (absnorm_factorLibISIS !=absnorm_factorLibISIS)|(izerc!=0): # It is an error, print diagnostics:\n if (absnorm_factorLibISIS !=absnorm_factorLibISIS):\n print '--------> Absolute normalization factor is NaN <----------------------------------------------'\n else:\n print '--------> Warning, Monovanadium has zero spectra <--------------------------------------------' \n print '--------> Processing workspace: ',deltaE_wkspace\n print '--------> Monovan Integration range : min=',min,' max=',max\n print '--------> Summarized: ',ic,' spectra with total value: ',signal2_sum, 'and total weight: ',weight2_sum\n print '--------> Dropped: ',izerc,' empty spectra'\n print '--------> Van multiplier: ',van_multiplier,' sample multiplier: ',sample_multiplier, 'and xsection: ',xsection \n print '--------> Abs norm factors: LibISIS: ',absnorm_factorLibISIS,' Sigma^2: ',absnorm_factorSigSq\n print '--------> Abs norm factors: Puasonian: ',absnorm_factorPuason, ' TGP: ',absnorm_factorTGP\n print '----------------------------------------------------------------------------------------------' \n else:\n DeleteWorkspace(Workspace=deltaE_wkspace)\n DeleteWorkspace(Workspace=data_ws)\n return (absnorm_factorLibISIS,absnorm_factorSigSq,absnorm_factorPuason,absnorm_factorTGP)","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 cvstem(self):\n if (self.iEC == \"est\") and (len(sig(self.Cfun).parameters) == 1):\n fun1 = self.Cfun\n self.Cfun = lambda x,p: fun1(x)\n if (self.iEC == \"est\") and (len(sig(self.Gw).parameters) == 1):\n fun2 = self.Gw\n self.Gw = lambda x,p: fun2(x)\n if self.iEC == \"est\":\n self.c_over = self.matrix_2bound(self.Cfun)\n self.g_over = self.matrix_2bound(self.Gw)\n if (len(sig(self.Bw).parameters) == 1):\n fun3 = self.Bw\n self.Bw = lambda x,p: fun3(x)\n self.b_over = self.matrix_2bound(self.Bw)\n self.linesearch()\n alp = self.alp_opt\n Nx = self.Nx\n Nsplit = 1\n Np = int(Nx/Nsplit)\n Nr = np.remainder(Nx,Nsplit)\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\n Nxp = self.n+self.n_p\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\n Ws_opt = []\n chi_opt = 0\n nu_opt = 0\n print(\"========================================================\")\n print(\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\")\n print(\"========================================================\")\n for p in range(Np):\n if np.remainder(p,int(Np/10)) == 0:\n print(\"# sampled metrics: \",p*Nsplit,\"...\")\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n if Nr != 0:\n print(\"# samples metrics: \",Nx,\"...\")\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n self.xs_opt = xs_opt\n self.ps_opt = ps_opt\n self.Ws_opt = Ws_opt\n self.chi_opt = chi_opt\n self.nu_opt = nu_opt\n if self.iEC == \"est\":\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\n print(\"Optimal steady-state estimation error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n elif self.iEC == \"con\":\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\n print(\"Optimal steady-state tracking error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n else:\n raise ValueError('Invalid iEC: iEC = \"est\" or \"con\"')\n self.M2cholM()\n path = \"models/optvals/\"+self.fname\n if os.path.exists(path) == False:\n try:\n os.makedirs(path)\n except: \n raise OSError(\"Creation of directory %s failed\" %path)\n else:\n print (\"Successfully created directory %s \" %path)\n else:\n print (\"Directory %s already exists\" %path)\n np.save(path+\"/alp_opt.npy\",alp)\n np.save(path+\"/chi_opt.npy\",self.chi_opt)\n np.save(path+\"/nu_opt.npy\",self.nu_opt)\n np.save(path+\"/Jcv_opt.npy\",self.Jcv_opt)\n print(\"========================================================\")\n print(\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\")\n print(\"========================================================\\n\\n\")\n pass","def inference(self):\n logging.info('RandomizeMincut inference')\n\n perturbation_num = 4\n noise_rate = 0.3\n noise_range = (-0.6, 0.4)\n base_adj_matrix = copy.deepcopy(self._graph.get_adjacency('weight').data)\n base_adj_matrix = np.array(base_adj_matrix)[:-2, :-2] # remove pseudo vertices\n vertices_number = self._graph.vcount()\n y = [] # list of return results\n\n # basic mincut first\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\n [positive_label, _] = self._cut.partition\n\n # ignore this cut if it has unbalance separation\n if len(positive_label) > 0.06 * vertices_number or \\\n len(positive_label) < 0.94 * vertices_number:\n labels = np.zeros(vertices_number) # re-construct y\n labels[positive_label] = 1\n y.append(labels[:-1]) # omit v_plus\n\n for _ in range(perturbation_num):\n # init noise\n noise_decision = np.random.binomial(\n n=1,\n p=noise_rate,\n size=base_adj_matrix.shape\n )\n noise_value = np.random.uniform(\n low=noise_range[0],\n high=noise_range[1],\n size=base_adj_matrix.shape\n )\n noise_value = noise_decision * noise_value\n\n # add noise\n noise_weight = np.triu(base_adj_matrix + noise_value) # only get upper triangle\n self._graph.es['weight'] = noise_weight[noise_weight.nonzero()]\n\n # find mincut\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\n [positive_label, _] = self._cut.partition\n\n # ignore this cut if it has unbalance separation\n if len(positive_label) < 0.06*vertices_number or \\\n len(positive_label) > 0.94*vertices_number:\n continue\n\n labels = np.zeros(vertices_number) # re-construct y\n labels[positive_label] = 1\n y.append(labels[:-1]) # omit v_plus\n\n self._graph.delete_vertices([self._v_minus, self._v_plus])\n vote = np.array(y).sum(axis=0) # if sum > cases//2: label 1, else label 0\n self._graph.vs['label'] = (vote > len(y)//2).astype(int)","def dual_objective_expression_rule(_m):\r\n\r\n # Build limits\r\n t_1 = sum(- (m.mu_2[z, y] * m.SOLAR_BUILD_LIMITS[z]) - (m.mu_3[z, y] * m.WIND_BUILD_LIMITS[z]) - (\r\n m.mu_4[z, y] * m.STORAGE_BUILD_LIMITS[z]) for z in m.Z for y in m.Y)\r\n\r\n # Min power output\r\n t_2 = sum(\r\n m.sigma_1[g, y, s, t] * m.P_MIN[g] for g in m.G.difference(m.G_STORAGE) for y in m.Y for s in m.S for t\r\n in m.T)\r\n\r\n # Max power - existing generators\r\n t_3 = sum(\r\n - m.sigma_2[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_THERM for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Max power - existing wind\r\n t_4 = sum(\r\n - m.sigma_4[g, y, s, t] * m.Q_W[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_WIND for y in\r\n m.Y for s in m.S for t in m.T)\r\n\r\n # Max power - existing solar\r\n t_5 = sum(\r\n - m.sigma_6[g, y, s, t] * m.Q_S[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_SOLAR for y in\r\n m.Y for s in m.S for t in m.T)\r\n\r\n # Max power - existing hydro\r\n t_6 = sum(\r\n - m.sigma_8[g, y, s, t] * m.P_H[g, y, s, t] * (1 - m.F[g, y]) for g in m.G_E_HYDRO for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max charging power - existing storage\r\n t_7 = sum(\r\n - m.sigma_11[g, y, s, t] * m.P_IN_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max discharging power - existing storage\r\n t_8 = sum(\r\n - m.sigma_13[g, y, s, t] * m.P_OUT_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max energy - existing storage units\r\n t_9 = sum(\r\n - m.sigma_16[g, y, s, t] * m.Q_MAX[g] for g in m.G_E_STORAGE for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Min energy - interval end\r\n t_10 = sum(m.sigma_18[g, y, s] * m.Q_END_MIN[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n # Max energy - interval end\r\n t_11 = sum(- m.sigma_19[g, y, s] * m.Q_END_MAX[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n # Ramp-up constraint - generators\r\n t_12 = sum(\r\n - m.sigma_20[g, y, s, t] * m.RR_UP[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Ramp-up constraint - initial power output - generators\r\n t_13 = sum(\r\n - m.sigma_20[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y\r\n for s in m.S)\r\n\r\n # Ramp-down constraint - generators\r\n t_18 = sum(\r\n - m.sigma_23[g, y, s, t] * m.RR_DOWN[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Ramp-down constraint - initial power output - generators\r\n t_19 = sum(\r\n m.sigma_23[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for\r\n s in m.S)\r\n\r\n # Min powerflow\r\n t_24 = sum(m.sigma_27[l, y, s, t] * m.POWERFLOW_MIN[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Max powerflow\r\n t_25 = sum(\r\n - m.sigma_28[l, y, s, t] * m.POWERFLOW_MAX[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Demand\r\n t_26 = sum(m.lamb[z, y, s, t] * m.DEMAND[z, y, s, t] for z in m.Z for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Initial storage unit energy\r\n t_27 = sum(m.zeta_1[g, y, s, m.T.first()] * m.Q0[g, y, s] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n return (t_1 + t_2 + t_3 + t_4 + t_5 + t_6 + t_7 + t_8 + t_9 + t_10 + t_11 + t_12 + t_13 + t_18 + t_19 + t_24\r\n + t_25 + t_26 + t_27)","def method1(self):\n cres=0. # Variable for storing Chern number.\n # The U matrices from Fukui's method; storage...\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n # ... and calculation of U matrices\n for ix in range(self.kS.Nx+1):\n for iy in range(self.kS.Ny+1):\n mat1=self.alleigvecs[:,:,ix ,iy ]\n if ix<self.kS.Nx:\n mat2=self.alleigvecs[:,:,ix+1,iy ]\n else:\n mat2=self.alleigvecs[:,:,1 ,iy ]\n if iy<self.kS.Ny:\n mat3=self.alleigvecs[:,:,ix ,iy+1]\n else:\n mat3=self.alleigvecs[:,:,ix ,1 ]\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\n \n # Local estimates of Berry curvature; storage ...\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\n # ... and calculation\n for ix in range(self.kS.Nx):\n for iy in range(self.kS.Ny):\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\n\n return cres.real, ftempall","def test_solver1c(N, version='scalar'):\n def I(x): return sin(2*x*pi/L)\n def f(x, t): return 0\n\n class Action:\n def __init__(self):\n self.solutions = []\n self.time_level_counter = 0\n\n def __call__(self, u, x, t):\n if self.time_level_counter % N == 0:\n self.solutions.append(u.copy())\n self.time_level_counter += 1\n\n action = Action()\n n = 100; tstop = 6; L = 10\n dt, x, cpu = solver(I, f, 1.0, lambda t: 0, lambda t: 0,\n L, n, 0, tstop,\n user_action=action, version=version)\n print 'CPU time:', cpu\n print 'Max value in final u:', arrmax(action.solutions[-1])","def optimize_fore(self):\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\n \n self.l2 = torch.from_numpy(self.u).float()\n print('self u shape',self.l2.shape)\n self.n = torch.randn(32, 1, 28, 28)\n self.l1 = self.enc(self.input + self.n)\n self.del1=self.dec(self.l1)\n self.del2=self.dec(self.l2)\n self.update_netc()\n self.update_netd()\n\n self.update_l2()\n self.update_netg()\n print('sssssssssssssssssssssss')","def front_column_model_p_gain():","def _para_boosting(self, H):\n # print '----------------primal-dual boost-------------------'\n H = np.hstack((H, -H))\n # H_ft = np.asfortranarray((H.copy()))\n (n, p) = H.shape\n self.c = np.log(n*p)\n nu = int(n * self.ratio)\n\n if self.max_iter < 50:\n delta = 1\n else:\n delta = 40\n d = np.ones(n) / n\n d_bar = np.ones(n) / n\n a_bar = np.ones(p) / p\n a = np.ones(p) / p\n h_a = np.sum(H, axis=1) / p\n h_a_bar = h_a.copy()\n # a_bar = a\n # a_tilde = np.ones(p) / p\n h_a_tilde = h_a.copy()\n # d_tilde = np.zeros(p)\n theta = 1\n sig = 1\n tau = 1\n t = 0\n logscale = 0\n for t in range(self.max_iter):\n d = prox_mapping(h_a_tilde, d, tau, 2)\n if self.has_dcap:\n d2 = proj_cap_ent(d, 1.0 / nu)\n # d_new = d_new/d_new.sum()\n if np.abs(d.sum() - d2.sum()) > 0.0001:\n print 'error'\n d = d2\n d_tilde = d\n dtH = np.dot(d_tilde, H)\n # dtH = np.dot(H.T, d_tilde)\n a_new = prox_mapping(-dtH, a, sig, 2)\n h_a_new = np.dot(H, a_new)\n # a_tilde = a_new + theta * (a_new - a)\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\n a = a_new\n h_a = h_a_new\n d_bar *= t / (t + 1.0)\n d_bar += 1.0 / (t + 1) * d\n a_bar *= t / (t + 1.0)\n a_bar += 1.0 / (t + 1) * a\n # h_a_bar = np.dot(H, a_bar)\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\n if int(np.log(t+1)) == logscale:\n logscale += 1\n self.iter_num.append(t)\n if self.has_dcap:\n min_margin = ksmallest2(h_a_bar, nu)\n self.primal_obj.append(-np.mean(min_margin))\n else:\n self.primal_obj.append(- np.min(h_a_bar))\n self.margin.append(-self.primal_obj[-1])\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\n self.err_tr.append(np.mean(h_a_bar < 0))\n # if t % 100 == 0:\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\n if self.gap[-1] < self.epsi:\n break\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\n self.d = d_bar\n print \" pd-boosting(python): max iter#%d: , actual iter#%d\" % (self.max_iter, t)","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 solve_SVM_dual_SMO(x_train, y_train, x_test, C=1):\n n, d = x_train.shape[0], x_train.shape[1]\n alpha = np.zeros((n))\n count = 0\n while True:\n count += 1\n alpha_prev = np.copy(alpha)\n for j in range(0, n):\n # Getting random int i!=j\n i = j\n cnt=0\n while i == j and cnt<1000:\n i = rnd.randint(0,n-1)\n cnt=cnt+1\n x_i, x_j, y_i, y_j = x_train[i,:], x_train[j,:], y_train[i], y_train[j]\n k_ij = (np.dot(x_i, x_i.T)) + (np.dot(x_j, x_j.T) ) - (2 * np.dot(x_i, x_j.T))\n if k_ij <= 0:\n continue\n alpha_prime_j, alpha_prime_i = alpha[j], alpha[i]\n if(y_i != y_j):\n (L,H) = (max(0, alpha_prime_j - alpha_prime_i), min(C, C - alpha_prime_i + alpha_prime_j))\n else:\n (L,H) = (max(0, alpha_prime_i + alpha_prime_j - C), min(C, alpha_prime_i + alpha_prime_j))\n if(L==H):\n continue\n # Computing model parameters\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\n b = np.mean(y_train - np.dot(w.T, x_train.T))\n E_i = np.sign(np.dot(w.T, x_i.T) + b).astype(int) - y_i\n E_j = np.sign(np.dot(w.T, x_j.T) + b).astype(int) - y_j\n # Setting new alpha values(Lagrange multipliers)\n alpha[j] = alpha_prime_j + float(y_j * (E_i - E_j))/k_ij\n alpha[j] = max(alpha[j], L)\n alpha[j] = min(alpha[j], H)\n alpha[i] = alpha_prime_i + y_i*y_j * (alpha_prime_j - alpha[j])\n # Checking for convergence\n diff = np.linalg.norm(alpha - alpha_prev)\n if diff < 0.000000001:\n break\n # Computing weights and bias\n b = np.mean(y_train-np.dot(w.T,x_train.T))\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\n y_pred_test = (np.sign(np.dot(w.T, x_test.T) + b).astype(int))\n return (y_pred_test,alpha)","def buildObjective(self):\r\n\r\n # self.z_prior might be the modified version\r\n self.L_elbo = T.mean(self.reconst + self.conditional_prior + self.w_prior + self.z_prior)\r\n\r\n self.L_elbo_modif = T.mean(self.reconst + self.conditional_prior + self.w_prior_modif + self.z_prior_modif)\r\n\r\n #---Getting model parameter---#\r\n cg = ComputationGraph(self.L_elbo)\r\n #self.phi_theta is the list of all the parameters in q and p.\r\n self.params = VariableFilter(roles=[PARAMETER])(cg.variables)","def solve(self):\n start = timer()\n # encode into milp\n me = MILPEncoder(MILPSolver.prob,\n MILPSolver.params.logger.LOGFILE, \n MILPSolver.params.INTRA_DEP_CONSTRS,\n MILPSolver.params.INTER_DEP_CONSTRS)\n if MILPSolver.lp == True:\n gmodel = me.lp_encode()\n else:\n gmodel = me.encode()\n # Set gurobi parameters\n pgo = 1 if MILPSolver.params.PRINT_GUROBI_OUTPUT == True else 0\n gmodel.setParam('OUTPUT_FLAG', pgo)\n tl = MILPSolver.params.TIMEOUT\n if tl != -1 : gmodel.setParam('TIME_LIMIT', tl)\n if not MILPSolver.params.DEFAULT_CUTS: \n MILPSolver.disable_default_cuts(gmodel)\n gmodel._vars = gmodel.getVars()\n # set callback cuts \n MILPSolver.id_form = IdealFormulation(MILPSolver.prob,\n gmodel, \n MILPSolver.params.IDEAL_FREQ,\n MILPSolver.params.logger.LOGFILE)\n MILPSolver.dep_cuts = DepCuts(MILPSolver.prob,\n gmodel,\n MILPSolver.params.DEP_FREQ,\n MILPSolver.params.INTRA_DEP_CUTS,\n MILPSolver.params.INTER_DEP_CUTS,\n MILPSolver.sip_params,\n MILPSolver.params.logger.LOGFILE)\n # Optimise\n if MILPSolver.params.callback_enabled() and MILPSolver.lp == False:\n gmodel.optimize(MILPSolver._callback)\n else:\n gmodel.optimize()\n\n runtime = timer() - start\n cex = None \n if MILPSolver.status == SolveResult.BRANCH_THRESHOLD:\n result = SolveResult.BRANCH_THRESHOLD\n elif gmodel.status == GRB.OPTIMAL:\n cex_shape = MILPSolver.prob.spec.input_layer.input_shape\n cex = np.zeros(cex_shape)\n for i in itertools.product(*[range(j) for j in cex_shape]):\n cex[i] = MILPSolver.prob.spec.input_layer.out_vars[i].x\n result = SolveResult.UNSATISFIED\n elif gmodel.status == GRB.TIME_LIMIT:\n result = SolveResult.TIMEOUT\n elif gmodel.status == GRB.INTERRUPTED:\n result = SolveResult.INTERRUPTED\n elif gmodel.status == GRB.INFEASIBLE or gmodel.status == GRB.INF_OR_UNBD:\n result = SolveResult.SATISFIED\n else:\n result = SolveResult.UNKNOWN\n \n # MILPSolver.logger.info('Verification problem {} solved, '\n # 'LP: {}, '\n # 'time: {:.2f}, '\n # 'result: {}.'\n # .format(MILPSolver.prob.id,\n # MILPSolver.lp,\n # runtime,\n # result.value))\n \n return SolveReport(result, runtime, cex)","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 find_large_separation2(self):\n\n ind = (self.modes['l'] == 0).flat\n n = self.modes['n'].compress(ind)\n if (len(n) < 2): return np.nan\n freq = self.modes['freq'].compress(ind)\n coeff = np.polyfit(n,freq,1)\n return coeff[0]","def selection_correction_method1(tree, scale, h_in, h_out):\n #h_in = ROOT.TH1D(\"h_in\", \"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\", 50, 0, 25)\n #h_out = ROOT.TH1D(\"h_out\", \"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\", 50, 0, 25)\n for event in tree:\n cut = [0, 0]\n S15_ch = i_channel(0, event)\n bpm_ch = i_channel(4, event)\n RT = event.DD_Rise[S15_ch]\n S15_w2 = event.DD_AmplADU[S15_ch]\n onset = event.DD_Rise10pct[S15_ch]\n if cut[0]==0:\n # first cut: for inside onset window\n # if event passes the first cuts\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n # calculation of the time of flight\n tof = (cfd_pmt-cfd_bpm)%400\n #cut on tof: time of flight of the neutron\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n # fill histogram inside onset window\n h_in.Fill(energy2)\n cut[0]=1\n break\n if cut[1]==0:\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\n for n_channel in range(5, 16):\n pmt_i = i_channel(n_channel, event)\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\n tof = (cfd_pmt-cfd_bpm)%400\n if tof<335 and tof>295:\n energy2 = S15_w2*scale\n h_out.Fill(energy2)\n cut[1]=1\n break\n return h_in, h_out","def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \n tol=1e-2):\n from numpy import array, zeros_like, zeros\n from scipy.optimize import minimize\n from tgo import tgo\n \n def x_lim(X): # limiting function used in TGO\n import numpy\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\n \n if k == None:\n k = p.m['Valid phases']\n \n # Initialize\n Z_0 = array(Z_0)\n LBD = - 1e300 # -inf\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \n \n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\n UBD = g_x_func(s, p).m['g_mix']['t'] \n Lambda_d = zeros_like(Z_0)\n\n # X bounds used in UBD optimization\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\n zeros(shape=(p.m['n']-1)) # Lower bound\n ] \n for i in range(p.m['n']-1): \n Sigma_ind = 0.0 # Sum of independent components excluding i\n # (lever rule) \n for j in range(p.m['n']-1):\n if j != i:\n Sigma_ind += Z_0[j]\n\n X_bounds[0][i] = 1.0 - Sigma_ind \n \n # Construct physical bounds x \\in [0, 1] for all independent components\n # (used in differential_evolution)\n Bounds = []\n for i in range(p.m['n'] - 1):\n #Bounds.append((0, 1))\n Bounds.append((1e-5, 0.99999))\n \n # Construct composition container from X_d for all phases. (REMOVED)\n X_d = Z_0\n\n\n #%% Normal calculation of daul problem if Z_0 is unstable.\n while abs(UBD - LBD) >= tol:\n # Solve UBD\n # Update system to new composition.\n # (Comp. invariant in UBD)\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\n k))['x']\n \n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\n \n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\n\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\n g_func=x_lim,\n n = 100,\n skip=2)\n # Solve LBD \n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \n X_d = X_sol\n # End\n \n\n if False: # Print results optional\n print 'Final UBD = {}'.format(UBD)\n print 'Final LBD = {}'.format(LBD)\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\n print 'Final Z_eq = {}'.format(X_d)\n print 'Final Lambda_d = {}'.format(Lambda_d)\n \n # Returns\n s.m['Z_eq'] = X_d\n s.m['Lambda_d'] = Lambda_d\n return s","def combined_costs(matrix_MSLL_IO):\r\n return","def uncertainty_mm(self,m1,m2):\n # ID and isolation uncertainty (TO BE FIXED)\n unc = (self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')/self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')+ \\\n self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1')/self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1'))**2\n \n## # trigger (approximate) ==== FIXME!! ===============\n## hlt_sf_run2011_a_unc = (self._mu7TrgWeight [(m1.pt(),m1.eta())][1]/self._mu7TrgWeight [(m1.pt(),m1.eta())][0] + \\\n## self._mu7TrgWeight [(m2.pt(),m2.eta())][1]/self._mu7TrgWeight [(m2.pt(),m2.eta())][0])**2\n## hlt_sf_run2011_b_unc = (abs(self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_b_unc += ((self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_c_unc = (abs(self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## hlt_sf_run2011_c_unc += ((self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\n## unc += 0.002*hlt_sf_run2011_a_unc + 0.643*hlt_sf_run2011_b_unc + 0.024*hlt_sf_run2011_c_unc\n \n return sqrt(unc)","def prior_params_tree(self):\n id = {name:i for i, name in enumerate(list(self.tree.keys()))}\n n_nodes = len(id)\n dist_mx = np.zeros((n_nodes, n_nodes))\n\n for node1, edges in self.tree.items():\n for node2, dist in edges.dist:\n dist_mx[id[node1], id[node2]] = dist\n dist_mx[id[node2], id[node1]] = dist\n\n # while np.count_nonzero(dist_mx) < (n_nodes ** 2 - n_nodes):\n for _ in range(20):\n for i, j in combinations(range(n_nodes), 2):\n if dist_mx[i,j] > 0:\n continue\n row_i = dist_mx[i]\n row_j = dist_mx[j]\n value = (row_i + row_j) * (row_i > 0) * (row_j > 0)\n dist_mx[i, j] = dist_mx[j, i] = - max(np.unique(value))\n dist_mx = np.abs(dist_mx)\n\n evolve_rate = []\n for node1, node2 in combinations(self.m_cov.keys(), 2):\n mx_cov_dist = np.abs(self.m_cov[node1] - self.m_cov[node2])\n elements = mx_cov_dist[np.triu_indices(len(mx_cov_dist))]\n norm_elements = elements / dist_mx[id[node2], id[node1]]\n evolve_rate += list(norm_elements)\n\n\n\n df = np.mean([p.shape[0] for _, p in self.m_profiles.items()])\n p_theta_alpha = df/2\n # p_theta_alpha = 4\n p_theta_beta = np.percentile(evolve_rate, 75) * (p_theta_alpha - 1)\n # print(p_theta_alpha, p_theta_beta)\n return p_theta_alpha, p_theta_beta","def wigner_gaunt(l1, l2, m):\n pref = sqrt((2*l1 + 1)*(2*l2 + 1)/(4*pi))\n return np.array([pref*sqrt(2*lpp + 1)*float(wigner_3j(l1,l2,lpp,m,-m,0)*wigner_3j(l1,l2,lpp,0,0,0))\n for lpp in range(abs(l1-l2), l1+l2+1, 2)])","def w3j000(L, l, lp, Fks):\n\n J = L + l + lp \n if (J % 2 == 1) or (l + lp < L) or (np.abs(l - lp) > L):\n return 0.\n\n res = (-1)**(J/2) * (Fks[J/2 - L] * Fks[J/2 - l] * Fks[J/2 - lp]) / (Fks[J/2] * (J + 1.)**0.5)\n \n return res","def _post_process(self, nhops=10, style='entropy', minmax='min'): # pragma: no co ver\n from scipy.optimize import basinhopping\n\n sign = +1 if minmax == 'min' else -1\n\n if style == 'channel':\n def objective(x):\n return sign*self.channel_capacity(x)\n elif style == 'entropy':\n def objective(x):\n var = self.construct_joint(x).sum(axis=tuple(range(self._crv+1)))\n return sign*h(var)\n\n true_objective = self.objective(self._optima)\n\n def constraint_match_objective(x):\n obj = (self.objective(x) - true_objective)**2\n return obj\n\n def constraint_normalized(x):\n channel = x.reshape(self._crv_size, self._bound)\n return (channel.sum(axis=1) - 1).sum()**2\n\n minimizer_kwargs = {'method': 'SLSQP',\n 'bounds': [(0, 1)]*self._optima.size,\n 'constraints': [{'type': 'eq',\n 'fun': constraint_match_objective,\n },\n {'type': 'eq',\n 'fun': constraint_normalized,\n },\n ],\n }\n\n cb = BasinHoppingCallBack(minimizer_kwargs['constraints'])\n cb(self._optima, true_objective, True)\n\n res = basinhopping(func=objective,\n x0=self._optima.copy(),\n minimizer_kwargs=minimizer_kwargs,\n niter=nhops,\n callback=cb,\n accept_test=accept_test,\n )\n\n minimum = cb.minimum()\n if minimum is not None:\n self._optima = minimum","def auxminf2(x):\n # Sum over data points\n f = 0.0\n for m_ind in range(cfg.ntrain):\n f += auxminrho1(x,m_ind) + auxminrho2(x,m_ind) \n \n return f","def pro_avfid_superoperator_compsubspace(U,L1):\n\n if U.type=='oper':\n inner = U.dag()*U_target\n part_idx = [0, 1, 3, 4] # only computational subspace\n ptrace = 0\n for i in part_idx:\n ptrace += inner[i, i]\n dim = 4 # 2 qubits comp subspace \n\n return np.real(((np.abs(ptrace))**2+dim*(1-L1))/(dim*(dim+1)))\n\n elif U.type=='super':\n kraus_form = qtp.to_kraus(U)\n dim=4 # 2 qubits in the computational subspace\n part_idx = [0, 1, 3, 4] # only computational subspace\n psum=0\n for A_k in kraus_form:\n ptrace = 0\n inner = U_target_diffdims.dag()*A_k # otherwise dimension mismatch\n for i in part_idx:\n ptrace += inner[i, i]\n psum += (np.abs(ptrace))**2\n\n return np.real((dim*(1-L1) + psum) / (dim*(dim + 1)))","def ACmomentConstraint(p, var):\n \n #extract the polynomial and variables \n x = var[0]\n th = var[1]\n\n\n #Identify support set, prepare for polytope reduction\n #A_pre = np.array(P.monoms())\n #b = np.array(P.coeffs())\n \n # #function to generate parameter coefficients\n # if len(var) == 1:\n # fb = lambda p: p\n # else:\n # fb = sp.lambdify(x, b, \"numpy\")\n if type(p) == list:\n fout = extract_monom(var, p)\n else:\n fout = extract_monom(var,[p])\n fb = fout[\"fb\"]\n A_pre = fout[\"A_pre\"]\n monom_poly = fout[\"monom_poly\"]\n geom = fout[\"geom\"]\n \n #add in constant term?\n z_blank = np.zeros([1, A_pre.shape[1]])\n z_list = [int(z) for z in z_blank.tolist()[0]] #probably a better way to do this\n add_z = []\n \n if z_blank not in A_pre:\n A_pre= np.append(A_pre, z_blank, axis = 0)\n b = np.append(b, 0)\n add_z = z_list\n \n #always add the constant term to the monomial set\n monom_all = A_pre.tolist()\n A = np.ones((A_pre.shape[1] + 1, A_pre.shape[0]), dtype = int)\n A[1:,:] = A_pre.T \n \n #find the support and generators of all monomials \n support = np.array(polytope.interior(A, strict = False))\n half_support = [list(v // 2) for v in support if v.any() and not (v % 2).any()]\n #once again, add back the constant\n\n\n #augmented support set, 1 + half_support + current support\n #TODO: This is incorrect, breaks the lexicographic ordering and many assumptions. Fix this\n #aug_support = monom_all + add_z + [i for i in half_support if i not in monom_all]\n monom_data = np.array(sum([[list(m) for m in monom_poly[i]] for i in range(len(geom)) if not geom[i]], []))\n\n keys_classify = np.lexsort(np.flipud(monom_data.T))\n\n #monom_classify = monom_data[keys_classify, :].tolist()\n monom_classify = monom_data.tolist()\n #for i = range(monom_poly):\n # if geom[i]:\n\n\n all_support = half_support + add_z + monom_classify\n aug_support = np.flip(np.unique(np.array(all_support), axis=0), axis=0).tolist()\n \n \n #lookup table to associate generating indices with monomials\n #fill out the moment constraints\n lookup = {} \n for vi in range(len(aug_support)):\n v = aug_support[vi]\n for ui in range(vi, len(aug_support)):\n u = aug_support[ui]\n s = tuple([u[i] + v[i] for i in range(len(v))])\n if s in lookup:\n lookup[s] += [(ui, vi)]\n else:\n lookup[s] = [(ui, vi)]\n \n M_out = {\"supp\": aug_support, \"monom_all\": monom_all, \"monom_poly\": monom_poly, \"monom_classify\":monom_classify,\n \"cons\": lookup, \"fb\": fb, \"geom\":geom}\n #M_out = {\"supp\" : aug_support, \"half_supp\" : half_support, \"monom\": monom, \"cons\" : lookup, \"fb\": fb} \n \n return M_out","def objective(self, x):\n pass","def objective(self, x):\n pass","def potentialSolver2(self, max_it, tol):\n\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\n \n L2 = 0.0 # norm\n \n converged = False\n \n \n # solve potential\n for it in np.arange(1,max_it+1):\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\" \n \"\"\"\n #standard internal open node\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\n \n # sucessive over relaxation \n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\n \n \"\"\" \n #standard internal open node\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\n \n \"\"\"\n # sucessive over relaxation \n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\n \"\"\"\n \n #check for convergence*/\n if it%25==0:\n sum = 0;\n \"\"\"\n for i in np.arange(1,self.ni-1):\n for j in np.arange(1,self.nj-1):\n for k in np.arange(1,self.nk-1):\n \"\"\"\n\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\n\n sum = np.sum(self.R**2)\n\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\n #print(\"iter: \"+str(it)+\", L2 = \"+str(L2))\n if (L2<tol):\n converged = True\n break\n\n if (converged==False):\n print(\"Gauss-Seidel failed to converge, L2 = \"+str(L2))\n \n return converged"],"string":"[\n \"def l1(P, q):\\n\\n m, n = P.size\\n\\n # Solve equivalent LP \\n #\\n # minimize [0; 1]' * [u; v]\\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\\n #\\n # maximize -[q; -q]' * z \\n # subject to [P', -P']*z = 0\\n # [-I, -I]*z + 1 = 0 \\n # z >= 0 \\n \\n c = matrix(n*[0.0] + m*[1.0])\\n h = matrix([q, -q])\\n\\n def Fi(x, y, alpha = 1.0, beta = 0.0, trans = 'N'): \\n if trans == 'N':\\n # y := alpha * [P, -I; -P, -I] * x + beta*y\\n u = P*x[:n]\\n y[:m] = alpha * ( u - x[n:]) + beta*y[:m]\\n y[m:] = alpha * (-u - x[n:]) + beta*y[m:]\\n\\n else:\\n # y := alpha * [P', -P'; -I, -I] * x + beta*y\\n y[:n] = alpha * P.T * (x[:m] - x[m:]) + beta*y[:n]\\n y[n:] = -alpha * (x[:m] + x[m:]) + beta*y[n:]\\n\\n\\n def Fkkt(W): \\n\\n # Returns a function f(x, y, z) that solves\\n #\\n # [ 0 0 P' -P' ] [ x[:n] ] [ bx[:n] ]\\n # [ 0 0 -I -I ] [ x[n:] ] [ bx[n:] ]\\n # [ P -I -W1^2 0 ] [ z[:m] ] = [ bz[:m] ]\\n # [-P -I 0 -W2 ] [ z[m:] ] [ bz[m:] ]\\n #\\n # On entry bx, bz are stored in x, z.\\n # On exit x, z contain the solution, with z scaled (W['di'] .* z is\\n # returned instead of z). \\n\\n d1, d2 = W['d'][:m], W['d'][m:]\\n D = 4*(d1**2 + d2**2)**-1\\n A = P.T * spdiag(D) * P\\n lapack.potrf(A)\\n\\n def f(x, y, z):\\n\\n x[:n] += P.T * ( mul( div(d2**2 - d1**2, d1**2 + d2**2), x[n:]) \\n + mul( .5*D, z[:m]-z[m:] ) )\\n lapack.potrs(A, x)\\n\\n u = P*x[:n]\\n x[n:] = div( x[n:] - div(z[:m], d1**2) - div(z[m:], d2**2) + \\n mul(d1**-2 - d2**-2, u), d1**-2 + d2**-2 )\\n\\n z[:m] = div(u-x[n:]-z[:m], d1)\\n z[m:] = div(-u-x[n:]-z[m:], d2)\\n\\n return f\\n\\n\\n # Initial primal and dual points from least-squares solution.\\n\\n # uls minimizes ||P*u-q||_2; rls is the LS residual.\\n uls = +q\\n lapack.gels(+P, uls)\\n rls = P*uls[:n] - q \\n\\n # x0 = [ uls; 1.1*abs(rls) ]; s0 = [q;-q] - [P,-I; -P,-I] * x0\\n x0 = matrix( [uls[:n], 1.1*abs(rls)] ) \\n s0 = +h\\n Fi(x0, s0, alpha=-1, beta=1) \\n\\n # z0 = [ (1+w)/2; (1-w)/2 ] where w = (.9/||rls||_inf) * rls \\n # if rls is nonzero and w = 0 otherwise.\\n if max(abs(rls)) > 1e-10: \\n w = .9/max(abs(rls)) * rls\\n else: \\n w = matrix(0.0, (m,1))\\n z0 = matrix([.5*(1+w), .5*(1-w)])\\n\\n dims = {'l': 2*m, 'q': [], 's': []}\\n sol = solvers.conelp(c, Fi, h, dims, kktsolver = Fkkt, \\n primalstart={'x': x0, 's': s0}, dualstart={'z': z0})\\n return sol['x'][:n]\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\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 add_objective(self): \\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n if self.num_hidden == 0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n else:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.add_css_approximation(data_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden ==0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n normalizer_term = self.compute_energy(self.x_gibbs, \\n self.batch_size)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden > 0:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n # cost is negative log likelihood \\n self.cost = T.mean(data_term) + normalizer_term\",\n \"def prob2():\\n # Define the function to be optimized and the initial condition.\\n def multimin(x):\\n r = np.sqrt((x[0]+1)**2 + x[1]**2)\\n return r**2 *(1+ np.sin(4*r)**2)\\n x0 = np.array([-2, -2])\\n \\n info = {}\\n info[.5] = opt.basinhopping(multimin, x0, stepsize=0.5,\\n minimizer_kwargs={'method':'nelder-mead'})\\n info[.2] = opt.basinhopping(multimin, x0, stepsize=0.2,\\n minimizer_kwargs={'method':'nelder-mead'})\\n\\n # Print the results.\\n for step in info:\\n print(\\\"Stepsize:\\\\t{}\\\\nMinimum:\\\\t{}\\\\n\\\".format(step, info[step].fun))\\n\\n # Answer the problem question and return the minimum value.\\n print(\\\"0.2 is too small a stepsize to escape the basin of a local min.\\\")\\n return info[.2].fun\",\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 fit_chowliu(self, data, penalty=0, weights=None):\\n # TODO: add score f'n parameter, default to empirical MI? or too complicated?\\n def MI2(data, weights):\\n \\\"\\\"\\\"Estimate mutual information between all pairs of *binary* {0,1} variables\\\"\\\"\\\"\\n pi = np.average(data.astype(float),axis=1,weights=weights)[np.newaxis,:]\\n pij = np.cov(data,ddof=0,aweights=weights) + (pi.T.dot(pi));\\n p = np.stack( (pij, pi-pij, pi.T-pij, 1+pij-pi-pi.T), axis=2)\\n p2 = pi.T.dot(pi)\\n q = np.stack( (p2,pi-p2,pi.T-p2,1+p2-pi-pi.T), axis=2)\\n MI = (p*(np.log(p+1e-10)-np.log(q+1e-10))).sum(axis=2)\\n return MI,pij,pi[0]\\n \\n n,m = data.shape\\n #MI, pij,pi = MI2(to01(data), weights)\\n MI, pij,pi = MI2(data, weights) # data should be 0/1, not -1/+1\\n from scipy.sparse.csgraph import minimum_spanning_tree as mst\\n tree = mst(penalty-MI).tocoo();\\n factors = [Factor([Var(i,2)], [1-pi[i],pi[i]]) for i in range(n)]\\n for i,j,w in zip(tree.row,tree.col,tree.data):\\n if w>0: continue\\n (i,j)=(int(i),int(j)) if i<j else (int(j),int(i))\\n tij = [1+pij[i,j]-pi[i]-pi[j], pi[i]-pij[i,j], pi[j]-pij[i,j], pij[i,j]]\\n fij = Factor([Var(i,2),Var(j,2)],tij);\\n fij = fij / fij.sum([i]) / fij.sum([j])\\n factors.append(fij)\\n self.__init__(factors)\",\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 method2(self):\\n cres=np.zeros(self.NL,dtype=float) # List of invariants\\n # The U matrices from Fukui's method; storage...\\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n for il in range(self.NL):\\n # ... and calculation of U matrices for each layer\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.LDM[il,ix ,iy ,:,:]\\n mat2=self.LDM[il,(ix%self.kS.Nx)+1 ,iy ,:,:]\\n mat3=self.LDM[il,ix ,(iy%self.kS.Ny)+1 ,:,:]\\n \\n Ux_loc[ix,iy]=np.dot(np.conj(mat1.T),mat2)[1,1]\\n Uy_loc[ix,iy]=np.dot(np.conj(mat1.T),mat3)[1,1]\\n \\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux_loc[ix,iy]*Uy_loc[ix+1,iy]/Ux_loc[ix,iy+1]/Uy_loc[ix,iy])\\n cres[il]+=(ftemp/2./pi/1j).real # Layer specific topological invariant\\n \\n return cres\",\n \"def u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=50): \\n # PREMULTIPLIED LHS IS AN EXTRA ARGUMENT! Set it to None and add solver! \\n \\\"\\\"\\\"In the following +[[]] and [:-1] are added to keep thing 1dim array of objects and still multiply it elemtwisely\\\"\\\"\\\" \\n# #B.append([]) #THIS IS WRONG, CHANGES THE LIST \\n# B_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(B+[[]])[:-1], axis = 0) \\n# A_ls = np.concatenate([(1/np.sqrt(2*eta0))*A, B_concat], axis = 0) \\n# #print(np.array(B).shape) \\n# #print(w[0].shape) \\n# #print(w, eta) \\n# #w.append([]) THIS IS WRONG, CHANGES THE LIST \\n# w_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(w+[[]])[:-1], axis = 0) #[:-1] Added as a hack to keep it one-dim array of objects \\n# eta_w = np.expand_dims(1/np.sqrt(2*eta),1)*np.array(w) \\n# print(eta_w.shape) \\n# b_ls = np.concatenate([(1/np.sqrt(2*eta_0))*w_0, eta_w.flatten()], axis = 0) \\n #Use correct broadcasting?\\n w_concat = np.concatenate((1/np.sqrt(2*eta))*np.array(w+[[]])[:-1], axis = 0) #[:-1] Added as a hack to keep it one-dim array of objects \\n b_ls = np.concatenate([(1/np.sqrt(2*eta_0))*w_0, w_concat, (1/np.sqrt(2*eta_lin))*w_lin], axis = 0) \\n# print(np.sum(eta_w.flatten() != w_concat)) \\n# premultiplied_time_start = time.time() \\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray() \\n# premultiplied_time_end = time.time() \\n# print('premultiplying took {}'.format(premultiplied_time_end - premultiplied_time_start)) \\n# premultiplied_rhs = eta_T_H_stacked.T.dot(b_ls) \\n# u_next = nnls_predotted(premultiplied_lhs, premultiplied_rhs, tol=1e-5) \\n# print(eta_T_H_stacked.shape, b_ls.shape) \\n# A_ls_t_b = eta_T_H_stacked.T.dot(b_ls) \\n# w =scipy.sparse.linalg.spsolve_triangular(RT, A_ls_t_b, lower = True) \\n# x = scipy.sparse.linalg.spsolve_triangular(R, w, lower = False) \\n# u_next = x \\n u_next = scipy.optimize.lsq_linear(eta_T_H_L_stacked, b_ls, bounds = (0, np.inf), tol=1e-3, lsmr_tol=1e-3, max_iter=nnls_max_iter, verbose=1).x \\n# u = scipy.optimize.lsq_linear(premultiplied_lhs, premultiplied_rhs, bounds = (0, np.inf), tol=1e-5).x \\n return u_next\",\n \"def fit_chowliu(data, penalty=0, weights=None):\\n # TODO: add score f'n parameter, default to empirical MI? or too complicated?\\n def MI2(data, weights, eps=1e-10):\\n \\\"\\\"\\\"Estimate mutual information between all pairs of *binary* {0,1} variables\\\"\\\"\\\"\\n pi = np.average(data.astype(float),axis=1,weights=weights)[np.newaxis,:]\\n pij = np.cov(data,ddof=0,aweights=weights) + (pi.T.dot(pi));\\n p = np.stack( (pij, pi-pij, pi.T-pij, 1+pij-pi-pi.T), axis=2)\\n p2 = pi.T.dot(pi)\\n q = np.stack( (p2,pi-p2,pi.T-p2,1+p2-pi-pi.T), axis=2)\\n MI = (p*(np.log(p+eps)-np.log(q+eps))).sum(axis=2)\\n return MI,pij,pi[0]\\n \\n n,m = data.shape\\n MI, pij,pi = MI2(data, weights) # data should be 0/1, not -1/+1\\n from scipy.sparse.csgraph import minimum_spanning_tree as mst\\n tree = mst(penalty-MI).tocoo();\\n factors = [Factor([Var(i,2)], [1-pi[i],pi[i]]) for i in range(n)]\\n for i,j,w in zip(tree.row,tree.col,tree.data):\\n if w>0: continue\\n (i,j)=(int(i),int(j)) if i<j else (int(j),int(i))\\n tij = [1+pij[i,j]-pi[i]-pi[j], pi[i]-pij[i,j], pi[j]-pij[i,j], pij[i,j]]\\n fij = Factor([Var(i,2),Var(j,2)],tij);\\n fij = fij / fij.sum([i]) / fij.sum([j])\\n factors.append(fij)\\n return Ising(factors)\",\n \"def limited_information_lower_bound_IL(P0: np.ndarray, P1: np.ndarray,\\r\\n pi0: np.ndarray, pi1: np.ndarray):\\r\\n P0, P1 = sanity_check_probabilities(P0, P1)\\r\\n na = P0.shape[0]\\r\\n ns = P1.shape[1]\\r\\n P1_p1 = build_markov_transition_density(P1, pi1)\\r\\n P0_p0 = build_markov_transition_density(P0, pi0)\\r\\n _, mu1 = compute_stationary_distribution(P1, pi1)\\r\\n\\r\\n d = sp.special.kl_div(P1_p1, P0_p0) + sp.special.kl_div(\\r\\n 1 - P1_p1, 1 - P0_p0)\\r\\n\\r\\n return np.dot(mu1, np.max(d, axis=0))\",\n \"def minimum_spanning_arborescence(sol):\",\n \"def minimize(self):\\n pass\",\n \"def Example_2():\\r\\n print \\\"\\\\n** Example_2: Finding the minimum of the Rosenbrock function with 2 variables under constraints **\\\"\\r\\n\\r\\n Ex = optim_wrapper()\\r\\n X0 = np.zeros(2)\\r\\n lim = [(-2.0, 2.0)]*2\\r\\n Ex.set_X0(X0)\\r\\n Ex.set_lim(lim)\\r\\n Ex.set_penalties_func(pen)\\r\\n Ex.set_norm_count(200)\\r\\n Ex.set_nb_best(100)\\r\\n Ex.set_obj_func(obj)\\r\\n Ex.set_wrapper()\\r\\n Ex.launch_multi_opti()\\r\\n print Ex\\r\\n\\r\\n X_solution = [1.0, 1.0]\\r\\n res_string = \\\"Results of the optimisation: {:03.4f}, expected results: {:03.4f}\\\".format(obj(Ex.get_res()), obj(X_solution))\\r\\n print res_string\\r\\n print \\\"*\\\" * len(res_string)\",\n \"def eg3(N_train=1000, N_test=500, depend_ratio_train=0.8, depend_ratio_test=0.2, feature_num=10, stable_ratio=0.4):\\n\\n def eg3_kernel(n, p, stable_ratio=0.4, depend_ratio=0.8):\\n p_stable = int(p * stable_ratio)\\n p_noise = p - p_stable\\n stable_feature = np.random.randn(n, p_stable)\\n noise_feature_dependent = np.zeros([n, p_noise])\\n noise_feature_independent = np.random.randn(n, p_noise)\\n for i in range(p_noise):\\n noise_feature_dependent[:, i] = stable_feature[:, i % p_stable] + stable_feature[:,\\n (i + 1) % p_stable] + 2 * np.random.randn(\\n n) # still need noise\\n noise_depend_label = np.random.uniform(0, 1, n).reshape(-1, 1)\\n noise_depend_label = np.concatenate([noise_depend_label] * p_noise, axis=1)\\n noise_feature = np.where(noise_depend_label < depend_ratio, noise_feature_dependent, noise_feature_independent)\\n\\n b = np.zeros([p_stable, 1])\\n linear_len = int(p_stable / 2)\\n\\n for i in range(linear_len): # linear part\\n b[i, 0] = (-1) ** i * (i % 3 + 1) * p / 3\\n for i in range(linear_len, b.shape[0]): # nonlinear part\\n b[i, 0] = p / 2\\n\\n linear_part = np.matmul(stable_feature[:, :linear_len], b[:linear_len, 0])\\n nolinear_part = np.zeros([n, 1])\\n for i in range(linear_len, b.shape[0]):\\n temp = stable_feature[:, i % p_stable] * stable_feature[:, (i + 1) % p_stable] * b[i, 0]\\n temp = temp.reshape(-1, 1)\\n nolinear_part += temp\\n\\n Y = linear_part.reshape(-1, 1) + nolinear_part + np.random.randn(n, 1)\\n\\n data = {}\\n data['stable'] = stable_feature\\n data['noise'] = noise_feature\\n data['Y'] = Y\\n data['params'] = b\\n data['kernel'] = 'eg3'\\n return data\\n\\n data_train = eg3_kernel(n=N_train, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_train)\\n data_test = eg3_kernel(n=N_test, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_test)\\n return data_train, data_test\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def potentialSolver5(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\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 minimize(self):\\n raise NotImplementedError\",\n \"def _checkedMinimizer(self, confs):\\n from MMTK.Minimization import SteepestDescentMinimizer # @UnresolvedImport\\n minimizer = SteepestDescentMinimizer(self.top.universe)\\n\\n original_stderr = sys.stderr\\n sys.stderr = NullDevice() # Suppresses warnings for minimization\\n\\n minimized_confs = []\\n minimized_energies = []\\n self.log.recordStart('minimization')\\n for conf in confs:\\n self.top.universe.setConfiguration(\\n Configuration(self.top.universe, conf))\\n x_o = np.copy(self.top.universe.configuration().array)\\n e_o = self.top.universe.energy()\\n for rep in range(50):\\n minimizer(steps=25)\\n x_n = np.copy(self.top.universe.configuration().array)\\n e_n = self.top.universe.energy()\\n diff = abs(e_o - e_n)\\n if np.isnan(e_n) or diff < 0.05 or diff > 1000.:\\n self.top.universe.setConfiguration(\\n Configuration(self.top.universe, x_o))\\n break\\n else:\\n x_o = x_n\\n e_o = e_n\\n if not np.isnan(e_o):\\n minimized_confs.append(x_o)\\n minimized_energies.append(e_o)\\n\\n sys.stderr = original_stderr # Restores error reporting\\n\\n confs = minimized_confs\\n energies = minimized_energies\\n self.log.tee(\\\" minimized %d configurations in \\\"%len(confs) + \\\\\\n HMStime(self.log.timeSince('minimization')) + \\\\\\n \\\"\\\\n the first %d energies are:\\\\n \\\"%min(len(confs),10) + \\\\\\n ', '.join(['%.2f'%e for e in energies[:10]]))\\n return confs, energies\",\n \"def _l1m_objective(a,X,*args):\\n \\n return(np.sum(np.apply_along_axis(_euclidnorm,1,_diffmat_objective(a,X))))\",\n \"def annealing_objective(x: npt.NDArray[np.float64], *args: Any) -> float:\\n blocks = [int(ind) for ind in x]\\n\\n approx_threshold = args[0]\\n upper_limit = args[1]\\n psol_configs = args[2]\\n dists = args[3]\\n utrys = args[4]\\n n_cxs = args[5]\\n p = args[6]\\n w = args[7]\\n\\n if blocks in psol_configs:\\n return 1.2\\n\\n approx_dist = sum(dists[i][b] for i, b in enumerate(blocks))\\n\\n if approx_dist > approx_threshold:\\n return 1.1\\n\\n n_cx = w * (sum(n_cxs[i][b] for i, b in enumerate(blocks)) / upper_limit)\\n\\n if len(psol_configs) == 0:\\n return n_cx\\n\\n distances = [0] * len(psol_configs)\\n\\n for index, config in enumerate(psol_configs):\\n distances[index] = sum(\\n utrys[i][config[i]].get_distance_from(utrys[i][b])\\n < max(dists[i][config[i]], dists[i][b])\\n for i, b in enumerate(blocks)\\n ) / len(blocks)\\n\\n b_dv = (1 - w) * np.percentile(distances, p)\\n\\n return n_cx + b_dv\",\n \"def find_stage2_threshold(model_path, u_mode):\\n u_modes = ['sub_u', 'unlabeled']\\n\\n assert u_mode in u_modes\\n\\n if u_mode == 'sub_u':\\n negative = np.load(\\\"./processed_data/train/sub_u_negative.npy\\\")\\n else:\\n negative = np.load(\\\"./processed_data/train/unlabeled_negative.npy\\\")\\n\\n positive = np.load(\\\"./processed_data/train/raw/train_p.npy\\\")\\n\\n\\n # begin with sub-u classifier test\\n classifier = joblib.load(model_path)\\n u_bst_th = 0.0\\n u_th = 0.0\\n u_index = 0.0\\n u_tp = 0.0\\n u_fp = 0.0\\n while u_th < 1:\\n p_result = np.array(classifier.predict_proba(positive[:, :-1])[:, 1])\\n sub_u_result = np.array(classifier.predict_proba(negative[:, :-1])[:, 1])\\n tp_rate = np.where(p_result >= u_th, 1, 0).sum() / p_result.shape[0]\\n fp_rate = np.where(sub_u_result >= u_th, 1, 0).sum() / sub_u_result.shape[0]\\n index = math.sqrt(tp_rate * (1 - fp_rate))\\n if index >= u_index:\\n u_index = index\\n u_tp = tp_rate\\n u_fp = fp_rate\\n u_bst_th = u_th\\n print(\\\"threshold: \\\" + str(u_th) + \\\" TP: \\\"\\n + str(tp_rate) + \\\" FP: \\\" + str(fp_rate) + \\\" GMean: \\\" + str(index) + \\\"\\\\n\\\\n\\\")\\n u_th += _threshold_2_step\\n\\n\\n\\n print(model_path + \\\"\\\\n \\\" +\\n \\\"threshold: \\\" + str(u_bst_th) + \\\" TP: \\\" + str(u_tp) + \\\" FP: \\\" + str(u_fp) + \\\" GMean: \\\" + str(u_index))\",\n \"def smooth_input(xs, ys, L):\\n n = len(xs)\\n\\n # obj = [1 for i in range(n)]\\n # for i in range(2 * n):\\n # obj.append(0)\\n\\n # Create the model\\n model = LpProblem(name=\\\"small-problem\\\", sense=LpMinimize)\\n ws = [LpVariable(name=\\\"w_{}\\\".format(i), lowBound=0, upBound=1) for i in range(n)]\\n ls = [LpVariable(name=\\\"L_{}\\\".format(i), lowBound=0) for i in range(n)]\\n zs = [LpVariable(name=\\\"z_{}\\\".format(i)) for i in range(n)]\\n\\n # objective\\n model += lpSum(ws)\\n\\n # constraint 1:\\n # sum of Li <= L\\n model += (lpSum(ls) <= L * n, \\\"sum of Li <= L\\\")\\n\\n # Constraint 2:\\n # w_i >= |z_i - y_i|\\n for i in range(n):\\n model += (ws[i] + zs[i] >= ys[i], \\\"C2.a_{}\\\".format(i))\\n model += (ws[i] - zs[i] >= -ys[i], \\\"C2.b_{}\\\".format(i))\\n\\n # Constraint 3\\n # |z_i - z_j| <= L_i * dist(x_i, x_j)\\n for i in range(n):\\n for j in range(n):\\n if i != j:\\n model += (zs[i] - zs[j] - abs(xs[i] - xs[j]) * ls[i] <= 0, \\\"C3.a_{}_{}\\\".format(i, j))\\n model += (zs[j] - zs[i] - abs(xs[i] - xs[j]) * ls[i] <= 0, \\\"C3.b_{}_{}\\\".format(i, j))\\n\\n if model.solve() == 1:\\n print(\\n \\\"------------------------------------\\\\nFound solution for the linear program\\\\n------------------------------------\\\\n\\\")\\n return [[xs[i], zs[i].value()] for i in range(n)]\\n # return [zi.value() for zi in zs], [li.value() for li in ls]\\n\\n print(\\\"Linear program: no solution found\\\")\\n exit(1)\\n return -1\",\n \"def cp_apr(X, Y1, R, Minit=None, tol=1e-4, maxiters=1000, maxinner=50,\\n epsilon=1e-10, kappatol=1e-10, kappa=1e-2):\\n N = X.ndims()\\n \\n ## Random initialization\\n if Minit == None:\\n F = tensorTools.randomInit(X.shape, R)\\n Minit = ktensor.ktensor(np.ones(R), F);\\n nInnerIters = np.zeros(maxiters);\\n\\n ## Initialize M and Phi for iterations\\n M = Minit\\n M.normalize(1)\\n Phi = [[] for i in range(N)]\\n kktModeViolations = np.zeros(N)\\n kktViolations = -np.ones(maxiters)\\n nViolations = np.zeros(maxiters)\\n\\n lambda2=0.1\\n lambda3=0.1\\n sita=np.random.rand(R+1,1);\\n ## statistics\\n cpStats = np.zeros(7)\\n '''\\n print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'\\n print M.U[0][1,:]\\n print M.U[0].shape\\n print Demog[1]\\n print DemoU[1]\\n print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'\\n '''\\n for iteration in range(maxiters):\\n startIter = time.time()\\n isConverged = True;\\n for n in range(N):\\n startMode = time.time()\\n ## Make adjustments to M[n] entries that violate complementary slackness\\n if iteration > 0:\\n V = np.logical_and(Phi[n] > 1, M.U[n] < kappatol)\\n if np.count_nonzero(V) > 0:\\n nViolations[iteration] = nViolations[iteration] + 1\\n #print 'V:',V.shape,V.dtype\\n #print 'M.U[n]',M.U[n].shape,M.U[n].dtype\\n M.U[n][V > 0] = M.U[n][V > 0] + kappa\\n if n==0:\\n sita=__solveLinear(M.U[n],Y1,lambda3)\\n # lr=LogisticRegression()\\n #sita=lr.fit(M.U[n],Y1).coef_\\n #print 'sita'\\n #print sita\\n #print 'demoU'\\n #print DemoU[0]\\n M, Phi[n], inner, kktModeViolations[n], isConverged = __solveSubproblem1(X, M, n, maxinner, isConverged, epsilon, tol,sita,Y1, lambda2)\\n else:\\n M, Phi[n], inner, kktModeViolations[n], isConverged = __solveSubproblem0(X, M, n, maxinner, isConverged, epsilon, tol)\\n elapsed = time.time() - startMode\\n # only write the outer iterations for now\\n #cpStats = np.vstack((cpStats, np.array([iteration, n, inner, tensorTools.lsqrFit(X,M), tensorTools.loglikelihood(X,[M]), kktModeViolations[n], elapsed])))\\n\\n kktViolations[iteration] = np.max(kktModeViolations)\\n elapsed = time.time()-startIter\\n #cpStats = np.vstack((cpStats, np.array([iter, -1, -1, kktViolations[iter], __loglikelihood(X,M), elapsed])))\\n print(\\\"Iteration {0}: Inner Its={1} with KKT violation={2}, nViolations={3}, and elapsed time={4}\\\".format(iteration, nInnerIters[iteration], kktViolations[iteration], nViolations[iteration], elapsed))\\n if isConverged:\\n break\\n\\n cpStats = np.delete(cpStats, (0), axis=0) # delete the first row which was superfluous\\n ### Print the statistics\\n #fit = tensorTools.lsqrFit(X,M)\\n #ll = tensorTools.loglikelihood(X,[M])\\n print(\\\"Number of iterations = {0}\\\".format(iteration))\\n #print(\\\"Final least squares fit = {0}\\\".format(fit))\\n #print(\\\"Final log-likelihood = {0}\\\".format(ll))\\n print(\\\"Final KKT Violation = {0}\\\".format(kktViolations[iteration]))\\n print(\\\"Total inner iterations = {0}\\\".format(np.sum(nInnerIters)))\\n \\n #modelStats = {\\\"Iters\\\" : iter, \\\"LS\\\" : fit, \\\"LL\\\" : ll, \\\"KKT\\\" : kktViolations[iteration]}\\n return M, cpStats\",\n \"def get_Objective(self):\\r\\n \\r\\n ans = 0\\r\\n for i in range(len(self.X.shape)):\\r\\n ans += self.parameter['phi'][i] * self.parameter['lambda1'] *norm(tl.unfold(self.Wlist[i], i), 'nuc') + (1 / self.parameter['m']) * norm(tl.unfold(self.X - self.Wlist[i] - self.V, i))\\r\\n\\r\\n # Augmented part is calculated seperately. \\r\\n augment_part1 = 0.5 * self.parameter['rho1'] * norm(self.V - self.T + self.F1)\\r\\n augment_part2 = 0.5 * self.parameter['rho2'] * norm(tl.fold(np.dot(self.Dmatrix, tl.unfold(self.T, 0)), 0, self.T.shape) - self.S + self.F2)\\r\\n\\r\\n # Combine the result for final objective function\\r\\n ans += self.parameter['beta1'] * norm(self.V.reshape(self.totaldim), 1) + self.parameter['beta2'] * norm(self.S.reshape(self.totaldim), 1) + augment_part1 + augment_part2 \\r\\n return ans\",\n \"def weight_mm(self,m1,m2):\\n lw = 1.\\n\\n # particle id and isolation\\n lw *= self._muIDISOWeight.value(m1.pt(),m1.eta(),'0')\\n lw *= self._muIDISOWeight.value(m2.pt(),m2.eta(),'0')\\n\\n # Trigger\\n hlt_sf_run2012_a = (self._muTRIGGERWeight_leg8_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_A.value(m2.pt(),m2.eta(),'0') +\\\\\\n self._muTRIGGERWeight_leg17_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg8_A.value(m2.pt(),m2.eta(),'0') -\\\\\\n self._muTRIGGERWeight_leg17_A.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_A.value(m2.pt(),m2.eta(),'0'))\\n\\n hlt_sf_run2012_b = (self._muTRIGGERWeight_leg8_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_B.value(m2.pt(),m2.eta(),'0') +\\\\\\n self._muTRIGGERWeight_leg17_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg8_B.value(m2.pt(),m2.eta(),'0') -\\\\\\n self._muTRIGGERWeight_leg17_B.value(m1.pt(),m1.eta(),'0')*self._muTRIGGERWeight_leg17_B.value(m2.pt(),m2.eta(),'0'))\\n \\n lw *= (0.5*hlt_sf_run2012_a + 0.5*hlt_sf_run2012_b) ##percentage according to the lumi in which they were not prescaled (apparently same efficinecy for AB)\\n #lw *= 0.966 ## temporary solution!\\n\\n if abs(configuration.LeptonTnPfactor)<0.01 :\\n return lw\\n else:\\n return lw + configuration.LeptonTnPfactor*self.uncertainty_mm(m1,m2)\",\n \"def eg4(N_train=1000, N_test=500, depend_ratio_train=0.8, depend_ratio_test=0.2, feature_num=10, stable_ratio=0.4):\\n\\n def eg4_kernel(n, p, stable_ratio=0.4, depend_ratio=0.8):\\n p_stable = int(p * stable_ratio)\\n p_noise = p - p_stable\\n noise_feature = np.random.randn(n, p_noise)\\n stable_feature_dependent = np.zeros([n, p_stable])\\n stable_feature_independent = np.random.randn(n, p_stable)\\n for i in range(p_stable):\\n stable_feature_dependent[:, i] = noise_feature[:, i % p_noise] + noise_feature[:,\\n (i + 1) % p_noise] + 2 * np.random.randn(\\n n) # still need noise\\n stable_depend_label = np.random.uniform(0, 1, n).reshape(-1, 1)\\n stable_depend_label = np.concatenate([stable_depend_label] * p_stable, axis=1)\\n stable_feature = np.where(stable_depend_label < depend_ratio, stable_feature_dependent,\\n stable_feature_independent)\\n\\n b = np.zeros([p_stable, 1])\\n linear_len = int(p_stable / 2)\\n\\n for i in range(linear_len): # linear part\\n b[i, 0] = (-1) ** i * (i % 3 + 1) * p / 3\\n for i in range(linear_len, b.shape[0]): # nonlinear part\\n b[i, 0] = p / 2\\n\\n Y = np.matmul(stable_feature, b) + np.random.randn(n, 1)\\n\\n data = {}\\n data['stable'] = stable_feature\\n data['noise'] = noise_feature\\n data['Y'] = Y\\n data['params'] = b\\n data['kernel'] = 'eg4'\\n return data\\n\\n data_train = eg4_kernel(n=N_train, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_train)\\n data_test = eg4_kernel(n=N_test, p=feature_num, stable_ratio=stable_ratio, depend_ratio=depend_ratio_test)\\n return data_train, data_test\",\n \"def coarse_to_fine(im1, im2, pyramid1, pyramid2, n_iter=3):\\n assert im1.shape == im2.shape\\n \\n u = np.zeros_like(im1)\\n v = np.zeros_like(im1)\\n\\n #\\n # Your code here\\n #\\n\\n # Code inspired by:\\n # https://www.youtube.com/watch?v=FhlbUHhNpD4\\n\\n # descending indices of the gaussian pyramid \\n # (from small to big image)\\n K = len(pyramid1)\\n levels = np.arange(K - 1, -1, -1) # [K - 1, K - 2, ..., 0]\\n\\n #######################\\n # intial estimation #\\n #######################\\n\\n ##################################################\\n # print('Level [{}]'.format(K - 1))\\n\\n # get coarsest images from the gaussian pyramid\\n # at level (k - 1)\\n im1_k = pyramid1[-1].copy()\\n im2_k = pyramid2[-1].copy()\\n\\n # iterative LK-Algorithm (refine the motion)\\n uk, vk = iter_LK(im1_k, im2_k, n_iter)\\n\\n # expand image to new resolution\\n uk_exp = expand(uk) * 2\\n vk_exp = expand(vk) * 2\\n ###################################################\\n\\n\\n ##############################\\n # coarse to fine iteritons #\\n ##############################\\n\\n # iterate over [ K-2, K-3, ..., 0 ] -> all scales except the smallest\\n for k in levels[1:]: \\n # print('Level [{}]'.format(k))\\n\\n # get images of current scale from the pyramid\\n im1_k = pyramid1[k]\\n im2_k = pyramid2[k]\\n\\n # warp im1 image from pyramid1\\n im1_k_warp = warp(im1_k, uk_exp, vk_exp)\\n\\n # apply LK for iterative refinement on current resolution\\n uk, vk = iter_LK(im1_k_warp, im2_k, n_iter)\\n\\n # add current motion fields (uk, vk) from iter_LK to \\n # previous expanded motion fields (uk_exp, vk_exp)\\n uk = uk + uk_exp\\n vk = vk + vk_exp\\n\\n # expand the motion fields (uk, vk) to the next higher\\n # scale in the gaussian pyramid (to use in next iteration)\\n if k > 0: # all other level\\n uk_exp = expand(uk) * 2\\n vk_exp = expand(vk) * 2\\n else: # last level 0 (no expansion needed -> original scale)\\n uk_exp = uk\\n vk_exp = vk\\n\\n # print('[', k, ']: uk_exp = ', uk_exp.shape, ' | vk_exp = ', vk_exp.shape)\\n\\n # print('[FINAL]: u = ', uk_exp.shape, ' | v = ', vk_exp.shape)\\n\\n # set the final parameter \\n # (LK at original resolution)\\n u = uk_exp\\n v = vk_exp\\n\\n assert u.shape == im1.shape and \\\\\\n v.shape == im1.shape\\n return u, v\",\n \"def compute_surr_objective(A_hat, old_policy_model, policy_model, j, state_part_mean, state_part_std, config=PPO_config):\\n \\n def clip(c, epsilon):\\n if c < 1-epsilon:\\n return 1- epsilon\\n elif c > 1+epsilon:\\n return 1+ epsilon\\n else:\\n return c\\n \\n clipping_param = np.amax([0.01, (1-j/config['J'])*config['clipping']])\\n print(\\\"Clipping parameters: {}\\\".format(clipping_param))\\n #K = PPO_config['K']\\n #assert(K==len(A_hat))\\n policy_model.to(device)\\n old_policy_model.to(device)\\n surr_objective = 0\\n kl_est_list = []\\n for k in range(len(A_hat)):\\n for i in range(len(A_hat[k])):\\n # CHECK: if the action is an integer corresponding to the state\\n curr_state = torch.tensor(A_hat[k][i][0]).float()\\n try:\\n curr_state_norm_input = torch.cat((curr_state[:,0].unsqueeze(1), (curr_state[:,1:]-state_part_mean)/state_part_std))\\n except:\\n curr_state_norm_input = torch.cat((curr_state[0].unsqueeze(0), (curr_state[1:]-state_part_mean)/state_part_std))\\n\\n curr_state_norm_input[np.isnan(curr_state_norm_input)] = 0\\n curr_state_norm_input.to(device)\\n curr_action = A_hat[k][i][1]\\n\\n r_theta_ksi = policy_model(curr_state_norm_input.to(device))[curr_action] / old_policy_model(curr_state_norm_input.to(device))[curr_action] \\n r_theta_ksi_num = r_theta_ksi.cpu().detach().numpy()\\n single_est_from_r = r_theta_ksi_num-1-np.log(r_theta_ksi_num)\\n kl_est_list.append(single_est_from_r)\\n A_hat_ksi = A_hat[k][i][2] # Estimate the A_hat\\n surr_objective += min(r_theta_ksi * A_hat_ksi, clip(r_theta_ksi, clipping_param) * A_hat_ksi)\\n surr_objective /= len(A_hat)\\n kl_est = np.mean(np.asarray(kl_est_list))\\n\\n return surr_objective, kl_est\",\n \"def propose_optimize():\\n pass\",\n \"def l1Min(A, b):\\n #set up the matrices\\n m,n = A.shape\\n solvers.options['show_progress'] = False\\n c = np.concatenate([np.ones(n),np.zeros(n)]).astype(float)\\n G = np.vstack((np.hstack((-np.eye(n),np.eye(n))), np.hstack((-np.eye(n),-np.eye(n))),np.hstack((-np.eye(n),np.zeros((n,n))))))\\n h = np.zeros(3*n).astype(float)\\n A = np.hstack((np.zeros((m,n)),A)).astype(float)\\n #convert the matrices\\n c = matrix(c)\\n G = matrix(G)\\n h = matrix(h)\\n A = matrix(A)\\n b = matrix(b.astype(float))\\n #solve the matrices\\n sol = solvers.lp(c, G, h,A,b)\\n\\n return np.ravel(sol['x'][n:]),sol['primal objective']\",\n \"def highpass(R1=10e3,R3=10e3,C1=1e-9,C2=1e-9,G=1.586,Vi=1):\\n \\n A=Matrix([[0,-1,0,1/G],\\n [s*C2*R3/(s*C2*R3+1),0,-1,0],\\n [0,G,-G,1],\\n [-s*C2-1/R1-s*C1,0,s*C2,1/R1]])\\n\\n b=Matrix([0,0,0,-Vi*s*C1])\\n\\n V=A.inv()*b\\n #V_lim = [limit(v,G1,oo) for v in V]\\n return (A,b,V)\",\n \"def objective(self):\\n pass\",\n \"def _objective(self,output, expected,device):\\r\\n #\\r\\n #output = output.to(device = expected.device) #\\r\\n \\r\\n output = torch.where(output == 0,self.saf,output)\\r\\n #output = torch.where(output == 1,torch.tensor([0.999999],device = device),output)\\r\\n out1 = torch.mul(-expected,torch.log(output))\\r\\n #out2 = torch.mul(expected-1,torch.log(1 - output))\\r\\n #out = torch.add(out1,out2)\\r\\n return torch.sum(out1, dim = 1)\",\n \"def potentialSolver4(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def _compute_imprimitivity(self):\\n m = floor(self._.d / 2)\\n self._.antipodal = all(full_simplify(\\n self._.b[i] - self._.c[self._.d - i]) == 0\\n for i in range(self._.d) if i != m)\\n self._.bipartite = all(a == 0 for a in self._.a)\\n if self._.antipodal:\\n try:\\n self._.r = integralize(\\n 1 + self._.b[m] / self._.c[self._.d - m])\\n except TypeError:\\n raise InfeasibleError(\\\"covering index not integral\\\")\\n if self._.d >= 2:\\n if self._.d == 2:\\n b = [self._.b[0]/(self._.b[1]+1)]\\n c = [Integer(1)]\\n else:\\n b = self._.b[:m]\\n c = list(self._.c[1:m+1])\\n if is_divisible(self._.d, 2):\\n c[-1] *= self._.r\\n scheme = self._get_class()(tuple(b), tuple(c))\\n else:\\n scheme = ASParameters(P=[[1]])\\n self._.antipodal_subscheme = self.add_subscheme(scheme,\\n self.ANTIPODAL)\\n if self._.bipartite:\\n if self._.d >= 2:\\n b = tuple(self._.b[2*i]*self._.b[2*i+1]/self._.c[2]\\n for i in range(m))\\n c = tuple(self._.c[2*i+1]*self._.c[2*i+2]/self._.c[2]\\n for i in range(m))\\n scheme = self._get_class()(b, c)\\n else:\\n scheme = ASParameters(P=[[1]])\\n self._.bipartite_subscheme = self.add_subscheme(scheme,\\n self.BIPARTITE)\",\n \"def make_objective(name, data, pset, unconfined_objective=None, bset=None,\\n num_points=101, withtail=True):\\n h2o = SLD(-0.54, 'h2o')\\n melCM = SLD(2.60, 'Melinex CM soln')\\n melinex = SLD(2.56, 'Melinex') \\n sio2 = SLD(3.47, 'sio2')\\n si = SLD(2.07, 'si')\\n polymer = SLD(0.85, 'PNIPAM')\\n\\n # Make sure nothing in our (already fitted) unconfined objective varys.\\n\\n\\n si_l = si(0, 0)\\n\\n # Silica\\n sio2_l = sio2(14.6, 2)\\n sio2_l.vfsolv.setp (value=0.003)\\n\\n polymer_l_mel = area_slabT(adsorbed_amount=200, dry_sld=polymer, rough=2,\\n thick=1500, name='polymer')\\n\\n mellinex_l = melinex(0,14)\\n mellinex_l.rough.setp (vary=False, bounds=(1, 20))\\n\\n h2o_l = h2o(0,10)\\n\\n structure_mel = si_l | sio2_l | polymer_l_mel | mellinex_l\\n\\n if unconfined_objective is not None:\\n for vp in unconfined_objective.varying_parameters().flattened():\\n vp.setp(vary=False)\\n unconfined_objective.model.structure[3].adsorbed_amount = polymer_l_mel.adsorbed_amount\\n structure_h2o = si_l | sio2_l | unconfined_objective.model.structure[2] | unconfined_objective.model.structure[3] | h2o_l\\n else:\\n structure_h2o = si_l | h2o_l\\n\\n\\n structure_mel.solvent = h2o\\n structure_h2o.solvent = h2o\\n\\n if unconfined_objective is not None:\\n structure_h2o.contract = 1.5\\n\\n distmodel = DistributionModel(structure_mel, loc_in_struct=2,\\n num_structs=num_points, pdf=dist_pdf,\\n pdf_kwargs={'loc':1, 'scale':1, 'a':1, 'tail':0.00, 'tail_len':400})\\n distmodel.pdf_params[0].setp(value=210)\\n distmodel.pdf_params[1].setp(value=6)\\n distmodel.pdf_params[2].setp(value=3)\\n\\n if withtail:\\n distmodel.pdf_params[3].setp(value=0.0001)\\n distmodel.pdf_params[4].setp(value=400)\\n else:\\n distmodel.pdf_params[3].setp(value=0, vary=False)\\n distmodel.pdf_params[4].setp(value=0, vary=False) \\n\\n h2omodel = ReflectModel(structure_h2o, name='h2o')\\n\\n\\n sratio = Parameter(value=0.1, name='scale ratio')\\n\\n model = MetaModel([distmodel, h2omodel], [0.5, 0.5], add_params=[sratio])\\n model.scales[0].setp(value=0.97)\\n model.scales[1] = model.scales[0]*sratio\\n model.bkg.setp(value=0)\\n\\n obj = Objective(model, data, name=name)\\n for key in pset:\\n set_param(obj.parameters, key, value=pset[key])\\n\\n if bset is not None:\\n for key in bset:\\n set_param(obj.parameters, key, bounds=bset[key])\\n\\n return obj\",\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 HaarGOB(treeG):\\n # number of level of the chain (or tree)\\n Ntr = len(treeG)\\n # reorder chain (optional) \\n # reordering each level so that in each level the nodes are in the\\n # descent order of degrees\\n # compute u_l^c for level J_0 (top level)\\n clusterJ0 = treeG[Ntr-1]['clusters']\\n N0 = len(clusterJ0)\\n # generate indicator function on G^c\\n chic = np.identity(N0)\\n uc = [None]*N0\\n uc[0] = 1/np.sqrt(N0,dtype=np.float64)*np.ones(N0)\\n for l in np.arange(1, N0):\\n uc[l] = np.sqrt((N0-l)/(N0-l+1))*(chic[l-1,:]-1/(N0-l)*np.sum(chic[l:,:], axis=0))\\n# u = copy.deepcopy(uc)\\n treeG[Ntr-1]['u'] = uc\\n # compute the next level orthonormal basis ulk and stored into u\\n for j_tr in np.arange(0, Ntr-1)[::-1]:\\n N1 = len(treeG[j_tr]['clusters'])\\n u = [None]*N1\\n i = N0\\n for l in range(N0):\\n clusterl = treeG[j_tr+1]['clusters'][l]\\n kl = len(clusterl)\\n #for k==1\\n ucl = uc[l]\\n ul1 = np.zeros(N1)\\n for j in range(N0):\\n idxj = treeG[j_tr+1]['clusters'][j]\\n ul1[idxj] = ucl[j]/np.sqrt(len(idxj))\\n u[l] = ul1\\n if kl>1:\\n chil = np.zeros((kl,N1))\\n for k in range(kl):\\n idxl = treeG[j_tr+1]['clusters'][l]\\n chil[k,idxl[k]] = 1;\\n \\n for k in np.arange(1,kl):\\n i = i+1\\n ulk = np.sqrt((kl-k)/(kl-k+1))*(chil[k-1,:]-1/(kl-k)*np.sum(chil[k:,:],axis=0))\\n u[i-1] = ulk\\n treeG[j_tr]['u'] = u\\n # update uc and N0\\n# uc = copy.deepcopy(u)\\n uc = u\\n N0 = N1\\n return treeG\",\n \"def seepage_from_superoperator(U):\\n if U.type=='oper':\\n sump = 0\\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n bra_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\\n qtp.ket([i_list[1]], dim=[3])).dag()\\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\\n qtp.ket([j_list[1]], dim=[3]))\\n p = np.abs((bra_i*U*ket_j).data[0, 0])**2\\n sump += p\\n sump /= 5 # divide by number of non-computational states\\n L1 = 1-sump\\n return L1\\n elif U.type=='super':\\n sump = 0\\n for i_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n for j_list in [[0,2],[1,2],[2,0],[2,1],[2,2]]:\\n ket_i = qtp.tensor(qtp.ket([i_list[0]], dim=[3]),\\n qtp.ket([i_list[1]], dim=[3]))\\n rho_i=qtp.operator_to_vector(qtp.ket2dm(ket_i))\\n ket_j = qtp.tensor(qtp.ket([j_list[0]], dim=[3]),\\n qtp.ket([j_list[1]], dim=[3]))\\n rho_j=qtp.operator_to_vector(qtp.ket2dm(ket_j))\\n p = (rho_i.dag()*U*rho_j).data[0, 0]\\n sump += p\\n sump /= 5 # divide by number of non-computational states\\n sump=np.real(sump)\\n L1 = 1-sump\\n return L1\",\n \"def MILP_1(self,xData,uData):\\n print \\\"\\\\n\\\",\\\"*\\\"*80,\\\"\\\\n\\\",\\\"MILP 1: Parameter Estimation\\\\n\\\",\\\"*\\\"*80 \\n model=Model(\\\"parameters\\\")\\n outflow={}\\n d={}\\n bigM=500\\n Q_out={}\\n Q_in={}\\n N=max(l[1] for l in xData.keys())\\n print \\\"x Data size is\\\",N\\n N=max(l[1] for l in uData.keys())\\n print \\\"u Data size is\\\",N\\n for l in self.links:\\n l.d=model.addVar(lb=0,ub=200,obj=0*l.type==\\\"road\\\") \\n for t in range(1,N):\\n d[l,t]=model.addVar(lb=0,ub=200,obj=1)\\n for k in l.outgoing:\\n outflow[l,k,t]=model.addVar(lb=0,ub=200)\\n self.c[l,k]=model.addVar(lb=20,ub=200)\\n self.beta[l,k]=model.addVar(lb=0.2,ub=0.8)\\n self.alpha[l,k]=model.addVar(lb=0,ub=1)\\n self.M[l,k]=model.addVar(lb=0,ub=200)\\n d[\\\"outflow-1\\\",l,k,t]=model.addVar(vtype=GRB.BINARY) \\n d[\\\"outflow-2\\\",l,k,t]=model.addVar(vtype=GRB.BINARY) \\n model.update()\\n for t in range(1,N):\\n for l in self.links:\\n if True:\\n Q_out[l,t]=LinExpr()\\n Q_in[l,t]=LinExpr()\\n Q_out[l,t].addConstant(0)\\n Q_in[l,t].addConstant(0)\\n for k in l.outgoing:\\n model.addConstr(outflow[l,k,t]<=self.beta[l,k]*uData[l,t]*xData[l,t])\\n model.addConstr(outflow[l,k,t]<=self.M[l,k])\\n model.addConstr(outflow[l,k,t]<=self.c[l,k]-self.alpha[l,k]*xData[k,t])\\n model.addConstr(outflow[l,k,t]>=self.beta[l,k]*uData[l,t]*xData[l,t]+bigM*d[\\\"outflow-1\\\",l,k,t]-bigM)\\n model.addConstr(outflow[l,k,t]>=self.M[l,k]+bigM*d[\\\"outflow-2\\\",l,k,t]-bigM)\\n model.addConstr(outflow[l,k,t]>=self.c[l,k]-self.alpha[l,k]*xData[k,t]-bigM*d[\\\"outflow-1\\\",l,k,t]-bigM*d[\\\"outflow-2\\\",l,k,t])\\n Q_out[l,t].add(outflow[l,k,t])\\n for k in l.incoming:\\n Q_in[l,t].add(outflow[k,l,t])\\n if l.type==\\\"road\\\":\\n model.addConstr(xData[l,t+1]<=xData[l,t]- Q_out[l,t] + Q_in[l,t] + d[l,t] + l.lambda_arrival) \\n else:\\n model.addConstr(xData[l,t+1]<=xData[l,t]- uData[l,t]*xData[l,t] + Q_in[l,t] + d[l,t] + l.lambda_arrival)\\n for l in self.links:\\n sum=LinExpr()\\n for k in l.outgoing:\\n sum.add(self.beta[l,k])\\n model.addConstr(sum>=0)\\n \\n# J=QuadExpr()\\n# for l in self.links:\\n# for t in range(1,N):\\n# if l.type==\\\"road\\\":\\n# J.add(d[l,t]*d[l,t])\\n# model.setObjective(J)\\n model.optimize()\\n for l in self.links:\\n l.d=l.d.X\\n for k in l.outgoing:\\n self.beta[l,k]=self.beta[l,k].X\\n self.c[l,k]=self.c[l,k].X\\n self.alpha[l,k]=self.alpha[l,k].X\\n self.M[l,k]=self.M[l,k].X\\n for l in self.links:\\n for t in range(1,N):\\n l.d=max(d[l,t].X,l.d)\\n \\n \\n\\n \\n if True:\\n for t in range(1,N):\\n print \\\"*\\\"*80,\\\"time=\\\",t\\n for l in self.links:\\n print \\\"\\\\n\\\",l,\\\"x is\\\",xData[l,t],\\\"u is\\\",uData[l,t],\\\"x+ is\\\",xData[l,t+1]\\n for k in l.outgoing:\\n print k,\\\"beta:\\\",self.beta[l,k],\\\"outflow\\\",outflow[l,k,t].X\",\n \"def main():\\n if len(sys.argv) != 5:\\n exit(\\\"Usage: python oneta.py train-corpus test-corpus kernel-size output\\\")\\n\\n w1Words = dict()\\n w2Words = dict()\\n W1 = 0\\n W2 = 0\\n\\n D1 = int(sys.argv[3])\\n\\n sys.stderr.write(\\\"First scan of training data\\\\n\\\")\\n \\n J = 0\\n # Read through the corpus to decided which words are in the dense set and which in the sparse set\\n corpus = open(sys.argv[1],\\\"r\\\")\\n for line in corpus:\\n tokens = word_tokenize(line)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if J < D1 and tk_decoded not in w1Words:\\n w1Words[tk_decoded] = W1\\n W1 += 1\\n elif J >= D1 and tk_decoded not in w2Words:\\n w2Words[tk_decoded] = W2\\n W2 += 1\\n J += 1\\n corpus.close()\\n\\n D2 = J - D1\\n\\n # Partition the corpus into a L-shaped matrix\\n sys.stderr.write(\\\"Building matrices\\\")\\n At = lil_matrix((D1,W1))\\n B = lil_matrix((W1,D2))\\n Ct = lil_matrix((D2,W2))\\n\\n corpus = open(sys.argv[1],\\\"r\\\")\\n\\n j = 0\\n for line in corpus:\\n sys.stderr.write(\\\".\\\")\\n tokens = word_tokenize(line)\\n docsq = 0.\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if j < D1: # tk_decoded in w1words\\n tkId = w1Words[tk_decoded]\\n docsq += (At[j,tkId]+1)**2 - (At[j,tkId])**2\\n At[j,tkId] += 1.\\n elif tk_decoded in w1Words:\\n tkId = w1Words[tk_decoded]\\n docsq += (B[tkId,j-D1]+1)**2 - (B[tkId,j-D1])**2\\n B[tkId,j-D1] += 1.\\n else:\\n tkId = w2Words[tk_decoded]\\n docsq += (Ct[j-D1,tkId]+1)**2 - (Ct[j-D1,tkId])**2\\n Ct[j-D1,tkId] += 1.\\n if j < D1:\\n At[j,:] /= math.sqrt(docsq)\\n else:\\n for w in range(0,W1):\\n B[w,j-D1] /= math.sqrt(docsq)\\n Ct[j-D1,:] /= math.sqrt(docsq)\\n j += 1\\n\\n sys.stderr.write(\\\"\\\\nBuild Cn\\\\n\\\")\\n Cn = zeros((D2,1))\\n Ct = Ct.tocsr()\\n for i in range(0,D2):\\n v = ((Ct[i,:] * Ct[i,:].transpose())[0,0])\\n if v == 0:\\n Cn[i,0] = 1.\\n else:\\n Cn[i,0] = v\\n\\n # Building real matrices\\n sys.stderr.write(\\\"Calculating ATA\\\\n\\\")\\n ATA = (At * At.transpose()).todense() # D1 x D1\\n At = At.tocsr()\\n B = B.tocsc()\\n\\n sys.stderr.write(\\\"Solve inverse\\\\n\\\")\\n ATAi = linalg.inv(ATA)\\n\\n # The real calculation is that if we have input vector [ d_1 d_2 ] ^ T \\n # We yield [ (A^T * A)^-1 * A^T ( d1^T - B * (C^T * d2 / Cn) ) (C^T * d2 / Cn)\\n sys.stderr.write(\\\"Calculating projected vectors\\\\n\\\")\\n\\n out = open(sys.argv[4],\\\"w\\\")\\n testDocs = open(sys.argv[2],\\\"r\\\")\\n for testDoc in testDocs:\\n sys.stderr.write(\\\".\\\")\\n corpus = open(sys.argv[1],\\\"r\\\")\\n d1 = zeros((W1,1))\\n d2 = zeros((W2,1))\\n tokens = word_tokenize(testDoc)\\n for token in tokens:\\n tk_decoded = token.decode(\\\"utf-8\\\")\\n if tk_decoded in w1Words:\\n d1[w1Words[tk_decoded],0] += 1\\n elif tk_decoded in w2Words:\\n d2[w2Words[tk_decoded],0] += 1\\n norm = sqrt(sum(d1**2) + sum(d2**2))\\n d1 /= norm \\n d2 /= norm\\n v2 = (Ct * d2) / Cn\\n v1 = ATAi * (At * (d1 - B * v2))\\n for j in range(0,D1+D2):\\n out.write(str(j) + \\\" \\\")\\n out.write(\\\"||| \\\")\\n for j in range(0,D1):\\n out.write(str(v1[j,0]) + \\\" \\\")\\n for j in range(0,D2):\\n out.write(str(v2[j,0]) + \\\" \\\")\\n out.write(\\\"\\\\n\\\")\\n\\n out.flush()\\n out.close()\\n sys.stderr.write(\\\"\\\\n\\\")\",\n \"def optGM(objective_function: \\\"function\\\",\\n set_of_mols_par: SetOfMolecules,\\n subset_of_mols: SetOfMolecules,\\n min_subset_of_mols: SetOfMolecules,\\n chg_method: ChargeMethod,\\n num_of_samples: int,\\n num_of_candidates: int) -> namedtuple:\\n\\n print(\\\" Sampling...\\\")\\n samples = lhs(num_of_samples, chg_method.params_bounds)\\n\\n print(\\\" Calculating of objective function for samples...\\\")\\n samples_rmsd = [objective_function(sample, chg_method, min_subset_of_mols) for sample in samples]\\n\\n print(\\\"\\\\x1b[2K Selecting candidates...\\\")\\n best_samples = samples[list(map(samples_rmsd.index, nsmallest(num_of_candidates * 100, samples_rmsd)))]\\n best_samples_rmsd = [objective_function(sample, chg_method, set_of_mols_par) for sample in best_samples]\\n candidates = best_samples[list(map(best_samples_rmsd.index, nsmallest(num_of_candidates, best_samples_rmsd)))]\\n\\n print(\\\"\\\\x1b[2K Local minimizating...\\\")\\n all_loc_min_course = []\\n opt_candidates = []\\n for params in candidates:\\n opt_params, _, loc_min_course = local_minimization(objective_function, subset_of_mols, chg_method, params)\\n all_loc_min_course.append(loc_min_course[0])\\n opt_candidates.append(opt_params)\\n\\n opt_candidates_rmsd = [objective_function(candidate, chg_method, set_of_mols_par) for candidate in opt_candidates]\\n final_candidate_obj_val = nsmallest(1, opt_candidates_rmsd)\\n final_candidate_index = opt_candidates_rmsd.index(final_candidate_obj_val)\\n final_candidate = opt_candidates[final_candidate_index]\\n\\n print(\\\"\\\\x1b[2K Final local minimizating...\\\")\\n final_params, final_obj_val, loc_min_course = local_minimization(objective_function, set_of_mols_par, chg_method, final_candidate)\\n all_loc_min_course[final_candidate_index].extend(loc_min_course[0])\\n\\n return namedtuple(\\\"chgs\\\", [\\\"params\\\",\\n \\\"obj_val\\\",\\n \\\"loc_min_courses\\\"])(final_params,\\n final_obj_val,\\n all_loc_min_course)\",\n \"def objective(self,w):\\n diffs = self.get_y_times_diffs(self.get_split_weights(w))\\n #print diffs, sigmoid(diffs)\\n obj = -np.sum(np.log(sigmoid(diffs))) #negative, since minimising\\n # regularisation\\n obj += 0.5 * self.alpha * np.dot(w[:self.interp_index[0]], w[:self.interp_index[0]])\\n return obj\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\n \"def potentialSolver3(self, w, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n # Step 1: create *integer* array the same size as u \\n x = np.zeros_like(self.phi,dtype=np.int)\\n\\n # Step 2: populate all non-boundary cells with running numbers from 1 to (n-2)^2\\n x[1:-1,1:-1,1:-1] = np.arange(1,(self.ni-2)*(self.nj-2)*(self.nk-2)+1).reshape(self.ni-2,self.nj-2,self.nk-2)\\n\\n # Step 3: get indices of even (red) and odd (black) points\\n ir, jr, kr = np.where((x>0) & (x%2 == 0)) # indices of red pts = indices of even numbers\\n ib, jb, kb = np.where((x>0) & (x%2 == 1)) # indices of black pts = indices of odd numbers\\n\\n\\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n \\n \\\"\\\"\\\"\\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n # Red point update\\n self.phi[ir,jr,kr] = (1-w)*self.phi[ir,jr,kr] + (1.0/6.0)*w*(self.phi[ir+1,jr,kr] + self.phi[ir-1,jr,kr] +\\\\\\n self.phi[ir,jr+1,kr] + self.phi[ir,jr-1,kr] +\\\\\\n self.phi[ir,jr,kr+1] + self.phi[ir,jr,kr-1] +\\\\\\n (self.rho[ir,jr,kr]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n # Black point update\\n self.phi[ib,jb,kb] = (1-w)*self.phi[ib,jb,kb] + (1.0/6.0)*w*(self.phi[ib+1,jb,kb] + self.phi[ib-1,jb,kb] +\\\\\\n self.phi[ib,jb+1,kb] + self.phi[ib,jb-1,kb] +\\\\\\n self.phi[ib,jb,kb+1] + self.phi[ib,jb,kb-1] +\\\\\\n (self.rho[ib,jb,kb]/self.EPS_0)*(self.dh[0]*self.dh[1]))\\n\\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\",\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 find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\\n\\n # Create a new model\\n m = Model(\\\"hamiltonian_cycle\\\")\\n \\n # Create variables\\n x_vars = {}\\n u_vars = {}\\n for var1 in permute(G.vertices()):\\n for var2 in permute(G.vertices()):\\n if var1 != var2:\\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\\\"x_\\\"+str(var1)+'_'+str(var2))\\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\\\"u_\\\"+str(var1))\\n m.update()\\n \\n for var in G.vertices():\\n if var != START_NODE:\\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\\n #print(cur_incoming)\\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\\n \\n if var != END_NODE:\\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\\n #print(cur_outgoing)\\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\\n \\n for var1 in G.vertices():\\n for var2 in G.vertices():\\n if var1 != var2:\\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\\n #print(c)\\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\\n \\n # Set objective\\n #try:\\n edge_weights = permute(G.get_edge_weights(weights))\\n if probs_instead_of_weights:\\n all_probs = []\\n for v in G.vertices():\\n if v != END_NODE:\\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\\n S = logsumexp([x[1] for x in batch_scores])\\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\\n all_probs.extend(batch_scores)\\n edge_weights = all_probs\\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\\n #except TypeError:\\n # return None\\n \\n m.setObjective(objective,GRB.MINIMIZE)\\n m.update()\\n code = m.optimize()\\n \\n try:\\n return [k for k,v in x_vars.items() if v.x > 0.98]\\n except GurobiError:\\n return None\",\n \"def penaltyFactor(m):\\n \\\"\\\"\\\" m in GeV \\\"\\\"\\\"\\n if m*m>0.71:\\n return math.pow(m*m/0.71,-4)\\n else:\\n return 1\",\n \"def reduce(self, threshold):\\n def percentage_change(old, new):\\n return (old - new) / old\\n real_reduction_iterations = 0\\n padic_reduction_iterations = 0\\n cont_reduction_iterations = 0\\n factor = len(self.constants.primes) + 1\\n \\n print('initial bound',max(self.coefficients['n1_bound'],max(self.coefficients['Z_bounds'])))\\n\\n # First, go through the real reduction loop.\\n current_n1_bound = self.coefficients['n1_bound']\\n current_diff_bound = None\\n while True:\\n real_reduction_iterations += 1\\n logging.info(\\\"Real Reduction - Iteration %d\\\" % real_reduction_iterations)\\n\\n large_constant = self.calculate_large_constant(current_n1_bound, factor)\\n logging.info(\\\"Large constant contains %d digits \\\" % large_constant.ndigits())\\n\\n # Find a new bound on n_1 - n_k\\n new_diff_bound = self.real_reduce(current_n1_bound, large_constant)\\n logging.info(\\\"Current bound on n1: \\\" + str(current_n1_bound))\\n self.update_real_constants(new_diff_bound)\\n logging.info(\\\"new diff bound: \\\" + str(new_diff_bound))\\n logging.info(\\\"New bound on n1: \\\" + str(self.coefficients[\\\"n1_bound\\\"]))\\n logging.info(\\\"New bound on zi: \\\" + str(self.coefficients['Z_bounds']))\\n \\n if percentage_change(current_n1_bound, self.coefficients[\\\"n1_bound\\\"]) < self.threshold:\\n logging.info(\\\"New bound did not improve in the real step; real reduction process is done.\\\")\\n factor = factor + 5\\n break\\n\\n current_n1_bound = self.coefficients['n1_bound']\\n current_diff_bound = new_diff_bound\\n\\n # Second, go through the p-adic reduction loop.\\n current_Z_bounds = self.coefficients['Z_bounds']\\n while True:\\n padic_reduction_iterations += 1\\n logging.info(\\\"p-adic Reduction - Iteration %d\\\" % padic_reduction_iterations)\\n\\n new_Z_bounds = self.padic_reduce(math.ceil(current_diff_bound))\\n logging.info(\\\"New bound on zi: \\\" + str(new_Z_bounds))\\n logging.info(\\\"Current bound on n1: \\\" + str(current_n1_bound))\\n new_n1_bound = self.update_padic_constants(new_Z_bounds)\\n logging.info(\\\"New bound on n1: \\\" + str(new_n1_bound))\\n if percentage_change(current_n1_bound, new_n1_bound) < self.threshold:\\n logging.info(\\\"New bound did not improve in the p-adic step; p-adic reduction process is done.\\\")\\n break\\n\\n current_n1_bound = new_n1_bound\\n\\n print(current_n1_bound)\\n\\n return self.constants\",\n \"def penalty_objective(Z_0, Z_1, Z_2, psi, theta):\\n return theta * sum(map(l1_od_norm, Z_0)) + (1 - theta) * sum(map(psi, Z_2 - Z_1))\",\n \"def minimize_neg_lbl(self):\\n if self.spatial_only:\\n init_index = 0 # anything should work here\\n else:\\n init_index = np.mean((self.energy_likelihood._min_index,\\n self.energy_likelihood._max_index))\\n \\n init_ns = np.arange(self.fit_input['N']).mean()\\n\\n m = Minuit(self._neg_lbl,\\n n_s = init_ns,\\n gamma = init_index)\\n\\n m.errors = [1, 0.1]\\n m.errordef = Minuit.LIKELIHOOD # 0.5\\n \\n if self.spatial_only:\\n m.fixed['gamma'] = True\\n m.limits = [(0, self.fit_input['N']-1),\\n (None,None)]\\n else:\\n m.limits = [(0, self.fit_input['N']-1),\\n (self.energy_likelihood._min_index,\\n self.energy_likelihood._max_index)]\\n\\n m.migrad()\\n self.minuit = m\\n self._best_fit_ns = m.values[\\\"n_s\\\"]\\n self._best_fit_index = m.values[\\\"gamma\\\"]\\n return m, self._best_fit_ns, self._best_fit_index\",\n \"def mole_jameson_insertion_init(D, d, C, L=None, minimize_K=False,\\n strain_criterion='all' ):\\n\\n callback_configurations = []\\n if strain_criterion=='proximity_ranking' or strain_criterion=='all':\\n callback_configurations.append( \\n ( _create_new_criteria_function(lm=0.0,mm=0.0), \\\"farthest\\\") )\\n \\n if strain_criterion=='min_strain':\\n #or strain_criterion=='all': # <- this is already is in 'augumented_min_strain'\\n callback_configurations.append(\\n (_create_new_criteria_function(lm=0.0,mm=1.0), \\\"farthest\\\") )\\n \\n if strain_criterion=='clarke_wright':\\n #or strain_criterion=='all': # <- this is already in 'augumented_min_strain'\\n callback_configurations.append( \\n # when mu = lambda-1, initiate route with savings criteria\\n (_create_new_criteria_function(lm=2.0,mm=1.0), \\\"strain\\\") )\\n \\n if strain_criterion=='gaskell' or strain_criterion=='all':\\n lambda_mults = [1.25, 1.5, 1.75, 2.0]\\n for glm in lambda_mults:\\n callback_configurations.append( \\n # when mu = lambda-1, initiate route with savings criteria\\n (_create_new_criteria_function(lm=glm,mm=glm-1.0), \\\"strain\\\") )\\n \\n if strain_criterion=='augumented_min_strain' or strain_criterion=='all':\\n # the lm=2.0, mm=1.0 is already in 'gaskell'\\n lambda_mults = [0, 0.5, 1, 1.5] if strain_criterion=='all' else\\\\\\n [0, 0.5, 1, 1.5, 2.0]\\n for alm in lambda_mults:\\n callback_configurations.append( \\n ( _create_new_criteria_function(lm=alm,mm=1.0),\\n \\\"strain\\\" if alm-1.0==1.0 else \\\"farthest\\\" ) )\\n \\n ## Find the best solution among the active strain criterions \\n best_sol = None\\n best_f = None\\n best_K = None\\n interrupted = False\\n for strain_function, init_method in callback_configurations:\\n \\n sol, sol_f, sol_K = None, float('inf'), float('inf')\\n try:\\n sol = cheapest_insertion_init(D, d, C, L, minimize_K=False,\\n emerging_route_count=1,\\n initialize_routes_with=init_method,\\n insertion_strain_callback=strain_function,\\n insert_callback=_try_insert_2opt_and_update)\\n sol = _refine_solution(sol, D, d, C, L, minimize_K)\\n # LS may make some of the routes empty\\n sol = without_empty_routes(sol)\\n \\n except KeyboardInterrupt as e: #or SIGINT\\n # some of the strain function insertion runs was interrupted\\n if len(e.args)>0 and type(e.args[0]) is list:\\n sol = e.args[0]\\n interrupted = True\\n \\n if sol:\\n sol_f = objf(sol, D)\\n sol_K = sol.count(0)-1\\n if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):\\n best_sol = sol\\n best_f = sol_f\\n best_K = sol_K\\n \\n if interrupted:\\n raise KeyboardInterrupt(best_sol)\\n \\n return best_sol\",\n \"def minimization(X, Y, r, L, max_iter):\\r\\n # Define the number of data points and dimension\\r\\n N = float(X.shape[0])\\r\\n d = X.shape[1]\\r\\n # Calculate the number of classes, q\\r\\n classes, q = [], 0\\r\\n for i in Y:\\r\\n if i not in classes:\\r\\n classes.append(i)\\r\\n q += 1\\r\\n # Calculate averages and M matrix\\r\\n classes_X = [[] for i in range(q)]\\r\\n for i, h in enumerate(classes):\\r\\n for j, k in enumerate(Y):\\r\\n if k == i:\\r\\n classes_X[i].append(X[j])\\r\\n mu_g = []\\r\\n for i, j in enumerate(classes_X):\\r\\n mu_g.append(np.mean(j, axis=0))\\r\\n mu = np.mean(X, axis=0)\\r\\n M = np.zeros((q, d))\\r\\n for i in range(q):\\r\\n M[i] = mu_g[i] - mu\\r\\n # Calculate sigma_xx\\r\\n Xc = np.transpose(X[0] - mu)\\r\\n for i in range(1, int(N)):\\r\\n Xc = np.vstack((Xc, np.transpose(X[i] - mu)))\\r\\n sigma_xx = np.matmul(Xc.T, Xc) / N\\r\\n # Calculate the size of each class\\r\\n Ng = []\\r\\n for i in classes:\\r\\n Ng.append((Y == i).sum())\\r\\n # Calculate the C matrix\\r\\n C = np.zeros((q, q))\\r\\n for i in range(q):\\r\\n C[i, i] = Ng[i] / N\\r\\n # Calculate C^(-1/2)\\r\\n C12 = np.zeros((q, q))\\r\\n for i in range(q):\\r\\n C12[i, i] = C[i, i] ** -0.5\\r\\n # Calculate initial theta\\r\\n Id = np.identity(r)\\r\\n z = np.zeros((q - r, r))\\r\\n theta = np.matmul(C12, np.vstack((Id, z)))\\r\\n # Initialize flags and error tolerance\\r\\n CONVERGED = False\\r\\n MAXITER_REACHED = False\\r\\n eps = 1e-06\\r\\n # Define constraints\\r\\n cons = ({'type': 'eq', 'fun': lambda x: constraint_1(x, q, r, C)},\\r\\n {'type': 'eq', 'fun': lambda x: constraint_2(x, q, r, C)})\\r\\n # Initialize error\\r\\n b = np.random.random((d, r))\\r\\n error = F_lambda(theta, b, q, d, r, M, C, sigma_xx, L)\\r\\n cost = []\\r\\n # Initialize counters for individual algorithm iterations\\r\\n b_it, theta_it = 0, 0\\r\\n # Run minimization algorithm\\r\\n for i in range(max_iter):\\r\\n # Save value of error from the previous iteration\\r\\n prev_error = error\\r\\n if i % 2 == 0:\\r\\n # Minimize b with respect to fixed theta using BFGS\\r\\n b_flat = b.flatten()\\r\\n b_min = minimize(lambda x: F_lambda(\\r\\n theta, x, q, d, r, M, C, sigma_xx, L), b_flat, method='BFGS')\\r\\n b = np.reshape(b_min.x, (d, r))\\r\\n b_it += b_min.nit\\r\\n # Check if rank(Mb) >= r\\r\\n test = np.linalg.matrix_rank(np.matmul(M, b))\\r\\n if test < r:\\r\\n raise Exception(\\\"Error: rank(Mb) < r\\\")\\r\\n else:\\r\\n # Minimize theta with respect to fixed b using SLSQP\\r\\n theta_flat = theta.flatten()\\r\\n theta_min = minimize(lambda x: F_lambda(\\r\\n x, b, q, d, r, M, C, sigma_xx, L), theta_flat, method='SLSQP',\\r\\n constraints=cons)\\r\\n theta = np.reshape(theta_min.x, (q, r))\\r\\n theta_it += theta_min.nit\\r\\n # Check if function has been minimized\\r\\n error = F_lambda(theta, b, q, d, r, M, C, sigma_xx, L)\\r\\n cost.append(error)\\r\\n CONVERGED = abs(error - prev_error) < eps\\r\\n if CONVERGED:\\r\\n break\\r\\n # Check if the maximum number of iterations has been reached\\r\\n MAXITER_REACHED = i == max_iter - 1\\r\\n if CONVERGED:\\r\\n print(\\\"Overall algorithm iterations: %d\\\" % i)\\r\\n print(\\\"Combined number of iterations for BFGS: %d\\\" % b_it)\\r\\n print(\\\"Combined number of iterations for SLSQP: %d\\\" % theta_it)\\r\\n print(\\\"Total number of iterations: %d\\\" % (b_it + theta_it))\\r\\n elif MAXITER_REACHED:\\r\\n print(\\\"The maximum number of iterations has been reached.\\\")\\r\\n it = np.arange(0, i + 1)\\r\\n return b, theta, mu, it, cost\",\n \"def _inexact_alm_l1(imgflt_stack,options):\\n # Get basic image information and reshape input\\n img_width = imgflt_stack.shape[0]\\n img_height = imgflt_stack.shape[1]\\n img_size = img_width* img_height\\n img_3d = imgflt_stack.shape[2]\\n imgflt_stack = np.reshape(imgflt_stack,(img_size, img_3d))\\n options['weight'] = np.reshape(options['weight'],imgflt_stack.shape)\\n\\n # Matrix normalization factor\\n temp = np.linalg.svd(imgflt_stack,full_matrices=False,compute_uv=False)\\n norm_two = np.float64(temp[0])\\n del temp\\n\\n # A is a low rank matrix that is being solved for\\n A = np.zeros(imgflt_stack.shape,dtype=np.float64)\\n A_coeff = np.ones((1, img_3d),dtype=np.float64) # per image scaling coefficient, accounts for things like photobleaching\\n A_offset = np.zeros((img_size,1),dtype=np.float64) # offset per pixel across all images\\n\\n # E1 is the additive error. Since the goal is determining the background signal, this is the real signal at each pixel\\n E1 = np.zeros(imgflt_stack.shape,dtype=np.float64)\\n\\n # Normalization factors\\n ent1 = np.float64(1) # flatfield normalization\\n ent2 = np.float64(10) # darkfield normalization\\n\\n # Weights\\n weight_upd = _dct2(np.mean(np.reshape(A,(img_width, img_height, img_3d)),2))\\n\\n # Initialize gradient and weight normalization factors\\n Y1 = np.float64(0)\\n mu = np.float64(12.5)/norm_two\\n mu_bar = mu * 10**7\\n rho = np.float64(1.5)\\n\\n # Frobenius norm\\n d_norm = np.linalg.norm(imgflt_stack,'fro')\\n\\n # Darkfield upper limit and offset\\n B1_uplimit = np.min(imgflt_stack)\\n B1_offset = np.float64(0)\\n\\n # Perform optimization\\n iternum = 0\\n converged = False\\n while not converged:\\n iternum += 1\\n\\n # Calculate the flatfield using existing weights, coefficients, and offsets\\n W_idct_hat = _idct2(weight_upd)\\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\\n temp_W = np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\\n\\n # Update the weights\\n temp_W = np.reshape(temp_W,(img_width, img_height, img_3d))\\n temp_W = np.mean(temp_W,2)\\n weight_upd = weight_upd + _dct2(temp_W)\\n weight_upd = np.max(np.reshape(weight_upd - options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0) + np.min(np.reshape(weight_upd + options['lambda']/(ent1*mu),(img_width, img_height,1)),-1,initial=0)\\n W_idct_hat = _idct2(weight_upd)\\n\\n # Calculate the flatfield using updated weights\\n A = np.matmul(np.reshape(W_idct_hat,(img_size,1)),A_coeff) + A_offset\\n\\n # Determine the error\\n E1 = E1 + np.divide(imgflt_stack - A - E1 + np.multiply(1/mu,Y1),ent1)\\n E1 = np.max(np.reshape(E1 - options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0) + np.min(np.reshape(E1 + options['weight']/(ent1*mu),(img_size, img_3d,1)),-1,initial=0)\\n\\n # Calculate the flatfield coefficients by subtracting the errors from the original data\\n R1 = imgflt_stack-E1\\n A_coeff = np.reshape(np.mean(R1,0)/np.mean(R1),(1, img_3d))\\n A_coeff[A_coeff<0] = 0 # pixel values should never be negative\\n\\n # Calculate the darkfield component if specified by the user\\n if options['darkfield']:\\n # Get images with predominantly background pixels\\n validA1coeff_idx = np.argwhere(A_coeff<1)[:,1]\\n R1_upper = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1)).astype(np.float64)>(np.float64(np.mean(W_idct_hat))-np.float64(10**-5)))[:,0],:]\\n R1_upper = np.mean(R1_upper[:,validA1coeff_idx],0)\\n R1_lower = R1[np.argwhere(np.reshape(W_idct_hat,(-1,1))<np.mean(W_idct_hat)+np.float64(10**-5))[:,0],:]\\n R1_lower = np.mean(R1_lower[:,validA1coeff_idx],0)\\n B1_coeff = (R1_upper-R1_lower)/np.mean(R1)\\n k = validA1coeff_idx.size\\n\\n # Calculate the darkfield offset\\n temp1 = np.sum(np.square(A_coeff[0,validA1coeff_idx]))\\n temp2 = np.sum(A_coeff[0,validA1coeff_idx])\\n temp3 = np.sum(B1_coeff)\\n temp4 = np.sum(A_coeff[0,validA1coeff_idx]*B1_coeff)\\n temp5 = temp2 * temp3 - k*temp4\\n if temp5 == 0:\\n B1_offset = np.float64(0)\\n else:\\n B1_offset = (temp1*temp3-temp2*temp4)/temp5\\n B1_offset = np.max(B1_offset,initial=0)\\n B1_offset = np.min(B1_offset,initial=B1_uplimit/(np.mean(W_idct_hat)+10**-7))\\n B_offset = B1_offset * np.mean(W_idct_hat) - B1_offset*np.reshape(W_idct_hat,(-1,1))\\n\\n # Calculate darkfield\\n A1_offset = np.reshape(np.mean(R1[:,validA1coeff_idx],1),(-1,1)) - np.mean(A_coeff[0,validA1coeff_idx]) * np.reshape(W_idct_hat,(-1,1))\\n A1_offset = A1_offset - np.mean(A1_offset)\\n A_offset = A1_offset - np.mean(A1_offset) - B_offset\\n\\n # Update darkfield weights\\n W_offset = _dct2(np.reshape(A_offset,(img_width, img_height)))\\n W_offset = np.max(np.reshape(W_offset - options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0) \\\\\\n + np.min(np.reshape(W_offset + options['lambda_darkfield']/(ent2*mu),(img_width, img_height,1)),-1,initial=0)\\n\\n # Calculate darkfield based on updated weights\\n A_offset = _idct2(W_offset)\\n A_offset = np.reshape(A_offset,(-1,1))\\n A_offset = np.max(np.reshape(A_offset - options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0) \\\\\\n + np.min(np.reshape(A_offset + options['lambda_darkfield']/(ent2*mu),(A_offset.shape[0],A_offset.shape[1],1)),-1,initial=0)\\n A_offset = A_offset + B_offset\\n\\n # Loss\\n Z1 = imgflt_stack - A - E1\\n\\n # Update weight regularization term\\n Y1 = Y1 + mu*Z1\\n\\n # Update learning rate\\n mu = np.min(mu*rho,initial=mu_bar)\\n\\n # Stop if loss is below threshold\\n stopCriterion = np.linalg.norm(Z1,ord='fro')/d_norm\\n if stopCriterion < options['optimization_tol'] or iternum > options['max_iterations']:\\n converged = True\\n\\n # Calculate final darkfield image\\n A_offset = A_offset + B1_offset * np.reshape(W_idct_hat,(-1,1))\\n\\n return A,E1,A_offset\",\n \"def selection_correction_method1_v2(tree, scale, h_in, h_out):\\n #h_in = ROOT.TH1D(\\\"h_in\\\", \\\"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n #h_out = ROOT.TH1D(\\\"h_out\\\", \\\"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n for event in tree:\\n cut = [0, 0]\\n S15_ch = i_channel(0, event)\\n bpm_ch = i_channel(4, event)\\n RT = event.DD_Rise[S15_ch]\\n S15_w2 = event.DD_AmplADU[S15_ch]\\n onset = event.DD_Rise10pct[S15_ch]\\n if cut[0]==0:\\n # first cut: for inside onset window\\n # if event passes the first cuts\\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n # calculation of the time of flight\\n tof = (cfd_pmt-cfd_bpm)%400\\n #cut on tof: time of flight of the neutron\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n # fill histogram inside onset window\\n h_in.Fill(energy2)\\n cut[0]=1\\n break\\n if cut[1]==0:\\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n tof = (cfd_pmt-cfd_bpm)%400\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n h_out.Fill(energy2)\\n cut[1]=1\\n break\",\n \"def CheckCouplings(params, verbose=False):\\n l1 = params[0]\\n l2 = params[1]\\n l3 = params[2]\\n gx = params[3]\\n m = model_2f(l1, l2, l3, y_t_interpol(np.log(v/mz)), gx)\\n minima, success = m.findMinimum() #the boolean success is added because we cannot trust the minima if numpy.optimize.minimize has failed\\n if not verbose:\\n tolvevh = 2.0\\n tolmh = 2.0\\n condition0 = abs(minima-v) < tolvevh\\n if condition0.any() and success:\\n ddVtot = nd.Hessian(m.Vtot_0T)\\n hess = ddVtot(minima)\\n masses = np.linalg.eigvalsh(hess) #computes masses...\\n positive_condition = masses > 0\\n if(positive_condition.all()): #we will only check them IF they are positive\\n masses = np.sqrt(np.abs(masses))\\n condition1 = abs(masses-mh) < tolmh\\n if condition1.any():\\n stability = m.CheckStability() #we check the stability of the model\\n f = open(file_name, 'a')\\n line0 = str(l1)+' '+str(l2)+' '+str(l3)+' '+str(gx)+' '+str(minima[0])+' '+str(minima[1])+' '+str(masses[0])+' '+str(masses[1]) #we print everything\\n line0 = line0 + ' '+str(stability)\\n f.write(line0+'\\\\n')\\n f.write('-'*90+'\\\\n')\\n f.close()\\n else:\\n \\\"\\\"\\\"\\n Just checks the minima of the model m, the masses of the particles and whether it is stable or not\\n Output: prints the information\\n \\\"\\\"\\\"\\n print \\\"Minimum at T = 0.0: \\\", minima, success\\n print \\\"Masses: \\\"\\n ddVtot = nd.Hessian(m.Vtot_0T)\\n hess = ddVtot(minima)\\n print np.sqrt(np.linalg.eigvalsh(hess))\\n print 'Stable: ', m.CheckStability()==1\",\n \"def solve_l1(y, A_fun, AT_fun, lambda_l1, reshape_img_fun, show_img_progress=False, alpha=0.2, max_iter=100, solver_tol=1e-6):\\n\\n\\n obj_lss = np.zeros(max_iter)\\n x_zs = np.zeros(max_iter)\\n u_norms = np.zeros(max_iter)\\n times = np.zeros(max_iter)\\n\\n ATy = AT_fun(y)\\n x_shape = ATy.shape\\n d = np.prod(x_shape)\\n\\n def A_cgs_fun(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x)) + alpha * x\\n return vec(y)\\n A_cgs = LinearOperator((d,d), matvec=A_cgs_fun, dtype='float')\\n\\n def compute_p_inv_A(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs, vec(b), x0=vec(z0), tol=1e-3, maxiter=100)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n\\n def A_cgs_fun_init(x):\\n x = np.reshape(x, x_shape, order='F')\\n y = AT_fun(A_fun(x))\\n return vec(y)\\n A_cgs_init = LinearOperator((d,d), matvec=A_cgs_fun_init, dtype='float')\\n\\n def compute_init(b, z0):\\n (z,info) = sp.sparse.linalg.cgs(A_cgs_init, vec(b), x0=vec(z0), tol=1e-2)\\n if info > 0:\\n print('cgs convergence to tolerance not achieved')\\n elif info <0:\\n print('cgs gets illegal input or breakdown')\\n z = np.reshape(z, x_shape, order='F')\\n return z\\n\\n # initialize z and u\\n z = compute_init(ATy, ATy)\\n u = np.zeros(x_shape)\\n\\n\\n plot_normalozer = matplotlib.colors.Normalize(vmin=0.0, vmax=1.0, clip=True)\\n\\n\\n start_time = timeit.default_timer()\\n\\n for iter in range(max_iter):\\n\\n # x-update\\n net_input = z+u\\n Wzu, wbook = wavelet_transform(net_input)\\n q = soft_threshold(Wzu, lambda_l1/alpha)\\n x = inverse_wavelet_transform(q, wbook, x_shape)\\n x = np.reshape(x, x_shape)\\n\\n # z-update\\n b = ATy + alpha * (x - u)\\n z = compute_p_inv_A(b, z)\\n\\n # u-update\\n u += z - x;\\n\\n if show_img_progress == True:\\n\\n fig = plt.figure('current_sol')\\n plt.gcf().clear()\\n fig.canvas.set_window_title('iter %d' % iter)\\n plt.subplot(1,3,1)\\n plt.imshow(reshape_img_fun(np.clip(x, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('x')\\n plt.subplot(1,3,2)\\n plt.imshow(reshape_img_fun(np.clip(z, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('z')\\n plt.subplot(1,3,3)\\n plt.imshow(reshape_img_fun(np.clip(net_input, 0.0, 1.0)), interpolation='nearest', norm=plot_normalozer)\\n plt.title('netin')\\n plt.pause(0.00001)\\n\\n\\n obj_ls = 0.5 * np.sum(np.square(y - A_fun(x)))\\n x_z = np.sqrt(np.mean(np.square(x-z)))\\n u_norm = np.sqrt(np.mean(np.square(u)))\\n\\n print('iter = %d: obj_ls = %.3e |x-z| = %.3e u_norm = %.3e' % (iter, obj_ls, x_z, u_norm))\\n\\n\\n obj_lss[iter] = obj_ls\\n x_zs[iter] = x_z\\n u_norms[iter] = u_norm\\n times[iter] = timeit.default_timer() - start_time\\n\\n if x_z < solver_tol:\\n break\\n\\n infos = {'obj_lss': obj_lss, 'x_zs': x_zs, 'u_norms': u_norms,\\n 'times': times, 'alpha':alpha, 'lambda_l1':lambda_l1,\\n 'max_iter':max_iter, 'solver_tol':solver_tol}\\n\\n\\n return (x, z, u, infos)\",\n \"def _lp_msne(self, self_support, opponent_support, player=1):\\n\\n # logging.info(f'_lp_msne for player {player}')\\n ns, U = len(self.s[player % 2]), self.U[player-1]\\n if player != 1:\\n U = U.T\\n\\n f, support_u = np.array([0.0 for _ in range(ns+1)]), U[np.where(self_support == 1)]\\n\\n a_temp = np.array([[0.] if i == 0 else [-1.] for i in range(support_u.shape[0]+1)])\\n Aeq = np.concatenate([a_temp, np.concatenate([np.ones((1, support_u.shape[1])), support_u], axis=0)], axis=1)\\n Beq = np.array([[1.] if i == 0 else [0.] for i in range(Aeq.shape[0])])\\n # logging.info(f'Aeq: {Aeq}, {Aeq.shape}')\\n # logging.info(f'Beq: {Beq}, {Beq.shape}')\\n\\n si_0 = np.where(self_support == 1)[0][0]\\n not_support = U[np.where(self_support == 0)]\\n # logging.info(f'not_support: {not_support}, {not_support.shape}')\\n\\n Aub = not_support - U[[si_0], :]\\n Aub = np.concatenate([np.zeros((Aub.shape[0], 1)), Aub], axis=1)\\n Bub = np.zeros((Aub.shape[0], 1))\\n # logging.info(f'Aub: {Aub}, {Aub.shape}')\\n # logging.info(f'Bub: {Bub}, {Bub.shape}')\\n\\n if not_support.shape[0] == 0 or not_support.shape[1] == 0:\\n Aub, Bub = None, None\\n\\n p_bounds = np.array([(zero_p, one_m) for _ in range(ns)])\\n p_bounds[np.where(opponent_support == 0)] = (0, 0)\\n\\n return linprog(f, A_ub=Aub, b_ub=Bub, A_eq=Aeq, b_eq=Beq, bounds=[(None, None), *p_bounds], method='simplex')\",\n \"def crossing_minimization(self):\\n self.layer_sweep()\",\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 _optimise(self):\\n pass\",\n \"def auxminrho2(x,m_ind):\\n \\n f = 0.0\\n for k_ind in range(cfg.nomax):\\n f -= auxmin_cc_piece(x,k_ind,m_ind) \\n\\n return f\",\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 l2Min(A, b):\\n #set up the matrices\\n solvers.options['show_progress'] = False\\n m,n = A.shape\\n Q = matrix(2*np.eye(n))\\n r = matrix(np.zeros(n))\\n A = matrix(A.astype(float))\\n b = matrix(b.astype(float))\\n #solve the matrices\\n sol=solvers.qp(Q, r,A=A,b=b)\\n return np.ravel(sol['x']), sol['primal objective']\",\n \"def second_heuristic(self):\\r\\n directions = [[-1, -1], [-1, 1], [1, 1], [1, -1]]\\r\\n # aceasta matrice indica valoarea pe care o are mutarea unei piese pe o celula aleasa\\r\\n # se va aduna la media ponderilor adunate in lista weights\\r\\n\\r\\n # mijlocul tablei este punctul cel mai vulnerabil\\r\\n # in timp ce lateralele sunt sigure,iar linia bazei transforma piesa in rege\\r\\n\\r\\n points = [[0, 4, 0, 4, 0, 4, 0, 4],\\r\\n [4, 0, 3, 0, 3, 0, 3, 0],\\r\\n [0, 3, 0, 2, 0, 2, 0, 4],\\r\\n [4, 0, 2, 0, 1, 0, 3, 0],\\r\\n [0, 3, 0, 1, 0, 2, 0, 4],\\r\\n [4, 0, 2, 0, 1, 0, 3, 0],\\r\\n [0, 3, 0, 2, 0, 2, 0, 4],\\r\\n [4, 0, 4, 0, 4, 0, 4, 0]]\\r\\n\\r\\n weights = [0 for i in range(4)]\\r\\n whites, blacks = 0, 0\\r\\n for i in range(8):\\r\\n for j in range(8):\\r\\n\\r\\n # numaram discurile de fiecare culoarea\\r\\n blacks += 1 if self.matrix[i][j] in ['N', 'n'] else 0\\r\\n whites += 1 if self.matrix[i][j] in ['A', 'a'] else 0\\r\\n\\r\\n if self.matrix[i][j] in [self.current_player, self.current_player.upper()]:\\r\\n\\r\\n # daca e piesa normala\\r\\n if self.matrix[i][j] == self.current_player:\\r\\n weights[0] += 4\\r\\n\\r\\n # cat de aproape este piesa de a deveni rege ( nr de linii din tabla - cate mai are pana ajunge pe ultima linie)\\r\\n\\r\\n # cu cat se apropie piesa mai multe de a deveni rege, scorul creste( negru - rege pentru i=0, alb -rege pentru i =7)\\r\\n if self.matrix[i][j] == 'n':\\r\\n weights[1] += (7 - i)\\r\\n elif self.matrix[i][j] == 'a':\\r\\n weights[1] += i\\r\\n else:\\r\\n # daca e piesa rege\\r\\n weights[0] += 8\\r\\n\\r\\n # cat de aproape este piesa rege de celelalte piese\\r\\n for d in directions:\\r\\n if self.matrix[i][j] == self.current_player.upper():\\r\\n # gaseste pe diagonala in directia d, o piesa adversara,daca exista\\r\\n x, y = self.find_piesa(i, j, d)\\r\\n if x and y:\\r\\n weights[2] += (x - i) * (x - i) + (y - j) * (y - j)\\r\\n vx = d[0] + i\\r\\n vy = d[1] + j\\r\\n back_x = i - d[0]\\r\\n back_y = j - d[1]\\r\\n next_x, next_y = vx + d[0], vy + d[1]\\r\\n # piesele pe care le poate captura jucatorul, daca e piesa rege are un scor mai mare\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(next_x, next_y) and self.matrix[next_x][next_y] == '.':\\r\\n if self.matrix[next_x][next_y] == self.opponent().upper():\\r\\n weights[3] += 7\\r\\n else:\\r\\n weights[3] += 4\\r\\n # piese care pot fi capturate; la fel daca este piesa rege atunci se scade mai mult scorul\\r\\n if self.bounded(vx, vy) and self.matrix[vx][vy] in [self.opponent(), self.opponent().upper()]:\\r\\n if self.bounded(back_x, back_y) and self.matrix[back_x][back_y] == '.':\\r\\n if self.matrix[vx][vy] == self.opponent().upper():\\r\\n weights[3] -= 6\\r\\n else:\\r\\n weights[3] -= 3\\r\\n # adunam piesa la media sumei date pentru a face AI-ul in caz de egalitate a scorului\\r\\n # sa imi aleaga piesa care ma pozitioneaza mai bine\\r\\n if self.move:\\r\\n return sum(weights) / 4 + points[self.move[0]][self.move[1]]\\r\\n return sum(weights) / 4\\r\\n\\r\\n def __str__(self):\\r\\n s = ' '\\r\\n for i in range(8):\\r\\n s += str(i) + ' '\\r\\n s += '\\\\n'\\r\\n for index, line in enumerate(self.matrix):\\r\\n s += str(chr(index + ord('a'))) + ' '\\r\\n for el in line:\\r\\n s += str(el) + ' '\\r\\n s += '\\\\n'\\r\\n\\r\\n return s\",\n \"def weber_MS(I,J,x,y,w):\\n M = max([((x[i]-x[j])**2 + (y[i]-y[j])**2) for i in I for j in I])\\n model = Model(\\\"weber - multiple source\\\")\\n X,Y,v,u = {},{},{},{}\\n xaux,yaux,uaux = {},{},{}\\n for j in J:\\n X[j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"X(%s)\\\"%j)\\n Y[j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"Y(%s)\\\"%j)\\n for i in I:\\n v[i,j] = model.addVar(vtype=\\\"C\\\", name=\\\"v(%s,%s)\\\"%(i,j))\\n u[i,j] = model.addVar(vtype=\\\"B\\\", name=\\\"u(%s,%s)\\\"%(i,j))\\n xaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"xaux(%s,%s)\\\"%(i,j))\\n yaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"yaux(%s,%s)\\\"%(i,j))\\n uaux[i,j] = model.addVar(vtype=\\\"C\\\", name=\\\"uaux(%s,%s)\\\"%(i,j))\\n\\n\\n\\n for i in I:\\n model.addCons(quicksum(u[i,j] for j in J) == 1, \\\"Assign(%s)\\\"%i)\\n for j in J:\\n model.addCons(xaux[i,j]*xaux[i,j] + yaux[i,j]*yaux[i,j] <= v[i,j]*v[i,j], \\\"MinDist(%s,%s)\\\"%(i,j))\\n model.addCons(xaux[i,j] == (x[i]-X[j]), \\\"xAux(%s,%s)\\\"%(i,j))\\n model.addCons(yaux[i,j] == (y[i]-Y[j]), \\\"yAux(%s,%s)\\\"%(i,j))\\n model.addCons(uaux[i,j] >= v[i,j] - M*(1-u[i,j]), \\\"uAux(%s,%s)\\\"%(i,j))\\n\\n model.setObjective(quicksum(w[i]*uaux[i,j] for i in I for j in J), \\\"minimize\\\")\\n\\n\\n model.data = X,Y,v,u\\n return model\",\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 auxmin_cc_piece(x,k_ind,m_ind):\\n \\n # Adding new linear function as a last function:\\n # The first line. If jk = 1 and k_ind = nomax, this is a new line, otherwise an old one.\\n line_start=cfg.nfea*sum(cfg.jk[i] for i in range(k_ind))\\n #print line_start,cfg.jk,k_ind,cfg.nomax-1,cfg.jk[k_ind], cfg.xprev,x\\n if cfg.jk[k_ind]==1 and k_ind==cfg.nomax-1:\\n #print \\\"hihu0\\\"\\n f_cc=np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\\n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\\n return f_cc\\n else:\\n #print \\\"hihu1\\\",line_start,k_ind\\n f_cc=np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n cfg.min_line[k_ind,m_ind] = 0 # a global variable to save the smallest value.\\n if cfg.jk[k_ind]==1:\\n return f_cc\\n \\n # Next lines\\n line_start += cfg.nfea\\n for j in range(1,cfg.jk[k_ind]-1): # Everything but the first and last.\\n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n \\n # Minimum of lines\\n if f_tmp <= f_cc:\\n f_cc = f_tmp\\n cfg.min_line[k_ind,m_ind] = j\\n line_start += cfg.nfea\\n \\n # The last line.\\n if k_ind==cfg.nomax-1:\\n #print \\\"hihu3\\\"\\n f_tmp = np.dot(x[0:cfg.nfea-1],cfg.a[m_ind,:cfg.nfea-1])+x[cfg.nfea-1]\\n else: \\n \\n f_tmp = np.dot(cfg.xprev[line_start:line_start+(cfg.nfea-1)],cfg.a[m_ind,:cfg.nfea-1])+cfg.xprev[line_start+cfg.nfea-1]\\n \\n # Minimum of lines\\n if f_tmp <= f_cc:\\n f_cc = f_tmp\\n cfg.min_line[k_ind,m_ind] = cfg.jk[k_ind]-1 \\n\\n return f_cc\",\n \"def getAbsNormalizationFactor(deltaE_wkspace,min,max):\\n global reducer\\n van_mass=reducer.get_default_parameter('vanadium-mass') \\n \\n Integration(InputWorkspace=deltaE_wkspace,OutputWorkspace='van_int',RangeLower=min,RangeUpper=max,IncludePartialBins='1')\\n input_ws = mtd[deltaE_wkspace]\\n ei_monovan = input_ws.getRun().getLogData(\\\"Ei\\\").value\\n data_ws=mtd['van_int']\\n nhist = data_ws.getNumberHistograms()\\n #print nhist\\n\\n signal1_sum = 0.0\\n weight1_sum = 0.0 \\n signal2_sum = 0.0\\n weight2_sum = 0.0 \\n signal3_sum = 0.0\\n weight3_sum = 0.0 \\n signal4_sum = 0.0\\n weight4_sum = 0.0 \\n\\n \\n ic=0;\\n izerc=0;\\n for i in range(nhist):\\n try:\\n det = data_ws.getDetector(i)\\n except Exception:\\n continue\\n if det.isMasked():\\n continue\\n\\n signal = data_ws.readY(i)[0]\\n error = data_ws.readE(i)[0]\\n \\n if signal != signal: #ignore NaN\\n continue\\n if ((error<=0) or (signal<=0)): # ignore Inf (0 in error are probably 0 in sign\\n izerc+=1\\n continue\\n # Guess which minimizes the value sum(n_i-n)^2/Sigma_i -- this what Libisis had\\n weight = 1.0/error\\n signal1_sum += signal * weight\\n weight1_sum += weight \\n # Guess which minimizes the value sum(n_i-n)^2/Sigma_i^2\\n weight2 = 1.0/(error*error)\\n signal2_sum += signal * weight2\\n weight2_sum += weight2 \\n # Guess which assumes puassonian distribution with Err=Sqrt(signal) and calculates \\n # the function: N_avrg = 1/(DetEfficiency_avrg^-1)*sum(n_i*DetEfficiency_i^-1)\\n # where the DetEfficiency = WB_signal_i/WB_average WB_signal_i is the White Beam Vanadium \\n # signal on i-th detector and the WB_average -- average WB vanadium signal. \\n # n_i is the modified signal \\n err_sq = error*error\\n weight = err_sq/signal\\n signal3_sum += err_sq\\n weight3_sum += weight\\n # Guess which estimatnes value sum(n_i^2/Sigma_i^2)/sum(n_i/Sigma_i^2) TGP suggestion from 12-2012\\n signal4_sum += signal*signal/err_sq\\n weight4_sum += signal/err_sq\\n \\n ic += 1 \\n #print 'signal value =' ,signal\\n #print 'error value =' ,error \\n #print 'average ',signal_sum \\n #---------------- Loop finished\\n \\n if( weight1_sum==0.0 or weight2_sum == 0.0 or weight3_sum == 0.0 or weight4_sum == 0.0) :\\n print \\\"WB integral has been calculated incorrectrly, look at van_int workspace and input workspace: \\\",deltaE_wkspace\\n raise IOError(\\\" divided by 0 weight\\\")\\n \\n integral_monovanLibISIS=signal1_sum / weight1_sum\\n integral_monovanSigSq =signal2_sum / weight2_sum \\n integral_monovanPuason =signal3_sum / weight3_sum \\n integral_monovanTGP =signal4_sum / weight4_sum\\n #integral_monovan=signal_sum /(wbVan_sum)\\n van_multiplier = (float(reducer.van_rmm)/float(van_mass))\\n absnorm_factorLibISIS = integral_monovanLibISIS * van_multiplier\\n absnorm_factorSigSq = integral_monovanSigSq * van_multiplier \\n absnorm_factorPuason = integral_monovanPuason * van_multiplier \\n absnorm_factorTGP = integral_monovanTGP * van_multiplier \\n #print 'Monovan integral :' ,integral_monovan \\n \\n if ei_monovan >= 210.0: \\n xsection = 421 # vanadium cross-section in mBarn/sR (402 mBarn/Sr) (!!!modified to fit high energy limit?!!!)\\n else: # old textbook cross-section for vanadium for ei=20mEv\\n xsection = 400 + (ei_monovan/10) \\n\\n absnorm_factorLibISIS /= xsection\\n absnorm_factorSigSq /= xsection \\n absnorm_factorPuason /= xsection \\n absnorm_factorTGP /= xsection \\n \\n sample_multiplier = (float(reducer.sample_mass)/float(reducer.sample_rmm))\\n absnorm_factorLibISIS= absnorm_factorLibISIS *sample_multiplier\\n absnorm_factorSigSq = absnorm_factorSigSq *sample_multiplier\\n absnorm_factorPuason = absnorm_factorPuason *sample_multiplier\\n absnorm_factorTGP = absnorm_factorTGP *sample_multiplier\\n \\n if (absnorm_factorLibISIS !=absnorm_factorLibISIS)|(izerc!=0): # It is an error, print diagnostics:\\n if (absnorm_factorLibISIS !=absnorm_factorLibISIS):\\n print '--------> Absolute normalization factor is NaN <----------------------------------------------'\\n else:\\n print '--------> Warning, Monovanadium has zero spectra <--------------------------------------------' \\n print '--------> Processing workspace: ',deltaE_wkspace\\n print '--------> Monovan Integration range : min=',min,' max=',max\\n print '--------> Summarized: ',ic,' spectra with total value: ',signal2_sum, 'and total weight: ',weight2_sum\\n print '--------> Dropped: ',izerc,' empty spectra'\\n print '--------> Van multiplier: ',van_multiplier,' sample multiplier: ',sample_multiplier, 'and xsection: ',xsection \\n print '--------> Abs norm factors: LibISIS: ',absnorm_factorLibISIS,' Sigma^2: ',absnorm_factorSigSq\\n print '--------> Abs norm factors: Puasonian: ',absnorm_factorPuason, ' TGP: ',absnorm_factorTGP\\n print '----------------------------------------------------------------------------------------------' \\n else:\\n DeleteWorkspace(Workspace=deltaE_wkspace)\\n DeleteWorkspace(Workspace=data_ws)\\n return (absnorm_factorLibISIS,absnorm_factorSigSq,absnorm_factorPuason,absnorm_factorTGP)\",\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 cvstem(self):\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Cfun).parameters) == 1):\\n fun1 = self.Cfun\\n self.Cfun = lambda x,p: fun1(x)\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Gw).parameters) == 1):\\n fun2 = self.Gw\\n self.Gw = lambda x,p: fun2(x)\\n if self.iEC == \\\"est\\\":\\n self.c_over = self.matrix_2bound(self.Cfun)\\n self.g_over = self.matrix_2bound(self.Gw)\\n if (len(sig(self.Bw).parameters) == 1):\\n fun3 = self.Bw\\n self.Bw = lambda x,p: fun3(x)\\n self.b_over = self.matrix_2bound(self.Bw)\\n self.linesearch()\\n alp = self.alp_opt\\n Nx = self.Nx\\n Nsplit = 1\\n Np = int(Nx/Nsplit)\\n Nr = np.remainder(Nx,Nsplit)\\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\\n Nxp = self.n+self.n_p\\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\\n Ws_opt = []\\n chi_opt = 0\\n nu_opt = 0\\n print(\\\"========================================================\\\")\\n print(\\\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\\\")\\n print(\\\"========================================================\\\")\\n for p in range(Np):\\n if np.remainder(p,int(Np/10)) == 0:\\n print(\\\"# sampled metrics: \\\",p*Nsplit,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n if Nr != 0:\\n print(\\\"# samples metrics: \\\",Nx,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n self.xs_opt = xs_opt\\n self.ps_opt = ps_opt\\n self.Ws_opt = Ws_opt\\n self.chi_opt = chi_opt\\n self.nu_opt = nu_opt\\n if self.iEC == \\\"est\\\":\\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\\n print(\\\"Optimal steady-state estimation error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n elif self.iEC == \\\"con\\\":\\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\\n print(\\\"Optimal steady-state tracking error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n else:\\n raise ValueError('Invalid iEC: iEC = \\\"est\\\" or \\\"con\\\"')\\n self.M2cholM()\\n path = \\\"models/optvals/\\\"+self.fname\\n if os.path.exists(path) == False:\\n try:\\n os.makedirs(path)\\n except: \\n raise OSError(\\\"Creation of directory %s failed\\\" %path)\\n else:\\n print (\\\"Successfully created directory %s \\\" %path)\\n else:\\n print (\\\"Directory %s already exists\\\" %path)\\n np.save(path+\\\"/alp_opt.npy\\\",alp)\\n np.save(path+\\\"/chi_opt.npy\\\",self.chi_opt)\\n np.save(path+\\\"/nu_opt.npy\\\",self.nu_opt)\\n np.save(path+\\\"/Jcv_opt.npy\\\",self.Jcv_opt)\\n print(\\\"========================================================\\\")\\n print(\\\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\\\")\\n print(\\\"========================================================\\\\n\\\\n\\\")\\n pass\",\n \"def inference(self):\\n logging.info('RandomizeMincut inference')\\n\\n perturbation_num = 4\\n noise_rate = 0.3\\n noise_range = (-0.6, 0.4)\\n base_adj_matrix = copy.deepcopy(self._graph.get_adjacency('weight').data)\\n base_adj_matrix = np.array(base_adj_matrix)[:-2, :-2] # remove pseudo vertices\\n vertices_number = self._graph.vcount()\\n y = [] # list of return results\\n\\n # basic mincut first\\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\\n [positive_label, _] = self._cut.partition\\n\\n # ignore this cut if it has unbalance separation\\n if len(positive_label) > 0.06 * vertices_number or \\\\\\n len(positive_label) < 0.94 * vertices_number:\\n labels = np.zeros(vertices_number) # re-construct y\\n labels[positive_label] = 1\\n y.append(labels[:-1]) # omit v_plus\\n\\n for _ in range(perturbation_num):\\n # init noise\\n noise_decision = np.random.binomial(\\n n=1,\\n p=noise_rate,\\n size=base_adj_matrix.shape\\n )\\n noise_value = np.random.uniform(\\n low=noise_range[0],\\n high=noise_range[1],\\n size=base_adj_matrix.shape\\n )\\n noise_value = noise_decision * noise_value\\n\\n # add noise\\n noise_weight = np.triu(base_adj_matrix + noise_value) # only get upper triangle\\n self._graph.es['weight'] = noise_weight[noise_weight.nonzero()]\\n\\n # find mincut\\n self._cut = self._graph.st_mincut(source=self._v_plus, target=self._v_minus, capacity='weight')\\n [positive_label, _] = self._cut.partition\\n\\n # ignore this cut if it has unbalance separation\\n if len(positive_label) < 0.06*vertices_number or \\\\\\n len(positive_label) > 0.94*vertices_number:\\n continue\\n\\n labels = np.zeros(vertices_number) # re-construct y\\n labels[positive_label] = 1\\n y.append(labels[:-1]) # omit v_plus\\n\\n self._graph.delete_vertices([self._v_minus, self._v_plus])\\n vote = np.array(y).sum(axis=0) # if sum > cases//2: label 1, else label 0\\n self._graph.vs['label'] = (vote > len(y)//2).astype(int)\",\n \"def dual_objective_expression_rule(_m):\\r\\n\\r\\n # Build limits\\r\\n t_1 = sum(- (m.mu_2[z, y] * m.SOLAR_BUILD_LIMITS[z]) - (m.mu_3[z, y] * m.WIND_BUILD_LIMITS[z]) - (\\r\\n m.mu_4[z, y] * m.STORAGE_BUILD_LIMITS[z]) for z in m.Z for y in m.Y)\\r\\n\\r\\n # Min power output\\r\\n t_2 = sum(\\r\\n m.sigma_1[g, y, s, t] * m.P_MIN[g] for g in m.G.difference(m.G_STORAGE) for y in m.Y for s in m.S for t\\r\\n in m.T)\\r\\n\\r\\n # Max power - existing generators\\r\\n t_3 = sum(\\r\\n - m.sigma_2[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_THERM for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Max power - existing wind\\r\\n t_4 = sum(\\r\\n - m.sigma_4[g, y, s, t] * m.Q_W[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_WIND for y in\\r\\n m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max power - existing solar\\r\\n t_5 = sum(\\r\\n - m.sigma_6[g, y, s, t] * m.Q_S[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_SOLAR for y in\\r\\n m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max power - existing hydro\\r\\n t_6 = sum(\\r\\n - m.sigma_8[g, y, s, t] * m.P_H[g, y, s, t] * (1 - m.F[g, y]) for g in m.G_E_HYDRO for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max charging power - existing storage\\r\\n t_7 = sum(\\r\\n - m.sigma_11[g, y, s, t] * m.P_IN_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max discharging power - existing storage\\r\\n t_8 = sum(\\r\\n - m.sigma_13[g, y, s, t] * m.P_OUT_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max energy - existing storage units\\r\\n t_9 = sum(\\r\\n - m.sigma_16[g, y, s, t] * m.Q_MAX[g] for g in m.G_E_STORAGE for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Min energy - interval end\\r\\n t_10 = sum(m.sigma_18[g, y, s] * m.Q_END_MIN[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n # Max energy - interval end\\r\\n t_11 = sum(- m.sigma_19[g, y, s] * m.Q_END_MAX[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n # Ramp-up constraint - generators\\r\\n t_12 = sum(\\r\\n - m.sigma_20[g, y, s, t] * m.RR_UP[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Ramp-up constraint - initial power output - generators\\r\\n t_13 = sum(\\r\\n - m.sigma_20[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y\\r\\n for s in m.S)\\r\\n\\r\\n # Ramp-down constraint - generators\\r\\n t_18 = sum(\\r\\n - m.sigma_23[g, y, s, t] * m.RR_DOWN[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Ramp-down constraint - initial power output - generators\\r\\n t_19 = sum(\\r\\n m.sigma_23[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for\\r\\n s in m.S)\\r\\n\\r\\n # Min powerflow\\r\\n t_24 = sum(m.sigma_27[l, y, s, t] * m.POWERFLOW_MIN[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max powerflow\\r\\n t_25 = sum(\\r\\n - m.sigma_28[l, y, s, t] * m.POWERFLOW_MAX[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Demand\\r\\n t_26 = sum(m.lamb[z, y, s, t] * m.DEMAND[z, y, s, t] for z in m.Z for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Initial storage unit energy\\r\\n t_27 = sum(m.zeta_1[g, y, s, m.T.first()] * m.Q0[g, y, s] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n return (t_1 + t_2 + t_3 + t_4 + t_5 + t_6 + t_7 + t_8 + t_9 + t_10 + t_11 + t_12 + t_13 + t_18 + t_19 + t_24\\r\\n + t_25 + t_26 + t_27)\",\n \"def method1(self):\\n cres=0. # Variable for storing Chern number.\\n # The U matrices from Fukui's method; storage...\\n Ux=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n Uy=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\\n \\n # ... and calculation of U matrices\\n for ix in range(self.kS.Nx+1):\\n for iy in range(self.kS.Ny+1):\\n mat1=self.alleigvecs[:,:,ix ,iy ]\\n if ix<self.kS.Nx:\\n mat2=self.alleigvecs[:,:,ix+1,iy ]\\n else:\\n mat2=self.alleigvecs[:,:,1 ,iy ]\\n if iy<self.kS.Ny:\\n mat3=self.alleigvecs[:,:,ix ,iy+1]\\n else:\\n mat3=self.alleigvecs[:,:,ix ,1 ]\\n Ux[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat2)[:self.NL,:self.NL])\\n Uy[ix,iy]=np.linalg.det(np.dot(np.conj(mat1.T),mat3)[:self.NL,:self.NL])\\n \\n # Local estimates of Berry curvature; storage ...\\n ftempall=np.zeros((self.kS.Nx,self.kS.Ny),complex)\\n # ... and calculation\\n for ix in range(self.kS.Nx):\\n for iy in range(self.kS.Ny):\\n ftemp=np.log(Ux[ix,iy]*Uy[ix+1,iy]/Ux[ix,iy+1]/Uy[ix,iy])\\n ftempall[ix,iy]=ftemp # ... of local Berry curvature ...\\n cres+=ftemp/2./pi/1j # ... and of Berry phase (Chern number).\\n\\n return cres.real, ftempall\",\n \"def test_solver1c(N, version='scalar'):\\n def I(x): return sin(2*x*pi/L)\\n def f(x, t): return 0\\n\\n class Action:\\n def __init__(self):\\n self.solutions = []\\n self.time_level_counter = 0\\n\\n def __call__(self, u, x, t):\\n if self.time_level_counter % N == 0:\\n self.solutions.append(u.copy())\\n self.time_level_counter += 1\\n\\n action = Action()\\n n = 100; tstop = 6; L = 10\\n dt, x, cpu = solver(I, f, 1.0, lambda t: 0, lambda t: 0,\\n L, n, 0, tstop,\\n user_action=action, version=version)\\n print 'CPU time:', cpu\\n print 'Max value in final u:', arrmax(action.solutions[-1])\",\n \"def optimize_fore(self):\\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\\n \\n self.l2 = torch.from_numpy(self.u).float()\\n print('self u shape',self.l2.shape)\\n self.n = torch.randn(32, 1, 28, 28)\\n self.l1 = self.enc(self.input + self.n)\\n self.del1=self.dec(self.l1)\\n self.del2=self.dec(self.l2)\\n self.update_netc()\\n self.update_netd()\\n\\n self.update_l2()\\n self.update_netg()\\n print('sssssssssssssssssssssss')\",\n \"def front_column_model_p_gain():\",\n \"def _para_boosting(self, H):\\n # print '----------------primal-dual boost-------------------'\\n H = np.hstack((H, -H))\\n # H_ft = np.asfortranarray((H.copy()))\\n (n, p) = H.shape\\n self.c = np.log(n*p)\\n nu = int(n * self.ratio)\\n\\n if self.max_iter < 50:\\n delta = 1\\n else:\\n delta = 40\\n d = np.ones(n) / n\\n d_bar = np.ones(n) / n\\n a_bar = np.ones(p) / p\\n a = np.ones(p) / p\\n h_a = np.sum(H, axis=1) / p\\n h_a_bar = h_a.copy()\\n # a_bar = a\\n # a_tilde = np.ones(p) / p\\n h_a_tilde = h_a.copy()\\n # d_tilde = np.zeros(p)\\n theta = 1\\n sig = 1\\n tau = 1\\n t = 0\\n logscale = 0\\n for t in range(self.max_iter):\\n d = prox_mapping(h_a_tilde, d, tau, 2)\\n if self.has_dcap:\\n d2 = proj_cap_ent(d, 1.0 / nu)\\n # d_new = d_new/d_new.sum()\\n if np.abs(d.sum() - d2.sum()) > 0.0001:\\n print 'error'\\n d = d2\\n d_tilde = d\\n dtH = np.dot(d_tilde, H)\\n # dtH = np.dot(H.T, d_tilde)\\n a_new = prox_mapping(-dtH, a, sig, 2)\\n h_a_new = np.dot(H, a_new)\\n # a_tilde = a_new + theta * (a_new - a)\\n h_a_tilde = (1+theta) * h_a_new - theta * h_a\\n a = a_new\\n h_a = h_a_new\\n d_bar *= t / (t + 1.0)\\n d_bar += 1.0 / (t + 1) * d\\n a_bar *= t / (t + 1.0)\\n a_bar += 1.0 / (t + 1) * a\\n # h_a_bar = np.dot(H, a_bar)\\n h_a_bar = t / (t + 1.0) * h_a_bar + 1.0/(t+1) * h_a\\n if int(np.log(t+1)) == logscale:\\n logscale += 1\\n self.iter_num.append(t)\\n if self.has_dcap:\\n min_margin = ksmallest2(h_a_bar, nu)\\n self.primal_obj.append(-np.mean(min_margin))\\n else:\\n self.primal_obj.append(- np.min(h_a_bar))\\n self.margin.append(-self.primal_obj[-1])\\n self.dual_obj.append(-np.max(np.dot(d_bar, H)))\\n self.gap.append(self.primal_obj[-1] - self.dual_obj[-1])\\n self.err_tr.append(np.mean(h_a_bar < 0))\\n # if t % 100 == 0:\\n # print 'iter ' + str(t) + ' ' + str(self.gap[-1])\\n if self.gap[-1] < self.epsi:\\n break\\n self.alpha = a_bar[:p / 2] - a_bar[p / 2:]\\n self.d = d_bar\\n print \\\" pd-boosting(python): max iter#%d: , actual iter#%d\\\" % (self.max_iter, t)\",\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 solve_SVM_dual_SMO(x_train, y_train, x_test, C=1):\\n n, d = x_train.shape[0], x_train.shape[1]\\n alpha = np.zeros((n))\\n count = 0\\n while True:\\n count += 1\\n alpha_prev = np.copy(alpha)\\n for j in range(0, n):\\n # Getting random int i!=j\\n i = j\\n cnt=0\\n while i == j and cnt<1000:\\n i = rnd.randint(0,n-1)\\n cnt=cnt+1\\n x_i, x_j, y_i, y_j = x_train[i,:], x_train[j,:], y_train[i], y_train[j]\\n k_ij = (np.dot(x_i, x_i.T)) + (np.dot(x_j, x_j.T) ) - (2 * np.dot(x_i, x_j.T))\\n if k_ij <= 0:\\n continue\\n alpha_prime_j, alpha_prime_i = alpha[j], alpha[i]\\n if(y_i != y_j):\\n (L,H) = (max(0, alpha_prime_j - alpha_prime_i), min(C, C - alpha_prime_i + alpha_prime_j))\\n else:\\n (L,H) = (max(0, alpha_prime_i + alpha_prime_j - C), min(C, alpha_prime_i + alpha_prime_j))\\n if(L==H):\\n continue\\n # Computing model parameters\\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\\n b = np.mean(y_train - np.dot(w.T, x_train.T))\\n E_i = np.sign(np.dot(w.T, x_i.T) + b).astype(int) - y_i\\n E_j = np.sign(np.dot(w.T, x_j.T) + b).astype(int) - y_j\\n # Setting new alpha values(Lagrange multipliers)\\n alpha[j] = alpha_prime_j + float(y_j * (E_i - E_j))/k_ij\\n alpha[j] = max(alpha[j], L)\\n alpha[j] = min(alpha[j], H)\\n alpha[i] = alpha_prime_i + y_i*y_j * (alpha_prime_j - alpha[j])\\n # Checking for convergence\\n diff = np.linalg.norm(alpha - alpha_prev)\\n if diff < 0.000000001:\\n break\\n # Computing weights and bias\\n b = np.mean(y_train-np.dot(w.T,x_train.T))\\n w = np.dot(x_train.T, np.multiply(alpha,y_train))\\n y_pred_test = (np.sign(np.dot(w.T, x_test.T) + b).astype(int))\\n return (y_pred_test,alpha)\",\n \"def buildObjective(self):\\r\\n\\r\\n # self.z_prior might be the modified version\\r\\n self.L_elbo = T.mean(self.reconst + self.conditional_prior + self.w_prior + self.z_prior)\\r\\n\\r\\n self.L_elbo_modif = T.mean(self.reconst + self.conditional_prior + self.w_prior_modif + self.z_prior_modif)\\r\\n\\r\\n #---Getting model parameter---#\\r\\n cg = ComputationGraph(self.L_elbo)\\r\\n #self.phi_theta is the list of all the parameters in q and p.\\r\\n self.params = VariableFilter(roles=[PARAMETER])(cg.variables)\",\n \"def solve(self):\\n start = timer()\\n # encode into milp\\n me = MILPEncoder(MILPSolver.prob,\\n MILPSolver.params.logger.LOGFILE, \\n MILPSolver.params.INTRA_DEP_CONSTRS,\\n MILPSolver.params.INTER_DEP_CONSTRS)\\n if MILPSolver.lp == True:\\n gmodel = me.lp_encode()\\n else:\\n gmodel = me.encode()\\n # Set gurobi parameters\\n pgo = 1 if MILPSolver.params.PRINT_GUROBI_OUTPUT == True else 0\\n gmodel.setParam('OUTPUT_FLAG', pgo)\\n tl = MILPSolver.params.TIMEOUT\\n if tl != -1 : gmodel.setParam('TIME_LIMIT', tl)\\n if not MILPSolver.params.DEFAULT_CUTS: \\n MILPSolver.disable_default_cuts(gmodel)\\n gmodel._vars = gmodel.getVars()\\n # set callback cuts \\n MILPSolver.id_form = IdealFormulation(MILPSolver.prob,\\n gmodel, \\n MILPSolver.params.IDEAL_FREQ,\\n MILPSolver.params.logger.LOGFILE)\\n MILPSolver.dep_cuts = DepCuts(MILPSolver.prob,\\n gmodel,\\n MILPSolver.params.DEP_FREQ,\\n MILPSolver.params.INTRA_DEP_CUTS,\\n MILPSolver.params.INTER_DEP_CUTS,\\n MILPSolver.sip_params,\\n MILPSolver.params.logger.LOGFILE)\\n # Optimise\\n if MILPSolver.params.callback_enabled() and MILPSolver.lp == False:\\n gmodel.optimize(MILPSolver._callback)\\n else:\\n gmodel.optimize()\\n\\n runtime = timer() - start\\n cex = None \\n if MILPSolver.status == SolveResult.BRANCH_THRESHOLD:\\n result = SolveResult.BRANCH_THRESHOLD\\n elif gmodel.status == GRB.OPTIMAL:\\n cex_shape = MILPSolver.prob.spec.input_layer.input_shape\\n cex = np.zeros(cex_shape)\\n for i in itertools.product(*[range(j) for j in cex_shape]):\\n cex[i] = MILPSolver.prob.spec.input_layer.out_vars[i].x\\n result = SolveResult.UNSATISFIED\\n elif gmodel.status == GRB.TIME_LIMIT:\\n result = SolveResult.TIMEOUT\\n elif gmodel.status == GRB.INTERRUPTED:\\n result = SolveResult.INTERRUPTED\\n elif gmodel.status == GRB.INFEASIBLE or gmodel.status == GRB.INF_OR_UNBD:\\n result = SolveResult.SATISFIED\\n else:\\n result = SolveResult.UNKNOWN\\n \\n # MILPSolver.logger.info('Verification problem {} solved, '\\n # 'LP: {}, '\\n # 'time: {:.2f}, '\\n # 'result: {}.'\\n # .format(MILPSolver.prob.id,\\n # MILPSolver.lp,\\n # runtime,\\n # result.value))\\n \\n return SolveReport(result, runtime, cex)\",\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 find_large_separation2(self):\\n\\n ind = (self.modes['l'] == 0).flat\\n n = self.modes['n'].compress(ind)\\n if (len(n) < 2): return np.nan\\n freq = self.modes['freq'].compress(ind)\\n coeff = np.polyfit(n,freq,1)\\n return coeff[0]\",\n \"def selection_correction_method1(tree, scale, h_in, h_out):\\n #h_in = ROOT.TH1D(\\\"h_in\\\", \\\"neutron spectrum with all cuts: inside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n #h_out = ROOT.TH1D(\\\"h_out\\\", \\\"neutron spectrum with all cuts: outside onset window; Energy [keV]; counts\\\", 50, 0, 25)\\n for event in tree:\\n cut = [0, 0]\\n S15_ch = i_channel(0, event)\\n bpm_ch = i_channel(4, event)\\n RT = event.DD_Rise[S15_ch]\\n S15_w2 = event.DD_AmplADU[S15_ch]\\n onset = event.DD_Rise10pct[S15_ch]\\n if cut[0]==0:\\n # first cut: for inside onset window\\n # if event passes the first cuts\\n if S15_w2>1000 and RT>1.1 and RT<1.51 and onset>39 and onset<47:\\n # loop over the pmt channel numbers to calculate the time of flight: time bd - time bpm\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n # calculation of the time of flight\\n tof = (cfd_pmt-cfd_bpm)%400\\n #cut on tof: time of flight of the neutron\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n # fill histogram inside onset window\\n h_in.Fill(energy2)\\n cut[0]=1\\n break\\n if cut[1]==0:\\n if S15_w2>1000 and RT<1.51 and RT>1.1 and ((onset<36 and onset>15) or (onset>50 and onset<=110)):\\n for n_channel in range(5, 16):\\n pmt_i = i_channel(n_channel, event)\\n cfd_pmt = event.cfdPulse_CFDNS[pmt_i]\\n cfd_bpm = event.cfdPulse_CFDNS[bpm_ch]\\n tof = (cfd_pmt-cfd_bpm)%400\\n if tof<335 and tof>295:\\n energy2 = S15_w2*scale\\n h_out.Fill(energy2)\\n cut[1]=1\\n break\\n return h_in, h_out\",\n \"def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \\n tol=1e-2):\\n from numpy import array, zeros_like, zeros\\n from scipy.optimize import minimize\\n from tgo import tgo\\n \\n def x_lim(X): # limiting function used in TGO\\n import numpy\\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\\n \\n if k == None:\\n k = p.m['Valid phases']\\n \\n # Initialize\\n Z_0 = array(Z_0)\\n LBD = - 1e300 # -inf\\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \\n \\n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\\n UBD = g_x_func(s, p).m['g_mix']['t'] \\n Lambda_d = zeros_like(Z_0)\\n\\n # X bounds used in UBD optimization\\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\\n zeros(shape=(p.m['n']-1)) # Lower bound\\n ] \\n for i in range(p.m['n']-1): \\n Sigma_ind = 0.0 # Sum of independent components excluding i\\n # (lever rule) \\n for j in range(p.m['n']-1):\\n if j != i:\\n Sigma_ind += Z_0[j]\\n\\n X_bounds[0][i] = 1.0 - Sigma_ind \\n \\n # Construct physical bounds x \\\\in [0, 1] for all independent components\\n # (used in differential_evolution)\\n Bounds = []\\n for i in range(p.m['n'] - 1):\\n #Bounds.append((0, 1))\\n Bounds.append((1e-5, 0.99999))\\n \\n # Construct composition container from X_d for all phases. (REMOVED)\\n X_d = Z_0\\n\\n\\n #%% Normal calculation of daul problem if Z_0 is unstable.\\n while abs(UBD - LBD) >= tol:\\n # Solve UBD\\n # Update system to new composition.\\n # (Comp. invariant in UBD)\\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \\n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \\n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\\n k))['x']\\n \\n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\\n \\n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\\n\\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\\n g_func=x_lim,\\n n = 100,\\n skip=2)\\n # Solve LBD \\n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \\n X_d = X_sol\\n # End\\n \\n\\n if False: # Print results optional\\n print 'Final UBD = {}'.format(UBD)\\n print 'Final LBD = {}'.format(LBD)\\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\\n print 'Final Z_eq = {}'.format(X_d)\\n print 'Final Lambda_d = {}'.format(Lambda_d)\\n \\n # Returns\\n s.m['Z_eq'] = X_d\\n s.m['Lambda_d'] = Lambda_d\\n return s\",\n \"def combined_costs(matrix_MSLL_IO):\\r\\n return\",\n \"def uncertainty_mm(self,m1,m2):\\n # ID and isolation uncertainty (TO BE FIXED)\\n unc = (self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')/self._muIDISOWeight.value(m1.pt(),m1.eta(),'+1')+ \\\\\\n self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1')/self._muIDISOWeight.value(m2.pt(),m2.eta(),'+1'))**2\\n \\n## # trigger (approximate) ==== FIXME!! ===============\\n## hlt_sf_run2011_a_unc = (self._mu7TrgWeight [(m1.pt(),m1.eta())][1]/self._mu7TrgWeight [(m1.pt(),m1.eta())][0] + \\\\\\n## self._mu7TrgWeight [(m2.pt(),m2.eta())][1]/self._mu7TrgWeight [(m2.pt(),m2.eta())][0])**2\\n## hlt_sf_run2011_b_unc = (abs(self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_b_unc += ((self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu13Trg_Mu13Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu13Trg_Mu13Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_c_unc = (abs(self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## hlt_sf_run2011_c_unc += ((self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][1]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][1])/ \\\\\\n## (self._mu8Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]+ \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu8Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]- \\\\\\n## self._mu17Trg_Mu17Mu8_Weight[(m1.pt(),m1.eta())][0]*self._mu17Trg_Mu17Mu8_Weight[(m2.pt(),m2.eta())][0]))**2\\n## unc += 0.002*hlt_sf_run2011_a_unc + 0.643*hlt_sf_run2011_b_unc + 0.024*hlt_sf_run2011_c_unc\\n \\n return sqrt(unc)\",\n \"def prior_params_tree(self):\\n id = {name:i for i, name in enumerate(list(self.tree.keys()))}\\n n_nodes = len(id)\\n dist_mx = np.zeros((n_nodes, n_nodes))\\n\\n for node1, edges in self.tree.items():\\n for node2, dist in edges.dist:\\n dist_mx[id[node1], id[node2]] = dist\\n dist_mx[id[node2], id[node1]] = dist\\n\\n # while np.count_nonzero(dist_mx) < (n_nodes ** 2 - n_nodes):\\n for _ in range(20):\\n for i, j in combinations(range(n_nodes), 2):\\n if dist_mx[i,j] > 0:\\n continue\\n row_i = dist_mx[i]\\n row_j = dist_mx[j]\\n value = (row_i + row_j) * (row_i > 0) * (row_j > 0)\\n dist_mx[i, j] = dist_mx[j, i] = - max(np.unique(value))\\n dist_mx = np.abs(dist_mx)\\n\\n evolve_rate = []\\n for node1, node2 in combinations(self.m_cov.keys(), 2):\\n mx_cov_dist = np.abs(self.m_cov[node1] - self.m_cov[node2])\\n elements = mx_cov_dist[np.triu_indices(len(mx_cov_dist))]\\n norm_elements = elements / dist_mx[id[node2], id[node1]]\\n evolve_rate += list(norm_elements)\\n\\n\\n\\n df = np.mean([p.shape[0] for _, p in self.m_profiles.items()])\\n p_theta_alpha = df/2\\n # p_theta_alpha = 4\\n p_theta_beta = np.percentile(evolve_rate, 75) * (p_theta_alpha - 1)\\n # print(p_theta_alpha, p_theta_beta)\\n return p_theta_alpha, p_theta_beta\",\n \"def wigner_gaunt(l1, l2, m):\\n pref = sqrt((2*l1 + 1)*(2*l2 + 1)/(4*pi))\\n return np.array([pref*sqrt(2*lpp + 1)*float(wigner_3j(l1,l2,lpp,m,-m,0)*wigner_3j(l1,l2,lpp,0,0,0))\\n for lpp in range(abs(l1-l2), l1+l2+1, 2)])\",\n \"def w3j000(L, l, lp, Fks):\\n\\n J = L + l + lp \\n if (J % 2 == 1) or (l + lp < L) or (np.abs(l - lp) > L):\\n return 0.\\n\\n res = (-1)**(J/2) * (Fks[J/2 - L] * Fks[J/2 - l] * Fks[J/2 - lp]) / (Fks[J/2] * (J + 1.)**0.5)\\n \\n return res\",\n \"def _post_process(self, nhops=10, style='entropy', minmax='min'): # pragma: no co ver\\n from scipy.optimize import basinhopping\\n\\n sign = +1 if minmax == 'min' else -1\\n\\n if style == 'channel':\\n def objective(x):\\n return sign*self.channel_capacity(x)\\n elif style == 'entropy':\\n def objective(x):\\n var = self.construct_joint(x).sum(axis=tuple(range(self._crv+1)))\\n return sign*h(var)\\n\\n true_objective = self.objective(self._optima)\\n\\n def constraint_match_objective(x):\\n obj = (self.objective(x) - true_objective)**2\\n return obj\\n\\n def constraint_normalized(x):\\n channel = x.reshape(self._crv_size, self._bound)\\n return (channel.sum(axis=1) - 1).sum()**2\\n\\n minimizer_kwargs = {'method': 'SLSQP',\\n 'bounds': [(0, 1)]*self._optima.size,\\n 'constraints': [{'type': 'eq',\\n 'fun': constraint_match_objective,\\n },\\n {'type': 'eq',\\n 'fun': constraint_normalized,\\n },\\n ],\\n }\\n\\n cb = BasinHoppingCallBack(minimizer_kwargs['constraints'])\\n cb(self._optima, true_objective, True)\\n\\n res = basinhopping(func=objective,\\n x0=self._optima.copy(),\\n minimizer_kwargs=minimizer_kwargs,\\n niter=nhops,\\n callback=cb,\\n accept_test=accept_test,\\n )\\n\\n minimum = cb.minimum()\\n if minimum is not None:\\n self._optima = minimum\",\n \"def auxminf2(x):\\n # Sum over data points\\n f = 0.0\\n for m_ind in range(cfg.ntrain):\\n f += auxminrho1(x,m_ind) + auxminrho2(x,m_ind) \\n \\n return f\",\n \"def pro_avfid_superoperator_compsubspace(U,L1):\\n\\n if U.type=='oper':\\n inner = U.dag()*U_target\\n part_idx = [0, 1, 3, 4] # only computational subspace\\n ptrace = 0\\n for i in part_idx:\\n ptrace += inner[i, i]\\n dim = 4 # 2 qubits comp subspace \\n\\n return np.real(((np.abs(ptrace))**2+dim*(1-L1))/(dim*(dim+1)))\\n\\n elif U.type=='super':\\n kraus_form = qtp.to_kraus(U)\\n dim=4 # 2 qubits in the computational subspace\\n part_idx = [0, 1, 3, 4] # only computational subspace\\n psum=0\\n for A_k in kraus_form:\\n ptrace = 0\\n inner = U_target_diffdims.dag()*A_k # otherwise dimension mismatch\\n for i in part_idx:\\n ptrace += inner[i, i]\\n psum += (np.abs(ptrace))**2\\n\\n return np.real((dim*(1-L1) + psum) / (dim*(dim + 1)))\",\n \"def ACmomentConstraint(p, var):\\n \\n #extract the polynomial and variables \\n x = var[0]\\n th = var[1]\\n\\n\\n #Identify support set, prepare for polytope reduction\\n #A_pre = np.array(P.monoms())\\n #b = np.array(P.coeffs())\\n \\n # #function to generate parameter coefficients\\n # if len(var) == 1:\\n # fb = lambda p: p\\n # else:\\n # fb = sp.lambdify(x, b, \\\"numpy\\\")\\n if type(p) == list:\\n fout = extract_monom(var, p)\\n else:\\n fout = extract_monom(var,[p])\\n fb = fout[\\\"fb\\\"]\\n A_pre = fout[\\\"A_pre\\\"]\\n monom_poly = fout[\\\"monom_poly\\\"]\\n geom = fout[\\\"geom\\\"]\\n \\n #add in constant term?\\n z_blank = np.zeros([1, A_pre.shape[1]])\\n z_list = [int(z) for z in z_blank.tolist()[0]] #probably a better way to do this\\n add_z = []\\n \\n if z_blank not in A_pre:\\n A_pre= np.append(A_pre, z_blank, axis = 0)\\n b = np.append(b, 0)\\n add_z = z_list\\n \\n #always add the constant term to the monomial set\\n monom_all = A_pre.tolist()\\n A = np.ones((A_pre.shape[1] + 1, A_pre.shape[0]), dtype = int)\\n A[1:,:] = A_pre.T \\n \\n #find the support and generators of all monomials \\n support = np.array(polytope.interior(A, strict = False))\\n half_support = [list(v // 2) for v in support if v.any() and not (v % 2).any()]\\n #once again, add back the constant\\n\\n\\n #augmented support set, 1 + half_support + current support\\n #TODO: This is incorrect, breaks the lexicographic ordering and many assumptions. Fix this\\n #aug_support = monom_all + add_z + [i for i in half_support if i not in monom_all]\\n monom_data = np.array(sum([[list(m) for m in monom_poly[i]] for i in range(len(geom)) if not geom[i]], []))\\n\\n keys_classify = np.lexsort(np.flipud(monom_data.T))\\n\\n #monom_classify = monom_data[keys_classify, :].tolist()\\n monom_classify = monom_data.tolist()\\n #for i = range(monom_poly):\\n # if geom[i]:\\n\\n\\n all_support = half_support + add_z + monom_classify\\n aug_support = np.flip(np.unique(np.array(all_support), axis=0), axis=0).tolist()\\n \\n \\n #lookup table to associate generating indices with monomials\\n #fill out the moment constraints\\n lookup = {} \\n for vi in range(len(aug_support)):\\n v = aug_support[vi]\\n for ui in range(vi, len(aug_support)):\\n u = aug_support[ui]\\n s = tuple([u[i] + v[i] for i in range(len(v))])\\n if s in lookup:\\n lookup[s] += [(ui, vi)]\\n else:\\n lookup[s] = [(ui, vi)]\\n \\n M_out = {\\\"supp\\\": aug_support, \\\"monom_all\\\": monom_all, \\\"monom_poly\\\": monom_poly, \\\"monom_classify\\\":monom_classify,\\n \\\"cons\\\": lookup, \\\"fb\\\": fb, \\\"geom\\\":geom}\\n #M_out = {\\\"supp\\\" : aug_support, \\\"half_supp\\\" : half_support, \\\"monom\\\": monom, \\\"cons\\\" : lookup, \\\"fb\\\": fb} \\n \\n return M_out\",\n \"def objective(self, x):\\n pass\",\n \"def objective(self, x):\\n pass\",\n \"def potentialSolver2(self, max_it, tol):\\n\\n dx2 = 1.0/(self.dh[0]*self.dh[0]); # dx^2\\n dy2 = 1.0/(self.dh[1]*self.dh[1]); # dy^2\\n dz2 = 1.0/(self.dh[2]*self.dh[2]); # dz^2\\n \\n L2 = 0.0 # norm\\n \\n converged = False\\n \\n \\n # solve potential\\n for it in np.arange(1,max_it+1):\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\" \\n \\\"\\\"\\\"\\n #standard internal open node\\n phi_new = (self.rho[i][j][k]/self.EPS_0 +\\\\\\n dx2*(self.phi[i-1][j][k] + self.phi[i+1][j][k]) +\\\\\\n dy2*(self.phi[i][j-1][k] + self.phi[i][j+1][k]) +\\\\\\n dz2*(self.phi[i][j][k-1] + self.phi[i][j][k+1]))/(2*dx2+2*dy2+2*dz2)\\n \\n # sucessive over relaxation \\n self.phi[i,j,k] = self.phi[i,j,k] + 1.4*(phi_new - self.phi[i][j][k])\\n \\n \\\"\\\"\\\" \\n #standard internal open node\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n (self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1])+\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1])+\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk]))/(2*dx2+2*dy2+2*dz2)\\n \\n \\\"\\\"\\\"\\n # sucessive over relaxation \\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] = self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1] +\\\\\\n 1.8*(self.phi_new[1:self.ni-1,1:self.nj-1,1:self.nk-1] - \\\\\\n self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1])\\n \\\"\\\"\\\"\\n \\n #check for convergence*/\\n if it%25==0:\\n sum = 0;\\n \\\"\\\"\\\"\\n for i in np.arange(1,self.ni-1):\\n for j in np.arange(1,self.nj-1):\\n for k in np.arange(1,self.nk-1):\\n \\\"\\\"\\\"\\n\\n self.R[1:self.ni-1,1:self.nj-1,1:self.nk-1] = \\\\\\n -self.phi[1:self.ni-1,1:self.nj-1,1:self.nk-1]*(2*dx2+2*dy2+2*dz2) +\\\\\\n self.rho[1:self.ni-1,1:self.nj-1,1:self.nk-1]/self.EPS_0 +\\\\\\n dx2*(self.phi[0:self.ni-2,1:self.nj-1,1:self.nk-1] + self.phi[2:self.ni,1:self.nj-1,1:self.nk-1]) +\\\\\\n dy2*(self.phi[1:self.ni-1,0:self.nj-2,1:self.nk-1] + self.phi[1:self.ni-1,2:self.nj,1:self.nk-1]) +\\\\\\n dz2*(self.phi[1:self.ni-1,1:self.nj-1,0:self.nk-2] + self.phi[1:self.ni-1,1:self.nj-1,2:self.nk])\\n\\n sum = np.sum(self.R**2)\\n\\n L2 = np.sqrt(sum/(self.ni*self.nj*self.nk));\\n #print(\\\"iter: \\\"+str(it)+\\\", L2 = \\\"+str(L2))\\n if (L2<tol):\\n converged = True\\n break\\n\\n if (converged==False):\\n print(\\\"Gauss-Seidel failed to converge, L2 = \\\"+str(L2))\\n \\n return converged\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60062426","0.60009205","0.5966422","0.5898558","0.58854496","0.58482015","0.5734522","0.56935805","0.5605645","0.5604729","0.55998397","0.55965626","0.55877346","0.5570163","0.5558406","0.5549005","0.554849","0.5545878","0.5530043","0.551141","0.55013293","0.5492349","0.54868186","0.54791296","0.5468052","0.5465821","0.5452274","0.54520696","0.5418245","0.540881","0.5401259","0.5382862","0.5382599","0.53816086","0.53755975","0.5370738","0.5365017","0.5364305","0.53419274","0.5339616","0.5335486","0.5333509","0.53264725","0.5320371","0.5316971","0.5310354","0.53057736","0.53057736","0.5302099","0.52954775","0.5287162","0.52843225","0.528357","0.5283473","0.5275551","0.5268035","0.52678573","0.5263228","0.5245017","0.5238959","0.52298677","0.522964","0.522303","0.5210514","0.5210444","0.5209481","0.51961774","0.51951396","0.5192949","0.5189","0.51886123","0.51886016","0.51882654","0.51866764","0.5185266","0.51740044","0.5173435","0.51632255","0.5162451","0.51570123","0.5156444","0.5144354","0.51426005","0.5140381","0.5130966","0.51293457","0.51227564","0.5122522","0.5120592","0.51201725","0.51146805","0.5112444","0.510999","0.51087606","0.51079875","0.51069885","0.5102927","0.5101974","0.5101032","0.5101032","0.50910926"],"string":"[\n \"0.60062426\",\n \"0.60009205\",\n \"0.5966422\",\n \"0.5898558\",\n \"0.58854496\",\n \"0.58482015\",\n \"0.5734522\",\n \"0.56935805\",\n \"0.5605645\",\n \"0.5604729\",\n \"0.55998397\",\n \"0.55965626\",\n \"0.55877346\",\n \"0.5570163\",\n \"0.5558406\",\n \"0.5549005\",\n \"0.554849\",\n \"0.5545878\",\n \"0.5530043\",\n \"0.551141\",\n \"0.55013293\",\n \"0.5492349\",\n \"0.54868186\",\n \"0.54791296\",\n \"0.5468052\",\n \"0.5465821\",\n \"0.5452274\",\n \"0.54520696\",\n \"0.5418245\",\n \"0.540881\",\n \"0.5401259\",\n \"0.5382862\",\n \"0.5382599\",\n \"0.53816086\",\n \"0.53755975\",\n \"0.5370738\",\n \"0.5365017\",\n \"0.5364305\",\n \"0.53419274\",\n \"0.5339616\",\n \"0.5335486\",\n \"0.5333509\",\n \"0.53264725\",\n \"0.5320371\",\n \"0.5316971\",\n \"0.5310354\",\n \"0.53057736\",\n \"0.53057736\",\n \"0.5302099\",\n \"0.52954775\",\n \"0.5287162\",\n \"0.52843225\",\n \"0.528357\",\n \"0.5283473\",\n \"0.5275551\",\n \"0.5268035\",\n \"0.52678573\",\n \"0.5263228\",\n \"0.5245017\",\n \"0.5238959\",\n \"0.52298677\",\n \"0.522964\",\n \"0.522303\",\n \"0.5210514\",\n \"0.5210444\",\n \"0.5209481\",\n \"0.51961774\",\n \"0.51951396\",\n \"0.5192949\",\n \"0.5189\",\n \"0.51886123\",\n \"0.51886016\",\n \"0.51882654\",\n \"0.51866764\",\n \"0.5185266\",\n \"0.51740044\",\n \"0.5173435\",\n \"0.51632255\",\n \"0.5162451\",\n \"0.51570123\",\n \"0.5156444\",\n \"0.5144354\",\n \"0.51426005\",\n \"0.5140381\",\n \"0.5130966\",\n \"0.51293457\",\n \"0.51227564\",\n \"0.5122522\",\n \"0.5120592\",\n \"0.51201725\",\n \"0.51146805\",\n \"0.5112444\",\n \"0.510999\",\n \"0.51087606\",\n \"0.51079875\",\n \"0.51069885\",\n \"0.5102927\",\n \"0.5101974\",\n \"0.5101032\",\n \"0.5101032\",\n \"0.50910926\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24397,"cells":{"query":{"kind":"string","value":"Updates a single entity. Implementers should return a tuple containing two iterables (to_update, to_delete)."},"document":{"kind":"string","value":"def map(self, entity):\n return ([], [])"},"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 entityUpdates(self, *args):\n\t\tfor entity in self.members.values():\n\t\t\tentity.update(*args)","def update_entities(self):\n raise NotImplementedError()","def update_many(\n self,\n *args: Union[dict, Mapping],\n session: Optional[ClientSession] = None\n ) -> UpdateMany:\n return self.update(*args, session=session)","def update(cls, values):\n result = yield UpdateQuery(cls, values).execute()\n returnValue(result)","def update(self, *args):\n qry = UpdateEntityQuery(self)\n self.context.add_query(qry)\n return self","def update(self, values):\n return self.manager.update(self, values)","def updateAllEntities():\n entityKeys=list(registeredEntities.keys())\n for currKey in entityKeys:\n try:\n currEntity=registeredEntities[currKey]\n currEntity.update()\n except KeyError:\n #this should only be called if an entity is deleted (like if a rock got hit by a bullet)\n continue","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def update(self, **kwargs):\n return self.manager.update(self, **kwargs)","def _update_entities(*entities):\n futures = []\n for entity in entities:\n futures.append(entity.put_async())\n Future.wait_all(futures)\n results = []\n for future in futures:\n results.append(future.get_result())\n return results","def update(self, request, pk):\n if pk is None:\n for item in request.data:\n # get object by its primary key\n obj = self._object_get(item[self.model._meta.pk.attname])\n self._object_update(obj, item)\n else:\n obj = self._object_get(pk)\n self._object_update(obj, request.data)\n return obj","def update_batch(self, *args, **kwargs):\n pass","def _update_bulk(self, iterable):\n self.cursor.executemany(self.UPDATE, iterable)","def update(self, **values):\r\n if self.__abstract__:\r\n raise ThunderdomeException('cant update abstract elements')\r\n self.pre_update(**values)\r\n for key in values.keys():\r\n if key not in self._columns:\r\n raise TypeError(\"unrecognized attribute name: '{}'\".format(key))\r\n\r\n for k,v in values.items():\r\n setattr(self, k, v)\r\n\r\n return self.save()","def _update_internal(self, entity_id, data, commit=True):\n input_data = self.to_model(data)\n self.validate_present(input_data)\n if not input_data:\n raise UnprocessableEntity(\"Can not update using empty data.\")\n entity = db_session.query(self.model).get(entity_id)\n if not entity:\n raise NotFound(\"Could not find any entity with specified parameters.\")\n\n for k, v in input_data.items():\n try:\n setattr(entity, k, v)\n except ValueError as e:\n raise UnprocessableEntity(f\"Could not save value.\", fields=k, what=BAD_VALUE) from e\n\n if commit:\n db_session.commit()\n \n return self.to_obj(entity)","def bulk_update(self, iterable):\n inserted, updated = [], []\n for d, h in iterable:\n if d in self:\n updated.append((d, h))\n else:\n inserted.append((d, h))\n self._update_bulk(updated)\n self._insert_bulk(inserted)","def update_entity(self, entity_obj):\n if (\n type(entity_obj) is not dict\n or \"entity_id\" not in entity_obj\n or \"mentions\" not in entity_obj\n ):\n raise ValueError(\n \"The input to update_entity needs to be a dictionary with an entity_id key and mentions key as \"\n \"you are replacing the entity information in bulk.\"\n )\n if not self._entity_symbols.qid_exists(entity_obj[\"entity_id\"]):\n raise ValueError(f\"The entity {entity_obj['entity_id']} is not in our dump\")\n try:\n ent = EntityObj(\n entity_id=entity_obj[\"entity_id\"],\n mentions=entity_obj[\"mentions\"],\n title=entity_obj.get(\"title\", entity_obj[\"entity_id\"]),\n types=entity_obj.get(\"types\", {}),\n relations=entity_obj.get(\"relations\", []),\n )\n except ValidationError as e:\n print(e.json())\n raise e\n # Update mentions\n for men in self.get_mentions(ent.entity_id):\n self._entity_symbols.remove_alias(ent.entity_id, men)\n for men in ent.mentions:\n # Lower case mentions for mention extraction\n men = [get_lnrm(men[0], strip=True, lower=True), men[1]]\n self._entity_symbols.add_alias(ent.entity_id, men)\n # Update title\n self._entity_symbols.set_title(ent.entity_id, ent.title)\n # Update types\n for type_sys in self._type_systems:\n for typename in self._type_systems[type_sys].get_types(ent.entity_id):\n self._type_systems[type_sys].remove_type(ent.entity_id, typename)\n for type_sys in ent.types:\n for typename in ent.types[type_sys]:\n self._type_systems[type_sys].add_type(ent.entity_id, typename)\n # Update KG\n if self._kg_symbols is not None:\n for rel in self._kg_symbols.get_relations(ent.entity_id):\n for qid2 in self._kg_symbols.get_connections_by_relation(\n ent.entity_id, rel\n ):\n self._kg_symbols.remove_kg(ent.entity_id, rel, qid2)\n for rel_pair in ent.relations:\n self._kg_symbols.add_kg(\n ent.entity_id, rel_pair[\"relation\"], rel_pair[\"object\"]\n )","def _update(self, model_obj):\n conn = self._get_session()\n db_item = None\n\n # Fetch the record from database\n try:\n identifier = getattr(model_obj, id_field(self.entity_cls).attribute_name)\n db_item = conn.query(self.model_cls).get(\n identifier\n ) # This will raise exception if object was not found\n except DatabaseError as exc:\n logger.error(f\"Database Record not found: {exc}\")\n raise\n\n if db_item is None:\n conn.rollback()\n conn.close()\n raise ObjectNotFoundError(\n {\n \"_entity\": f\"`{self.entity_cls.__name__}` object with identifier {identifier} \"\n f\"does not exist.\"\n }\n )\n\n # Sync DB Record with current changes. When the session is committed, changes are automatically synced\n try:\n for attribute in attributes(self.entity_cls):\n if attribute != id_field(self.entity_cls).attribute_name and getattr(\n model_obj, attribute\n ) != getattr(db_item, attribute):\n setattr(db_item, attribute, getattr(model_obj, attribute))\n except DatabaseError as exc:\n logger.error(f\"Error while updating: {exc}\")\n raise\n finally:\n if not current_uow:\n conn.commit()\n conn.close()\n\n return model_obj","def update_batch_of_entitiies(self, username, entity_batch_data):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY_BATCH, username + '|' + str(entity_batch_data))","def update_entity(self, username, entity_data):\n\t\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY, username + '|' + str(entity_data))","def update(self, **kwargs):\n return self._update_data(self.put(None, data=kwargs))","def update(self, *args, **kwargs):\n raise NotImplementedError","def bulk_update(self, iterable):\n inserted, updated = [], []\n for d, h in iterable:\n if -d in self:\n updated.append((-d, h))\n else:\n inserted.append((-d, h))\n self._update_bulk(updated)\n self._insert_bulk(inserted)","def update(\n self,\n *args: Union[dict, Mapping],\n session: Optional[ClientSession] = None\n ):\n self.set_session(session=session)\n return (\n self.UpdateQueryType(\n document_model=self.document_model,\n find_query=self.get_filter_query(),\n )\n .update(*args)\n .set_session(session=self.session)\n )","async def update(self, pk, payload):\n\n self.log.info(payload)\n await self.db.update(pk, payload)\n return await self.get_one(pk)","def update(self, request, pk=None): #update a specific object\n return Response({'http_method': 'PUT'})","def update(self, obj, data):\n self.get(obj[self.model.pk_field.name])\n self.validate_fields(data)\n\n fields = []\n values = []\n\n for k, v in data.iteritems():\n if k in self.model.get_fields_name():\n fields.append(k)\n values.append(v)\n\n conn = self.get_connector()\n cursor = conn.cursor()\n update = \" ,\".join([\"{0}='{1}'\".format(f, v) for f, v in zip(fields,\n values)])\n query = \"update {0} set {1} WHERE {2}={3}\".format(\n self.ressource_config[\"table\"],\n update,\n self.model.pk_field.name,\n obj[self.model.pk_field.name]\n )\n\n cursor.execute(query)\n conn.commit()\n conn.close()\n\n return self.get(obj[self.model.pk_field.name])","def update(self, table_name, fields, keys=None, any=False, eids=None):\n table = self.db.table(table_name)\n if eids is not None:\n LOGGER.debug(\"%r: update(%r, eids=%r)\" % (table_name, fields, eids))\n if isinstance(eids, list):\n return table.update(fields, eids=eids)\n else:\n return table.update(fields, eids=[eids])\n else:\n LOGGER.debug(\"%r: update(%r, keys=%r)\" % (table_name, fields, keys))\n return table.update(fields, self._getQuery(keys, any))","def update(self, attributes, type=None, name=None, identity=None):\n attributes = attributes or {}\n type = type or attributes.get('type')\n name = name or attributes.get('name')\n identity = identity or attributes.get('identity')\n if name and identity:\n name = None # Only send one\n request = self.request(operation='UPDATE', type=type, name=name,\n identity=identity, body=self.clean_attrs(attributes))\n return Entity(self, self.call(request).body)","def update(self, **values):\n\n return self._put(\"\", None, values)","def update(self, _id, data: dict) -> tuple:\n item = self.model.find_by_id(_id)\n if item:\n try:\n for field in data.keys():\n setattr(item, field, verify_date_field(field, data[field]))\n item.save()\n items = self.get_all()\n\n return items\n except DataBaseException as e:\n return {'error': {'message': e.message}}, 500\n else:\n return {'error': {'message': 'Item not found'}}, 400","def update(entity_list):\n for entity in entity_list:\n # Only moveable entities should have the dest field\n if \"dest\" in entity:\n # If no destination, pick a new random one\n if entity[\"dest\"] == None:\n entity[\"dest\"] = random_pos(100, 100)\n \n # Move one step towards destination\n cpos = entity[\"position\"]\n dest = entity[\"dest\"]\n entity[\"position\"] = move(cpos, dest) \n\n # Clear destination if it has been reached\n if entity[\"dest\"] == entity[\"position\"]:\n entity[\"dest\"] = None","def bulk_update(self, objs, fields, batch_size=None):\n if batch_size is not None and batch_size <= 0:\n raise ValueError(\"Batch size must be a positive integer.\")\n if not fields:\n raise ValueError(\"Field names must be given to bulk_update().\")\n objs = tuple(objs)\n if any(obj.pk is None for obj in objs):\n raise ValueError(\"All bulk_update() objects must have a primary key set.\")\n fields = [self.model._meta.get_field(name) for name in fields]\n if any(not f.concrete or f.many_to_many for f in fields):\n raise ValueError(\"bulk_update() can only be used with concrete fields.\")\n if any(f.primary_key for f in fields):\n raise ValueError(\"bulk_update() cannot be used with primary key fields.\")\n if not objs:\n return 0\n for obj in objs:\n obj._prepare_related_fields_for_save(\n operation_name=\"bulk_update\", fields=fields\n )\n # PK is used twice in the resulting update query, once in the filter\n # and once in the WHEN. Each field will also have one CAST.\n self._for_write = True\n connection = connections[self.db]\n max_batch_size = connection.ops.bulk_batch_size([\"pk\", \"pk\"] + fields, objs)\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\n requires_casting = connection.features.requires_casted_case_in_updates\n batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))\n updates = []\n for batch_objs in batches:\n update_kwargs = {}\n for field in fields:\n when_statements = []\n for obj in batch_objs:\n attr = getattr(obj, field.attname)\n if not hasattr(attr, \"resolve_expression\"):\n attr = Value(attr, output_field=field)\n when_statements.append(When(pk=obj.pk, then=attr))\n case_statement = Case(*when_statements, output_field=field)\n if requires_casting:\n case_statement = Cast(case_statement, output_field=field)\n update_kwargs[field.attname] = case_statement\n updates.append(([obj.pk for obj in batch_objs], update_kwargs))\n rows_updated = 0\n queryset = self.using(self.db)\n with transaction.atomic(using=self.db, savepoint=False):\n for pks, update_kwargs in updates:\n rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)\n return rows_updated","def update(self, *args: Any, **kwargs: Any) -> None:\n self._check_for_increment(\"update\")\n self[-1].update(*args, **kwargs)","def update(self, request, *args, **kwargs):\n orig_get_queryset = self.get_queryset\n\n def patched_get_queryset():\n \"\"\"Patched get_queryset method.\"\"\"\n entity_ids = orig_get_queryset().values_list(\"id\", flat=True)\n return Entity.objects.filter(id__in=entity_ids)\n\n self.get_queryset = patched_get_queryset\n\n resp = super().update(request, *args, **kwargs)\n\n self.get_queryset = orig_get_queryset\n return resp","def update(self, *others):\r\n return self.r.sunion(self.r_key, *[o.r_key for o in others])","def update(self, update_fields=None):\n instance = self.get_object() \n if not update_fields: \n update_fields=self.request.PUT.keys()\n try: \n for field in update_fields:\n update_value = self.request.PUT.get(field) # get value from PUT\n setattr(instance, field, update_value) # renew fields\n instance.save() # save updates\n except IntegrityError: # catch error\n return self.response(status='Failed to Update.') \n return self.response(\n status='Successfully Update')","def Update(self) -> T:","def test_update_multiple(test_store, andy, pandy, candy):\n n_updated = test_store.update(fields={\"age\": 14}, age=12)\n assert n_updated == 2\n items = list(test_store.get_by())\n\n andy.age = pandy.age = 14\n assert andy in items\n assert pandy in items\n assert candy in items","def update_one(\n self, *args, session: Optional[ClientSession] = None\n ) -> UpdateOne:\n return self.update(*args, session=session)","def put(self):\n # TODO: What kind of errors do I contemplate for here? How do I handle\n # them?\n if isinstance(self.request.data, self.model):\n self.request.data.save(force_update=True)\n else:\n for instance in self.request.data:\n instance.save(force_update=True)\n return self.request.data","async def modify(\n self, item: T, update: Union[dict, MotycQuery], *,\n inject_default_id: bool = None,\n ) -> T:\n\n assert isinstance(item, BaseModel), \"Can only handle BaseModel, not dict i.g.\"\n\n document = item.dict(by_alias=True)\n\n assert document.get(self.identity) is not None, f\"Need identity ({self.identity}) to update model.\"\n\n return await self.update_one(\n {self.identity: document[self.identity]},\n update,\n inject_default_id=inject_default_id\n )","async def update_many(\n self,\n update_document: Dict[str, Any],\n *,\n filter: Optional[Dict[str, Any]] = DEFAULT_FILTER,\n session: Optional[Any] = DEFAULT_SESSION,\n **kwargs: Any,\n ) -> UpdateResult:\n return await self._database.update_many(\n self.name,\n update_document=update_document,\n filter=filter,\n session=session,\n **kwargs,\n )","def update(cls, dto: dict):\n entity = cls.from_dict(dto)\n try:\n valid_entity = cls.find_by_id(dto[\"id\"])\n except KeyError as e:\n raise AppException(\"Can't find key {}\".format(e))\n\n if not valid_entity:\n return None\n\n # validate creation your creation.\n entity.creation_validation()\n\n # Copy all attributes from entity to valid_entity.\n valid_entity << entity\n\n return valid_entity","def update(self):\n values = {}\n for field in self.fields():\n attr = object.__getattribute__(self, field)\n if not attr.auto_value and attr._updated:\n values[field] = getattr(self, field)\n object.__setattr__(attr, '_updated', False)\n result = self.where({self.__class__.get_primary():self.primary})\n if len(values) == 0:\n logging.warning('update() called on model with no changed fields.')\n return None\n return result.update(values)[0]","def update(self, updates, predicate):\n for row in self.rows:\n if predicate(row):\n for column, new_value in updates.items():\n row[column] = new_value","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, *args, **kwargs):\n pass","def update(self, es, **kwargs):\n pass","def update(self, *args, **kw):\n pass","def update(self, commit=True, **kwargs):\n # Prevent changing IDS\n kwargs.pop('id', None)\n for attr, value in kwargs.iteritems():\n # Flask-restful makes everything None by default\n if value is not None:\n setattr(self, attr, value)\n return commit and self.save() or self","def _process(self, start_key, batch_size):\n\n query = self.MODEL.all()\n if start_key:\n query.filter('__key__ > ', start_key)\n\n try:\n entities = query.fetch(batch_size)\n\n if not entities:\n # all entities has already been processed\n return\n\n for entity in entities:\n for field in self.FIELDS_TO_UPDATE:\n old_reference = getattr(entity, field)\n\n if not old_reference:\n continue\n\n # check if the field has not been updated\n if isinstance(old_reference, self.PROFILE_MODEL):\n continue\n\n profile = _getProfileForRole(old_reference, self.PROFILE_MODEL)\n setattr(entity, field, profile)\n\n for list_property in self.LISTS_TO_UPDATE:\n l = getattr(entity, list_property)\n new_l = []\n for key in l:\n new_l.append(_getProfileKeyForRoleKey(key, self.PROFILE_MODEL))\n setattr(entity, list_property, new_l)\n\n db.put(entities)\n start_key = entities[-1].key()\n deferred.defer(self._process, start_key, batch_size)\n except DeadlineExceededError:\n # here we should probably be more careful\n deferred.defer(self._process, start_key, batch_size)","async def update_one(self, where, data):\n\n pass","def partial_update(self, request, pk=None): #partial update a specific object\n return Response({'http_method': 'PATCH'})","def update(self, **kwargs):\n\n return self.api_request(self._get_method_fullname(\"update\"), kwargs)","def update(self, **kwargs):\n\n return self.api_request(self._get_method_fullname(\"update\"), kwargs)","def update(self, **kwargs):\n\n return self.api_request(self._get_method_fullname(\"update\"), kwargs)","def update_character_eveentitydata(op, data_model, character_id, delete=False):\n character = EveCharacter.objects.get(external_id=character_id)\n\n response = EveClient.call(op, character_id=character.external_id)\n\n if response.status != 200:\n if response.status in [502, 503, 504]:\n logger.warning(\n f\"Skipping batch update {data_model.__name__} for {character_id} due to ESI error\")\n return\n else:\n logger.error(\n f\"[{response.status}] Failed to batch update {data_model.__name__} for {character_id}: {response.header} {response.data}\")\n return\n\n items = response.data\n\n if 'X-Pages' in response.header and response.header['X-Pages'][0] > 1:\n for num in range(2, response.header['X-Pages'][0]+1):\n response = EveClient.call(\n op, character_id=character.external_id, page=num)\n if response.status != 200:\n continue\n items += response.data\n\n if len(items) == 0:\n return []\n\n if delete:\n data_model.objects.filter(entity=character).delete()\n\n data_model.create_from_esi_response(items, character.external_id)\n\n return items","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update(self, *args, **kwargs): # real signature unknown\n pass","def update_corporation_eveentitydata(op, data_model, corporation_id, delete=False):\n\n corporation = EveCorporation.objects.get(external_id=corporation_id)\n\n response = EveClient.call(op, corporation_id=corporation.external_id)\n\n if response.status != 200:\n logger.error(\n f\"[{response.status}] Failed to batch update {data_model.__name__} for {character_id}: {response.header} {response.data}\")\n return\n\n items = response.data\n\n if 'X-Pages' in response.header and response.header['X-Pages'][0] > 1:\n for num in range(2, response.header['X-Pages'][0]+1):\n response = EveClient.call(\n op, corporation_id=corporation.external_id, page=num)\n if response.status != 200:\n continue\n items += response.data\n\n if len(items) == 0:\n return []\n\n if delete:\n data_model.objects.filter(entity=corporation).delete()\n\n data_model.create_from_esi_response(items, corporation.external_id)\n\n return items","def _update(self, values):\n if self.query.is_sliced:\n raise TypeError(\"Cannot update a query once a slice has been taken.\")\n query = self.query.chain(sql.UpdateQuery)\n query.add_update_fields(values)\n # Clear any annotations so that they won't be present in subqueries.\n query.annotations = {}\n self._result_cache = None\n return query.get_compiler(self.db).execute_sql(CURSOR)","def update(self, resource, keys_vals, url_prefix, auth, session, send_opts):\n success = True\n exc = HTTPErrorList('At least one key-value update failed.')\n\n for pair in keys_vals.items():\n key = pair[0]\n value = pair[1]\n req = self.get_metadata_request(\n resource, 'PUT', 'application/json', url_prefix, auth,\n key, value)\n prep = session.prepare_request(req)\n resp = session.send(prep, **send_opts)\n\n if resp.status_code == 200:\n continue\n\n err = (\n 'Update failed for {}: {}:{}, got HTTP response: ({}) - {}'\n .format(resource.name, key, value, resp.status_code, resp.text))\n exc.http_errors.append(HTTPError(err, request=req, response=resp))\n success = False\n\n if not success:\n raise exc","def update(self, request, pk=None):\n\n return Response({'http_method': 'PUT'})","def update_entities(self, entities: List[str]) -> None:\n self._entities = entities or []","def put(self, request, pk=None): #pk of id of objects to be updated (DB)\n return Response({'method':'PUT'})","def update(self, data: Union[QueryWithResponse, List[QueryWithResponse]], **kwargs):\n raise NotImplementedError","def update(self, **kwargs):\n return self._object.update(meta=kwargs)","def test_update_all(test_store, andy, pandy, candy):\n n_updated = test_store.update(fields={\"age\": 13})\n assert n_updated == 3\n items = list(test_store.get_by())\n\n andy.age = pandy.age = 13\n assert andy in items\n assert pandy in items\n assert candy in items","def update(self, request, pk=None):\n return Response({'http_method': 'PUT'})","def update(self, **kwargs):\n expr = self.model.__table__.update().where(self.query).values(**kwargs)\n return self._runquery(expr)","def update_many(\n cls,\n *,\n pks: List[Union[str, int]],\n update: Dict[str, Any],\n sychronize_session: bool = False,\n ) -> None:\n if pks:\n db.session.query(cls).filter(\n getattr(cls, cls.get_primary_key()).in_(pks)\n ).update(update, synchronize_session=sychronize_session)\n db.session.commit()\n cache.delete_many(*(cls.create_cache_key(pk) for pk in pks))","def update( # type: ignore # dead: disable\n self, entity: KeyValueEntity\n ) -> t.Optional[KeyValueEntity]:\n if entity.uuid not in self._data:\n raise KeyError()\n\n self._data[entity.uuid] = entity.value\n return entity","def update(*args):","def update(self, *args, **kwargs):","async def callback_update_entities(\n self,\n device: Device,\n message_id: int,\n state: DeviceResponseState,\n action: str,\n data: Tuple[\"Command\", Dict, int],\n ) -> NoReturn:\n if (\n device\n and action in (ACTION_COMMAND_RESPONSE, ACTION_DEVICE_MESSAGE)\n and state == DeviceResponseState.SUCCESS\n ):\n\n _LOGGER.debug(\n \"Received response (message ID: %d) from information command (action: %s) with data: %s\"\n % (message_id, action, data)\n )\n command, data, frame_number = data\n\n update_entities = self.device_entities.get(device.device_id)\n\n if not update_entities:\n _LOGGER.info(\"Device %s does not have any associated entities\" % device.device_id)\n else:\n protocol_id = self.devices_config_entries[device.device_id][CONF_PROTOCOL]\n protocol = SUPPORTED_PROTOCOLS[protocol_id]\n\n attribute_filter = protocol.get(PROTOCOL_FILTER)\n attributes = attribute_filter(data) if callable(attribute_filter) else data\n\n tasks = [\n asyncio.create_task(entity.handle_data_update(attributes))\n for entity in update_entities\n if entity.command_receive == command.name\n ]\n\n if tasks:\n _LOGGER.debug(\n 'Performing update on %d entities for command \"%s\"'\n % (len(tasks), command.name)\n )\n await asyncio.wait(tasks)\n _LOGGER.debug(\"Update complete!\")\n else:\n _LOGGER.debug('No updates scheduled for command \"%s\"' % command.name)","def update(self):\n self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes)","def storage_update(context, storage_id, values):\n session = get_session()\n with session.begin():\n query = _storage_get_query(context, session)\n result = query.filter_by(id=storage_id).update(values)\n return result","def update_compound_key(self, ids, values, entity_name=None):\n try:\n options = {\"options\": ids, \"values\": values}\n query_result = self.query(\n \"update\", entity_name or self.__entity_name, options)\n except Exception as error:\n error_detected = error\n\n if query_result.rowcount != 1:\n raise Exception(\n \"Fatal Error: The data was not updated.\",\n error_detected)\n\n return True","def update(self, obj, parent=None, **attrs):\n if isinstance(obj, ObjectRow):\n object_type, object_id = obj['type'], obj['id']\n else:\n object_type, object_id = obj\n\n type_attrs = self._get_type_attrs(object_type)\n get_pickle = False\n\n # Determine which inverted indexes need to be regenerated for this\n # object. Builds a dictionary of ivtidxes with a dirty flag and\n # a list of sql columns needed for reindexing.\n ivtidx_columns = {}\n for name, (attr_type, flags, attr_ivtidx, attr_split) in type_attrs.items():\n if flags & ATTR_INVERTED_INDEX:\n if attr_ivtidx not in ivtidx_columns:\n ivtidx_columns[attr_ivtidx] = [ False, [] ]\n if flags & ATTR_SEARCHABLE:\n ivtidx_columns[attr_ivtidx][1].append(name)\n if flags & (ATTR_SIMPLE | ATTR_IGNORE_CASE):\n get_pickle = True\n if name in attrs:\n ivtidx_columns[attr_ivtidx][0] = True\n\n if flags & ATTR_SIMPLE and name in attrs:\n # Simple attribute needs pickle\n get_pickle = True\n\n # TODO: if ObjectRow is supplied, don't need to fetch columns\n # that are available in the ObjectRow. (Of course this assumes\n # the object wasn't changed via elsewhere during the life of the\n # ObjectRow object, so maybe we don't want to do that.)\n reqd_columns = ['pickle'] if get_pickle else []\n for dirty, searchable_attrs in ivtidx_columns.values():\n if dirty:\n reqd_columns.extend(searchable_attrs)\n\n if reqd_columns:\n q = 'SELECT %s FROM objects_%s WHERE id=?' % (','.join(reqd_columns), object_type)\n row = self._db_query_row(q, (object_id,))\n if not row:\n raise ValueError, \"Can't update unknown object (%s, %d)\" % (object_type, object_id)\n if reqd_columns[0] == 'pickle' and row[0]:\n # One of the attrs we're updating is in the pickle, so we\n # have fetched it; now convert it to a dict.\n row_attrs = cPickle.loads(str(row[0]))\n for key, value in row_attrs.items():\n # Rename all __foo to foo for ATTR_IGNORE_CASE columns\n if key.startswith('__') and type_attrs[key[2:]][1] & ATTR_IGNORE_CASE:\n row_attrs[key[2:]] = value\n del row_attrs[key]\n # Update stored pickle data with new ATTR_SIMPLE attribute values\n row_attrs.update(attrs)\n attrs = row_attrs\n\n if isinstance(parent, ObjectRow):\n attrs['parent_type'], attrs['parent_id'] = parent['type'], parent['id']\n elif parent:\n attrs['parent_type'], attrs['parent_id'] = self._get_type_id(parent[0]), parent[1]\n\n attrs['id'] = object_id\n # Make copy of attrs for later query, since we're now about to mess with it.\n orig_attrs = attrs.copy()\n\n # Merge the ivtidx columns we grabbed above into attrs dict.\n for n, name in enumerate(reqd_columns):\n if name not in attrs and name != 'pickle':\n attrs[name] = row[n]\n\n for ivtidx, (dirty, searchable_attrs) in ivtidx_columns.items():\n if not dirty:\n # No attribute for this ivtidx changed.\n continue\n split = self._inverted_indexes[ivtidx]['split']\n # Remove existing indexed words for this object.\n self._delete_object_inverted_index_terms((object_type, object_id), ivtidx)\n\n # FIXME: code duplication from add()\n # Need to reindex all columns in this object using this ivtidx.\n terms_list = []\n for name, (attr_type, flags, attr_ivtidx, attr_split) in type_attrs.items():\n if attr_ivtidx == ivtidx and name in attrs:\n if attr_type == str and type(attrs[name]) == buffer:\n # We store string objects in the db as buffers, in\n # order to prevent any unicode issues. So we need\n # to convert the buffer we got from the db back to\n # a string before parsing the attribute into terms.\n attrs[name] = str(attrs[name])\n terms_list.append((attrs[name], 1.0, attr_split or split, ivtidx))\n\n if ivtidx in attrs and ivtidx not in type_attrs:\n # Attribute named after an inverted index is given, but\n # that ivtidx is not a named attribute (which would be handled\n # in the for loop just above).\n terms_list.append((attrs[ivtidx], 1.0, split, ivtidx))\n\n terms = self._score_terms(terms_list)\n self._add_object_inverted_index_terms((object_type, object_id), ivtidx, terms)\n if ivtidx in type_attrs:\n # Registered attribute named after ivtidx; store ivtidx\n # terms in object.\n orig_attrs[ivtidx] = terms.keys()\n\n query, values = self._make_query_from_attrs(\"update\", orig_attrs, object_type)\n self._db_query(query, values)","def put(self, request, **resources):\r\n if not self._meta.form:\r\n return None\r\n\r\n if not self._meta.name in resources or not resources[self._meta.name]:\r\n raise HttpError(\r\n \"Resource not found.\", status=status.HTTP_404_NOT_FOUND)\r\n resource = resources.pop(self._meta.name)\r\n\r\n updated = UpdatedList()\r\n for o in as_tuple(resource):\r\n form = self._meta.form(data=request.data, instance=o, **resources)\r\n\r\n if not form.is_valid():\r\n raise FormError(form)\r\n\r\n updated.append(form.save())\r\n\r\n return updated if len(updated) > 1 else updated[-1]","def update(self, request, pk=None):\n\n return Response({'http_method':'PUT'})","def patch(self, request, pk):\n return self.partial_update(request, pk)","def updateItem(self, object):\n pass","def update_element(cls, condition=None, async=True, **kwargs):\n\n command = cls.__table__.update().values(**kwargs)\n\n if condition is not None:\n command = command.where(condition)\n\n return DBConnection.execute_command(command=command, async=async)","def update_all(self, request):\n\n schema = self.session.info['schema']\n\n for item in self.query().filter_by(schema=schema):\n self.session.delete(item)\n\n for item in ElectionCollection(self.session).query():\n self.update(item, request)\n\n for item in ElectionCompoundCollection(self.session).query():\n self.update(item, request)\n\n for item in VoteCollection(self.session).query():\n self.update(item, request)","def update(self, uri, values, where, selectionArgs):\n pass","def update(task_id, task):\n # Get the task requested from the db into session\n update_task = TaskList.query.filter(TaskList.task_id == task_id).one_or_none()\n\n # Did we find the task?\n if update_task is not None: \n\n # turn the passed in task into a db object\n schema = TaskListSchema()\n update = schema.load(task, session=db.session).data\n print(update)\n\n # Set the id to the task we want to update\n update.task_id = update_task.task_id\n\n # merge the new object into the old and commit it to the db\n db.session.merge(update)\n db.session.commit()\n\n # return updated task in the response\n data = schema.dump(update_task).data\n\n return data, 200\n # otherwise, nope, that's an error\n else:\n abort(\n 404, \"Task {task_id} not found\".format(task_id=task_id),\n )","def do_update(self, arg):\n args = arg.split()\n object_dict = storage.all()\n if len(args) == 0:\n print(\"** class name missing **\")\n return\n if args[0] in self.class_dict:\n if len(args) == 1:\n print(\"** instance id missing **\")\n return\n elif len(args) == 2:\n print(\"** attribute name missing **\")\n return\n elif len(args) == 3:\n print(\"** value missing **\")\n return\n else:\n print(\"** class doesn't exist **\")\n return\n\n for i in range(len(args)):\n if args[i].startswith('\"') and args[i].endswith('\"'):\n args[i] = args[i][1:-1]\n\n for full_key in object_dict.keys():\n key = full_key.split('.')\n key_id = key[1]\n if args[0] in self.class_dict:\n if args[1] == object_dict[full_key].id:\n setattr(object_dict[full_key], args[2], args[3])\n setattr(object_dict[full_key], \"updated_at\",\n datetime.now())\n storage.save()\n return\n else:\n print(\"** class doesn't exist **\")\n return\n print(\"** no instance found **\")","def patch(self, entity_id=None, **kwargs):\n entity = self.fetcher.get_entity(entity_id, **kwargs)\n if not entity:\n raise NotFound\n self._verify_etag(entity)\n\n incoming_data, errors = self._patch_schema().load(self.patch_data)\n if errors:\n raise FlumpUnprocessableEntity(errors=errors)\n\n entity = self.orm_integration.update_entity(entity,\n incoming_data.attributes)\n entity_data = self._build_entity_data(entity)\n response_data = ResponseData(entity_data, {'self': request.url})\n\n data, _ = self.response_schema(strict=True).dump(response_data)\n response = jsonify(data)\n response.set_etag(str(entity_data.meta.etag))\n return response, 200","def update( id=UNDEFINED, identifier=UNDEFINED, prioritya=UNDEFINED, priorityb=UNDEFINED, priorityc=UNDEFINED, priorityd=UNDEFINED, prioritye=UNDEFINED, created_at=UNDEFINED, updated_at=UNDEFINED, published_at=UNDEFINED, processed=UNDEFINED):\n errors = []\n params = dict( filter( lambda i: not isinstance( i, SV ), locals().items() ) )\n if 'id' not in params:\n return None, [(\"'id' is a required parameter to update\", None, None)]\n n, errors = note.update( **params )\n try: \n return db_to_model(n), errors\n except:\n return None, [sys.exc_info()] + errors","def put(self, request, pk):\n return self.update(request, pk)","def _update(self, context, values, prune_stats=False):\n return db.compute_node_update(context, self.compute_node['id'],\n values, prune_stats)","def update(self, *args, **kwargs):\n if len(args):\n for i, val in enumerate(args):\n if i == 0:\n self.id = val\n elif i == 1:\n self.size = val\n elif i == 2:\n self.x = val\n elif i == 3:\n self.y = val\n else:\n for key, val in kwargs.items():\n if key == \"id\":\n self.id = val\n if key == \"size\":\n self.size = val\n if key == \"x\":\n self.x = val\n if key == \"y\":\n self.y = val","def updateAll(self):\n \tself.idToUpdate=''\n \tself.newState=''\n \tself.save()"],"string":"[\n \"def entityUpdates(self, *args):\\n\\t\\tfor entity in self.members.values():\\n\\t\\t\\tentity.update(*args)\",\n \"def update_entities(self):\\n raise NotImplementedError()\",\n \"def update_many(\\n self,\\n *args: Union[dict, Mapping],\\n session: Optional[ClientSession] = None\\n ) -> UpdateMany:\\n return self.update(*args, session=session)\",\n \"def update(cls, values):\\n result = yield UpdateQuery(cls, values).execute()\\n returnValue(result)\",\n \"def update(self, *args):\\n qry = UpdateEntityQuery(self)\\n self.context.add_query(qry)\\n return self\",\n \"def update(self, values):\\n return self.manager.update(self, values)\",\n \"def updateAllEntities():\\n entityKeys=list(registeredEntities.keys())\\n for currKey in entityKeys:\\n try:\\n currEntity=registeredEntities[currKey]\\n currEntity.update()\\n except KeyError:\\n #this should only be called if an entity is deleted (like if a rock got hit by a bullet)\\n continue\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def update(self, **kwargs):\\n return self.manager.update(self, **kwargs)\",\n \"def _update_entities(*entities):\\n futures = []\\n for entity in entities:\\n futures.append(entity.put_async())\\n Future.wait_all(futures)\\n results = []\\n for future in futures:\\n results.append(future.get_result())\\n return results\",\n \"def update(self, request, pk):\\n if pk is None:\\n for item in request.data:\\n # get object by its primary key\\n obj = self._object_get(item[self.model._meta.pk.attname])\\n self._object_update(obj, item)\\n else:\\n obj = self._object_get(pk)\\n self._object_update(obj, request.data)\\n return obj\",\n \"def update_batch(self, *args, **kwargs):\\n pass\",\n \"def _update_bulk(self, iterable):\\n self.cursor.executemany(self.UPDATE, iterable)\",\n \"def update(self, **values):\\r\\n if self.__abstract__:\\r\\n raise ThunderdomeException('cant update abstract elements')\\r\\n self.pre_update(**values)\\r\\n for key in values.keys():\\r\\n if key not in self._columns:\\r\\n raise TypeError(\\\"unrecognized attribute name: '{}'\\\".format(key))\\r\\n\\r\\n for k,v in values.items():\\r\\n setattr(self, k, v)\\r\\n\\r\\n return self.save()\",\n \"def _update_internal(self, entity_id, data, commit=True):\\n input_data = self.to_model(data)\\n self.validate_present(input_data)\\n if not input_data:\\n raise UnprocessableEntity(\\\"Can not update using empty data.\\\")\\n entity = db_session.query(self.model).get(entity_id)\\n if not entity:\\n raise NotFound(\\\"Could not find any entity with specified parameters.\\\")\\n\\n for k, v in input_data.items():\\n try:\\n setattr(entity, k, v)\\n except ValueError as e:\\n raise UnprocessableEntity(f\\\"Could not save value.\\\", fields=k, what=BAD_VALUE) from e\\n\\n if commit:\\n db_session.commit()\\n \\n return self.to_obj(entity)\",\n \"def bulk_update(self, iterable):\\n inserted, updated = [], []\\n for d, h in iterable:\\n if d in self:\\n updated.append((d, h))\\n else:\\n inserted.append((d, h))\\n self._update_bulk(updated)\\n self._insert_bulk(inserted)\",\n \"def update_entity(self, entity_obj):\\n if (\\n type(entity_obj) is not dict\\n or \\\"entity_id\\\" not in entity_obj\\n or \\\"mentions\\\" not in entity_obj\\n ):\\n raise ValueError(\\n \\\"The input to update_entity needs to be a dictionary with an entity_id key and mentions key as \\\"\\n \\\"you are replacing the entity information in bulk.\\\"\\n )\\n if not self._entity_symbols.qid_exists(entity_obj[\\\"entity_id\\\"]):\\n raise ValueError(f\\\"The entity {entity_obj['entity_id']} is not in our dump\\\")\\n try:\\n ent = EntityObj(\\n entity_id=entity_obj[\\\"entity_id\\\"],\\n mentions=entity_obj[\\\"mentions\\\"],\\n title=entity_obj.get(\\\"title\\\", entity_obj[\\\"entity_id\\\"]),\\n types=entity_obj.get(\\\"types\\\", {}),\\n relations=entity_obj.get(\\\"relations\\\", []),\\n )\\n except ValidationError as e:\\n print(e.json())\\n raise e\\n # Update mentions\\n for men in self.get_mentions(ent.entity_id):\\n self._entity_symbols.remove_alias(ent.entity_id, men)\\n for men in ent.mentions:\\n # Lower case mentions for mention extraction\\n men = [get_lnrm(men[0], strip=True, lower=True), men[1]]\\n self._entity_symbols.add_alias(ent.entity_id, men)\\n # Update title\\n self._entity_symbols.set_title(ent.entity_id, ent.title)\\n # Update types\\n for type_sys in self._type_systems:\\n for typename in self._type_systems[type_sys].get_types(ent.entity_id):\\n self._type_systems[type_sys].remove_type(ent.entity_id, typename)\\n for type_sys in ent.types:\\n for typename in ent.types[type_sys]:\\n self._type_systems[type_sys].add_type(ent.entity_id, typename)\\n # Update KG\\n if self._kg_symbols is not None:\\n for rel in self._kg_symbols.get_relations(ent.entity_id):\\n for qid2 in self._kg_symbols.get_connections_by_relation(\\n ent.entity_id, rel\\n ):\\n self._kg_symbols.remove_kg(ent.entity_id, rel, qid2)\\n for rel_pair in ent.relations:\\n self._kg_symbols.add_kg(\\n ent.entity_id, rel_pair[\\\"relation\\\"], rel_pair[\\\"object\\\"]\\n )\",\n \"def _update(self, model_obj):\\n conn = self._get_session()\\n db_item = None\\n\\n # Fetch the record from database\\n try:\\n identifier = getattr(model_obj, id_field(self.entity_cls).attribute_name)\\n db_item = conn.query(self.model_cls).get(\\n identifier\\n ) # This will raise exception if object was not found\\n except DatabaseError as exc:\\n logger.error(f\\\"Database Record not found: {exc}\\\")\\n raise\\n\\n if db_item is None:\\n conn.rollback()\\n conn.close()\\n raise ObjectNotFoundError(\\n {\\n \\\"_entity\\\": f\\\"`{self.entity_cls.__name__}` object with identifier {identifier} \\\"\\n f\\\"does not exist.\\\"\\n }\\n )\\n\\n # Sync DB Record with current changes. When the session is committed, changes are automatically synced\\n try:\\n for attribute in attributes(self.entity_cls):\\n if attribute != id_field(self.entity_cls).attribute_name and getattr(\\n model_obj, attribute\\n ) != getattr(db_item, attribute):\\n setattr(db_item, attribute, getattr(model_obj, attribute))\\n except DatabaseError as exc:\\n logger.error(f\\\"Error while updating: {exc}\\\")\\n raise\\n finally:\\n if not current_uow:\\n conn.commit()\\n conn.close()\\n\\n return model_obj\",\n \"def update_batch_of_entitiies(self, username, entity_batch_data):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY_BATCH, username + '|' + str(entity_batch_data))\",\n \"def update_entity(self, username, entity_data):\\n\\t\\treturn self._send_command_to_entity_server(us.SERVER_COMMAND_UPDATE_ENTITY, username + '|' + str(entity_data))\",\n \"def update(self, **kwargs):\\n return self._update_data(self.put(None, data=kwargs))\",\n \"def update(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def bulk_update(self, iterable):\\n inserted, updated = [], []\\n for d, h in iterable:\\n if -d in self:\\n updated.append((-d, h))\\n else:\\n inserted.append((-d, h))\\n self._update_bulk(updated)\\n self._insert_bulk(inserted)\",\n \"def update(\\n self,\\n *args: Union[dict, Mapping],\\n session: Optional[ClientSession] = None\\n ):\\n self.set_session(session=session)\\n return (\\n self.UpdateQueryType(\\n document_model=self.document_model,\\n find_query=self.get_filter_query(),\\n )\\n .update(*args)\\n .set_session(session=self.session)\\n )\",\n \"async def update(self, pk, payload):\\n\\n self.log.info(payload)\\n await self.db.update(pk, payload)\\n return await self.get_one(pk)\",\n \"def update(self, request, pk=None): #update a specific object\\n return Response({'http_method': 'PUT'})\",\n \"def update(self, obj, data):\\n self.get(obj[self.model.pk_field.name])\\n self.validate_fields(data)\\n\\n fields = []\\n values = []\\n\\n for k, v in data.iteritems():\\n if k in self.model.get_fields_name():\\n fields.append(k)\\n values.append(v)\\n\\n conn = self.get_connector()\\n cursor = conn.cursor()\\n update = \\\" ,\\\".join([\\\"{0}='{1}'\\\".format(f, v) for f, v in zip(fields,\\n values)])\\n query = \\\"update {0} set {1} WHERE {2}={3}\\\".format(\\n self.ressource_config[\\\"table\\\"],\\n update,\\n self.model.pk_field.name,\\n obj[self.model.pk_field.name]\\n )\\n\\n cursor.execute(query)\\n conn.commit()\\n conn.close()\\n\\n return self.get(obj[self.model.pk_field.name])\",\n \"def update(self, table_name, fields, keys=None, any=False, eids=None):\\n table = self.db.table(table_name)\\n if eids is not None:\\n LOGGER.debug(\\\"%r: update(%r, eids=%r)\\\" % (table_name, fields, eids))\\n if isinstance(eids, list):\\n return table.update(fields, eids=eids)\\n else:\\n return table.update(fields, eids=[eids])\\n else:\\n LOGGER.debug(\\\"%r: update(%r, keys=%r)\\\" % (table_name, fields, keys))\\n return table.update(fields, self._getQuery(keys, any))\",\n \"def update(self, attributes, type=None, name=None, identity=None):\\n attributes = attributes or {}\\n type = type or attributes.get('type')\\n name = name or attributes.get('name')\\n identity = identity or attributes.get('identity')\\n if name and identity:\\n name = None # Only send one\\n request = self.request(operation='UPDATE', type=type, name=name,\\n identity=identity, body=self.clean_attrs(attributes))\\n return Entity(self, self.call(request).body)\",\n \"def update(self, **values):\\n\\n return self._put(\\\"\\\", None, values)\",\n \"def update(self, _id, data: dict) -> tuple:\\n item = self.model.find_by_id(_id)\\n if item:\\n try:\\n for field in data.keys():\\n setattr(item, field, verify_date_field(field, data[field]))\\n item.save()\\n items = self.get_all()\\n\\n return items\\n except DataBaseException as e:\\n return {'error': {'message': e.message}}, 500\\n else:\\n return {'error': {'message': 'Item not found'}}, 400\",\n \"def update(entity_list):\\n for entity in entity_list:\\n # Only moveable entities should have the dest field\\n if \\\"dest\\\" in entity:\\n # If no destination, pick a new random one\\n if entity[\\\"dest\\\"] == None:\\n entity[\\\"dest\\\"] = random_pos(100, 100)\\n \\n # Move one step towards destination\\n cpos = entity[\\\"position\\\"]\\n dest = entity[\\\"dest\\\"]\\n entity[\\\"position\\\"] = move(cpos, dest) \\n\\n # Clear destination if it has been reached\\n if entity[\\\"dest\\\"] == entity[\\\"position\\\"]:\\n entity[\\\"dest\\\"] = None\",\n \"def bulk_update(self, objs, fields, batch_size=None):\\n if batch_size is not None and batch_size <= 0:\\n raise ValueError(\\\"Batch size must be a positive integer.\\\")\\n if not fields:\\n raise ValueError(\\\"Field names must be given to bulk_update().\\\")\\n objs = tuple(objs)\\n if any(obj.pk is None for obj in objs):\\n raise ValueError(\\\"All bulk_update() objects must have a primary key set.\\\")\\n fields = [self.model._meta.get_field(name) for name in fields]\\n if any(not f.concrete or f.many_to_many for f in fields):\\n raise ValueError(\\\"bulk_update() can only be used with concrete fields.\\\")\\n if any(f.primary_key for f in fields):\\n raise ValueError(\\\"bulk_update() cannot be used with primary key fields.\\\")\\n if not objs:\\n return 0\\n for obj in objs:\\n obj._prepare_related_fields_for_save(\\n operation_name=\\\"bulk_update\\\", fields=fields\\n )\\n # PK is used twice in the resulting update query, once in the filter\\n # and once in the WHEN. Each field will also have one CAST.\\n self._for_write = True\\n connection = connections[self.db]\\n max_batch_size = connection.ops.bulk_batch_size([\\\"pk\\\", \\\"pk\\\"] + fields, objs)\\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\\n requires_casting = connection.features.requires_casted_case_in_updates\\n batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))\\n updates = []\\n for batch_objs in batches:\\n update_kwargs = {}\\n for field in fields:\\n when_statements = []\\n for obj in batch_objs:\\n attr = getattr(obj, field.attname)\\n if not hasattr(attr, \\\"resolve_expression\\\"):\\n attr = Value(attr, output_field=field)\\n when_statements.append(When(pk=obj.pk, then=attr))\\n case_statement = Case(*when_statements, output_field=field)\\n if requires_casting:\\n case_statement = Cast(case_statement, output_field=field)\\n update_kwargs[field.attname] = case_statement\\n updates.append(([obj.pk for obj in batch_objs], update_kwargs))\\n rows_updated = 0\\n queryset = self.using(self.db)\\n with transaction.atomic(using=self.db, savepoint=False):\\n for pks, update_kwargs in updates:\\n rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)\\n return rows_updated\",\n \"def update(self, *args: Any, **kwargs: Any) -> None:\\n self._check_for_increment(\\\"update\\\")\\n self[-1].update(*args, **kwargs)\",\n \"def update(self, request, *args, **kwargs):\\n orig_get_queryset = self.get_queryset\\n\\n def patched_get_queryset():\\n \\\"\\\"\\\"Patched get_queryset method.\\\"\\\"\\\"\\n entity_ids = orig_get_queryset().values_list(\\\"id\\\", flat=True)\\n return Entity.objects.filter(id__in=entity_ids)\\n\\n self.get_queryset = patched_get_queryset\\n\\n resp = super().update(request, *args, **kwargs)\\n\\n self.get_queryset = orig_get_queryset\\n return resp\",\n \"def update(self, *others):\\r\\n return self.r.sunion(self.r_key, *[o.r_key for o in others])\",\n \"def update(self, update_fields=None):\\n instance = self.get_object() \\n if not update_fields: \\n update_fields=self.request.PUT.keys()\\n try: \\n for field in update_fields:\\n update_value = self.request.PUT.get(field) # get value from PUT\\n setattr(instance, field, update_value) # renew fields\\n instance.save() # save updates\\n except IntegrityError: # catch error\\n return self.response(status='Failed to Update.') \\n return self.response(\\n status='Successfully Update')\",\n \"def Update(self) -> T:\",\n \"def test_update_multiple(test_store, andy, pandy, candy):\\n n_updated = test_store.update(fields={\\\"age\\\": 14}, age=12)\\n assert n_updated == 2\\n items = list(test_store.get_by())\\n\\n andy.age = pandy.age = 14\\n assert andy in items\\n assert pandy in items\\n assert candy in items\",\n \"def update_one(\\n self, *args, session: Optional[ClientSession] = None\\n ) -> UpdateOne:\\n return self.update(*args, session=session)\",\n \"def put(self):\\n # TODO: What kind of errors do I contemplate for here? How do I handle\\n # them?\\n if isinstance(self.request.data, self.model):\\n self.request.data.save(force_update=True)\\n else:\\n for instance in self.request.data:\\n instance.save(force_update=True)\\n return self.request.data\",\n \"async def modify(\\n self, item: T, update: Union[dict, MotycQuery], *,\\n inject_default_id: bool = None,\\n ) -> T:\\n\\n assert isinstance(item, BaseModel), \\\"Can only handle BaseModel, not dict i.g.\\\"\\n\\n document = item.dict(by_alias=True)\\n\\n assert document.get(self.identity) is not None, f\\\"Need identity ({self.identity}) to update model.\\\"\\n\\n return await self.update_one(\\n {self.identity: document[self.identity]},\\n update,\\n inject_default_id=inject_default_id\\n )\",\n \"async def update_many(\\n self,\\n update_document: Dict[str, Any],\\n *,\\n filter: Optional[Dict[str, Any]] = DEFAULT_FILTER,\\n session: Optional[Any] = DEFAULT_SESSION,\\n **kwargs: Any,\\n ) -> UpdateResult:\\n return await self._database.update_many(\\n self.name,\\n update_document=update_document,\\n filter=filter,\\n session=session,\\n **kwargs,\\n )\",\n \"def update(cls, dto: dict):\\n entity = cls.from_dict(dto)\\n try:\\n valid_entity = cls.find_by_id(dto[\\\"id\\\"])\\n except KeyError as e:\\n raise AppException(\\\"Can't find key {}\\\".format(e))\\n\\n if not valid_entity:\\n return None\\n\\n # validate creation your creation.\\n entity.creation_validation()\\n\\n # Copy all attributes from entity to valid_entity.\\n valid_entity << entity\\n\\n return valid_entity\",\n \"def update(self):\\n values = {}\\n for field in self.fields():\\n attr = object.__getattribute__(self, field)\\n if not attr.auto_value and attr._updated:\\n values[field] = getattr(self, field)\\n object.__setattr__(attr, '_updated', False)\\n result = self.where({self.__class__.get_primary():self.primary})\\n if len(values) == 0:\\n logging.warning('update() called on model with no changed fields.')\\n return None\\n return result.update(values)[0]\",\n \"def update(self, updates, predicate):\\n for row in self.rows:\\n if predicate(row):\\n for column, new_value in updates.items():\\n row[column] = new_value\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, *args, **kwargs):\\n pass\",\n \"def update(self, es, **kwargs):\\n pass\",\n \"def update(self, *args, **kw):\\n pass\",\n \"def update(self, commit=True, **kwargs):\\n # Prevent changing IDS\\n kwargs.pop('id', None)\\n for attr, value in kwargs.iteritems():\\n # Flask-restful makes everything None by default\\n if value is not None:\\n setattr(self, attr, value)\\n return commit and self.save() or self\",\n \"def _process(self, start_key, batch_size):\\n\\n query = self.MODEL.all()\\n if start_key:\\n query.filter('__key__ > ', start_key)\\n\\n try:\\n entities = query.fetch(batch_size)\\n\\n if not entities:\\n # all entities has already been processed\\n return\\n\\n for entity in entities:\\n for field in self.FIELDS_TO_UPDATE:\\n old_reference = getattr(entity, field)\\n\\n if not old_reference:\\n continue\\n\\n # check if the field has not been updated\\n if isinstance(old_reference, self.PROFILE_MODEL):\\n continue\\n\\n profile = _getProfileForRole(old_reference, self.PROFILE_MODEL)\\n setattr(entity, field, profile)\\n\\n for list_property in self.LISTS_TO_UPDATE:\\n l = getattr(entity, list_property)\\n new_l = []\\n for key in l:\\n new_l.append(_getProfileKeyForRoleKey(key, self.PROFILE_MODEL))\\n setattr(entity, list_property, new_l)\\n\\n db.put(entities)\\n start_key = entities[-1].key()\\n deferred.defer(self._process, start_key, batch_size)\\n except DeadlineExceededError:\\n # here we should probably be more careful\\n deferred.defer(self._process, start_key, batch_size)\",\n \"async def update_one(self, where, data):\\n\\n pass\",\n \"def partial_update(self, request, pk=None): #partial update a specific object\\n return Response({'http_method': 'PATCH'})\",\n \"def update(self, **kwargs):\\n\\n return self.api_request(self._get_method_fullname(\\\"update\\\"), kwargs)\",\n \"def update(self, **kwargs):\\n\\n return self.api_request(self._get_method_fullname(\\\"update\\\"), kwargs)\",\n \"def update(self, **kwargs):\\n\\n return self.api_request(self._get_method_fullname(\\\"update\\\"), kwargs)\",\n \"def update_character_eveentitydata(op, data_model, character_id, delete=False):\\n character = EveCharacter.objects.get(external_id=character_id)\\n\\n response = EveClient.call(op, character_id=character.external_id)\\n\\n if response.status != 200:\\n if response.status in [502, 503, 504]:\\n logger.warning(\\n f\\\"Skipping batch update {data_model.__name__} for {character_id} due to ESI error\\\")\\n return\\n else:\\n logger.error(\\n f\\\"[{response.status}] Failed to batch update {data_model.__name__} for {character_id}: {response.header} {response.data}\\\")\\n return\\n\\n items = response.data\\n\\n if 'X-Pages' in response.header and response.header['X-Pages'][0] > 1:\\n for num in range(2, response.header['X-Pages'][0]+1):\\n response = EveClient.call(\\n op, character_id=character.external_id, page=num)\\n if response.status != 200:\\n continue\\n items += response.data\\n\\n if len(items) == 0:\\n return []\\n\\n if delete:\\n data_model.objects.filter(entity=character).delete()\\n\\n data_model.create_from_esi_response(items, character.external_id)\\n\\n return items\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update_corporation_eveentitydata(op, data_model, corporation_id, delete=False):\\n\\n corporation = EveCorporation.objects.get(external_id=corporation_id)\\n\\n response = EveClient.call(op, corporation_id=corporation.external_id)\\n\\n if response.status != 200:\\n logger.error(\\n f\\\"[{response.status}] Failed to batch update {data_model.__name__} for {character_id}: {response.header} {response.data}\\\")\\n return\\n\\n items = response.data\\n\\n if 'X-Pages' in response.header and response.header['X-Pages'][0] > 1:\\n for num in range(2, response.header['X-Pages'][0]+1):\\n response = EveClient.call(\\n op, corporation_id=corporation.external_id, page=num)\\n if response.status != 200:\\n continue\\n items += response.data\\n\\n if len(items) == 0:\\n return []\\n\\n if delete:\\n data_model.objects.filter(entity=corporation).delete()\\n\\n data_model.create_from_esi_response(items, corporation.external_id)\\n\\n return items\",\n \"def _update(self, values):\\n if self.query.is_sliced:\\n raise TypeError(\\\"Cannot update a query once a slice has been taken.\\\")\\n query = self.query.chain(sql.UpdateQuery)\\n query.add_update_fields(values)\\n # Clear any annotations so that they won't be present in subqueries.\\n query.annotations = {}\\n self._result_cache = None\\n return query.get_compiler(self.db).execute_sql(CURSOR)\",\n \"def update(self, resource, keys_vals, url_prefix, auth, session, send_opts):\\n success = True\\n exc = HTTPErrorList('At least one key-value update failed.')\\n\\n for pair in keys_vals.items():\\n key = pair[0]\\n value = pair[1]\\n req = self.get_metadata_request(\\n resource, 'PUT', 'application/json', url_prefix, auth,\\n key, value)\\n prep = session.prepare_request(req)\\n resp = session.send(prep, **send_opts)\\n\\n if resp.status_code == 200:\\n continue\\n\\n err = (\\n 'Update failed for {}: {}:{}, got HTTP response: ({}) - {}'\\n .format(resource.name, key, value, resp.status_code, resp.text))\\n exc.http_errors.append(HTTPError(err, request=req, response=resp))\\n success = False\\n\\n if not success:\\n raise exc\",\n \"def update(self, request, pk=None):\\n\\n return Response({'http_method': 'PUT'})\",\n \"def update_entities(self, entities: List[str]) -> None:\\n self._entities = entities or []\",\n \"def put(self, request, pk=None): #pk of id of objects to be updated (DB)\\n return Response({'method':'PUT'})\",\n \"def update(self, data: Union[QueryWithResponse, List[QueryWithResponse]], **kwargs):\\n raise NotImplementedError\",\n \"def update(self, **kwargs):\\n return self._object.update(meta=kwargs)\",\n \"def test_update_all(test_store, andy, pandy, candy):\\n n_updated = test_store.update(fields={\\\"age\\\": 13})\\n assert n_updated == 3\\n items = list(test_store.get_by())\\n\\n andy.age = pandy.age = 13\\n assert andy in items\\n assert pandy in items\\n assert candy in items\",\n \"def update(self, request, pk=None):\\n return Response({'http_method': 'PUT'})\",\n \"def update(self, **kwargs):\\n expr = self.model.__table__.update().where(self.query).values(**kwargs)\\n return self._runquery(expr)\",\n \"def update_many(\\n cls,\\n *,\\n pks: List[Union[str, int]],\\n update: Dict[str, Any],\\n sychronize_session: bool = False,\\n ) -> None:\\n if pks:\\n db.session.query(cls).filter(\\n getattr(cls, cls.get_primary_key()).in_(pks)\\n ).update(update, synchronize_session=sychronize_session)\\n db.session.commit()\\n cache.delete_many(*(cls.create_cache_key(pk) for pk in pks))\",\n \"def update( # type: ignore # dead: disable\\n self, entity: KeyValueEntity\\n ) -> t.Optional[KeyValueEntity]:\\n if entity.uuid not in self._data:\\n raise KeyError()\\n\\n self._data[entity.uuid] = entity.value\\n return entity\",\n \"def update(*args):\",\n \"def update(self, *args, **kwargs):\",\n \"async def callback_update_entities(\\n self,\\n device: Device,\\n message_id: int,\\n state: DeviceResponseState,\\n action: str,\\n data: Tuple[\\\"Command\\\", Dict, int],\\n ) -> NoReturn:\\n if (\\n device\\n and action in (ACTION_COMMAND_RESPONSE, ACTION_DEVICE_MESSAGE)\\n and state == DeviceResponseState.SUCCESS\\n ):\\n\\n _LOGGER.debug(\\n \\\"Received response (message ID: %d) from information command (action: %s) with data: %s\\\"\\n % (message_id, action, data)\\n )\\n command, data, frame_number = data\\n\\n update_entities = self.device_entities.get(device.device_id)\\n\\n if not update_entities:\\n _LOGGER.info(\\\"Device %s does not have any associated entities\\\" % device.device_id)\\n else:\\n protocol_id = self.devices_config_entries[device.device_id][CONF_PROTOCOL]\\n protocol = SUPPORTED_PROTOCOLS[protocol_id]\\n\\n attribute_filter = protocol.get(PROTOCOL_FILTER)\\n attributes = attribute_filter(data) if callable(attribute_filter) else data\\n\\n tasks = [\\n asyncio.create_task(entity.handle_data_update(attributes))\\n for entity in update_entities\\n if entity.command_receive == command.name\\n ]\\n\\n if tasks:\\n _LOGGER.debug(\\n 'Performing update on %d entities for command \\\"%s\\\"'\\n % (len(tasks), command.name)\\n )\\n await asyncio.wait(tasks)\\n _LOGGER.debug(\\\"Update complete!\\\")\\n else:\\n _LOGGER.debug('No updates scheduled for command \\\"%s\\\"' % command.name)\",\n \"def update(self):\\n self.attributes = self.call('UPDATE', expect=error.OK, body=self.attributes)\",\n \"def storage_update(context, storage_id, values):\\n session = get_session()\\n with session.begin():\\n query = _storage_get_query(context, session)\\n result = query.filter_by(id=storage_id).update(values)\\n return result\",\n \"def update_compound_key(self, ids, values, entity_name=None):\\n try:\\n options = {\\\"options\\\": ids, \\\"values\\\": values}\\n query_result = self.query(\\n \\\"update\\\", entity_name or self.__entity_name, options)\\n except Exception as error:\\n error_detected = error\\n\\n if query_result.rowcount != 1:\\n raise Exception(\\n \\\"Fatal Error: The data was not updated.\\\",\\n error_detected)\\n\\n return True\",\n \"def update(self, obj, parent=None, **attrs):\\n if isinstance(obj, ObjectRow):\\n object_type, object_id = obj['type'], obj['id']\\n else:\\n object_type, object_id = obj\\n\\n type_attrs = self._get_type_attrs(object_type)\\n get_pickle = False\\n\\n # Determine which inverted indexes need to be regenerated for this\\n # object. Builds a dictionary of ivtidxes with a dirty flag and\\n # a list of sql columns needed for reindexing.\\n ivtidx_columns = {}\\n for name, (attr_type, flags, attr_ivtidx, attr_split) in type_attrs.items():\\n if flags & ATTR_INVERTED_INDEX:\\n if attr_ivtidx not in ivtidx_columns:\\n ivtidx_columns[attr_ivtidx] = [ False, [] ]\\n if flags & ATTR_SEARCHABLE:\\n ivtidx_columns[attr_ivtidx][1].append(name)\\n if flags & (ATTR_SIMPLE | ATTR_IGNORE_CASE):\\n get_pickle = True\\n if name in attrs:\\n ivtidx_columns[attr_ivtidx][0] = True\\n\\n if flags & ATTR_SIMPLE and name in attrs:\\n # Simple attribute needs pickle\\n get_pickle = True\\n\\n # TODO: if ObjectRow is supplied, don't need to fetch columns\\n # that are available in the ObjectRow. (Of course this assumes\\n # the object wasn't changed via elsewhere during the life of the\\n # ObjectRow object, so maybe we don't want to do that.)\\n reqd_columns = ['pickle'] if get_pickle else []\\n for dirty, searchable_attrs in ivtidx_columns.values():\\n if dirty:\\n reqd_columns.extend(searchable_attrs)\\n\\n if reqd_columns:\\n q = 'SELECT %s FROM objects_%s WHERE id=?' % (','.join(reqd_columns), object_type)\\n row = self._db_query_row(q, (object_id,))\\n if not row:\\n raise ValueError, \\\"Can't update unknown object (%s, %d)\\\" % (object_type, object_id)\\n if reqd_columns[0] == 'pickle' and row[0]:\\n # One of the attrs we're updating is in the pickle, so we\\n # have fetched it; now convert it to a dict.\\n row_attrs = cPickle.loads(str(row[0]))\\n for key, value in row_attrs.items():\\n # Rename all __foo to foo for ATTR_IGNORE_CASE columns\\n if key.startswith('__') and type_attrs[key[2:]][1] & ATTR_IGNORE_CASE:\\n row_attrs[key[2:]] = value\\n del row_attrs[key]\\n # Update stored pickle data with new ATTR_SIMPLE attribute values\\n row_attrs.update(attrs)\\n attrs = row_attrs\\n\\n if isinstance(parent, ObjectRow):\\n attrs['parent_type'], attrs['parent_id'] = parent['type'], parent['id']\\n elif parent:\\n attrs['parent_type'], attrs['parent_id'] = self._get_type_id(parent[0]), parent[1]\\n\\n attrs['id'] = object_id\\n # Make copy of attrs for later query, since we're now about to mess with it.\\n orig_attrs = attrs.copy()\\n\\n # Merge the ivtidx columns we grabbed above into attrs dict.\\n for n, name in enumerate(reqd_columns):\\n if name not in attrs and name != 'pickle':\\n attrs[name] = row[n]\\n\\n for ivtidx, (dirty, searchable_attrs) in ivtidx_columns.items():\\n if not dirty:\\n # No attribute for this ivtidx changed.\\n continue\\n split = self._inverted_indexes[ivtidx]['split']\\n # Remove existing indexed words for this object.\\n self._delete_object_inverted_index_terms((object_type, object_id), ivtidx)\\n\\n # FIXME: code duplication from add()\\n # Need to reindex all columns in this object using this ivtidx.\\n terms_list = []\\n for name, (attr_type, flags, attr_ivtidx, attr_split) in type_attrs.items():\\n if attr_ivtidx == ivtidx and name in attrs:\\n if attr_type == str and type(attrs[name]) == buffer:\\n # We store string objects in the db as buffers, in\\n # order to prevent any unicode issues. So we need\\n # to convert the buffer we got from the db back to\\n # a string before parsing the attribute into terms.\\n attrs[name] = str(attrs[name])\\n terms_list.append((attrs[name], 1.0, attr_split or split, ivtidx))\\n\\n if ivtidx in attrs and ivtidx not in type_attrs:\\n # Attribute named after an inverted index is given, but\\n # that ivtidx is not a named attribute (which would be handled\\n # in the for loop just above).\\n terms_list.append((attrs[ivtidx], 1.0, split, ivtidx))\\n\\n terms = self._score_terms(terms_list)\\n self._add_object_inverted_index_terms((object_type, object_id), ivtidx, terms)\\n if ivtidx in type_attrs:\\n # Registered attribute named after ivtidx; store ivtidx\\n # terms in object.\\n orig_attrs[ivtidx] = terms.keys()\\n\\n query, values = self._make_query_from_attrs(\\\"update\\\", orig_attrs, object_type)\\n self._db_query(query, values)\",\n \"def put(self, request, **resources):\\r\\n if not self._meta.form:\\r\\n return None\\r\\n\\r\\n if not self._meta.name in resources or not resources[self._meta.name]:\\r\\n raise HttpError(\\r\\n \\\"Resource not found.\\\", status=status.HTTP_404_NOT_FOUND)\\r\\n resource = resources.pop(self._meta.name)\\r\\n\\r\\n updated = UpdatedList()\\r\\n for o in as_tuple(resource):\\r\\n form = self._meta.form(data=request.data, instance=o, **resources)\\r\\n\\r\\n if not form.is_valid():\\r\\n raise FormError(form)\\r\\n\\r\\n updated.append(form.save())\\r\\n\\r\\n return updated if len(updated) > 1 else updated[-1]\",\n \"def update(self, request, pk=None):\\n\\n return Response({'http_method':'PUT'})\",\n \"def patch(self, request, pk):\\n return self.partial_update(request, pk)\",\n \"def updateItem(self, object):\\n pass\",\n \"def update_element(cls, condition=None, async=True, **kwargs):\\n\\n command = cls.__table__.update().values(**kwargs)\\n\\n if condition is not None:\\n command = command.where(condition)\\n\\n return DBConnection.execute_command(command=command, async=async)\",\n \"def update_all(self, request):\\n\\n schema = self.session.info['schema']\\n\\n for item in self.query().filter_by(schema=schema):\\n self.session.delete(item)\\n\\n for item in ElectionCollection(self.session).query():\\n self.update(item, request)\\n\\n for item in ElectionCompoundCollection(self.session).query():\\n self.update(item, request)\\n\\n for item in VoteCollection(self.session).query():\\n self.update(item, request)\",\n \"def update(self, uri, values, where, selectionArgs):\\n pass\",\n \"def update(task_id, task):\\n # Get the task requested from the db into session\\n update_task = TaskList.query.filter(TaskList.task_id == task_id).one_or_none()\\n\\n # Did we find the task?\\n if update_task is not None: \\n\\n # turn the passed in task into a db object\\n schema = TaskListSchema()\\n update = schema.load(task, session=db.session).data\\n print(update)\\n\\n # Set the id to the task we want to update\\n update.task_id = update_task.task_id\\n\\n # merge the new object into the old and commit it to the db\\n db.session.merge(update)\\n db.session.commit()\\n\\n # return updated task in the response\\n data = schema.dump(update_task).data\\n\\n return data, 200\\n # otherwise, nope, that's an error\\n else:\\n abort(\\n 404, \\\"Task {task_id} not found\\\".format(task_id=task_id),\\n )\",\n \"def do_update(self, arg):\\n args = arg.split()\\n object_dict = storage.all()\\n if len(args) == 0:\\n print(\\\"** class name missing **\\\")\\n return\\n if args[0] in self.class_dict:\\n if len(args) == 1:\\n print(\\\"** instance id missing **\\\")\\n return\\n elif len(args) == 2:\\n print(\\\"** attribute name missing **\\\")\\n return\\n elif len(args) == 3:\\n print(\\\"** value missing **\\\")\\n return\\n else:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n\\n for i in range(len(args)):\\n if args[i].startswith('\\\"') and args[i].endswith('\\\"'):\\n args[i] = args[i][1:-1]\\n\\n for full_key in object_dict.keys():\\n key = full_key.split('.')\\n key_id = key[1]\\n if args[0] in self.class_dict:\\n if args[1] == object_dict[full_key].id:\\n setattr(object_dict[full_key], args[2], args[3])\\n setattr(object_dict[full_key], \\\"updated_at\\\",\\n datetime.now())\\n storage.save()\\n return\\n else:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n print(\\\"** no instance found **\\\")\",\n \"def patch(self, entity_id=None, **kwargs):\\n entity = self.fetcher.get_entity(entity_id, **kwargs)\\n if not entity:\\n raise NotFound\\n self._verify_etag(entity)\\n\\n incoming_data, errors = self._patch_schema().load(self.patch_data)\\n if errors:\\n raise FlumpUnprocessableEntity(errors=errors)\\n\\n entity = self.orm_integration.update_entity(entity,\\n incoming_data.attributes)\\n entity_data = self._build_entity_data(entity)\\n response_data = ResponseData(entity_data, {'self': request.url})\\n\\n data, _ = self.response_schema(strict=True).dump(response_data)\\n response = jsonify(data)\\n response.set_etag(str(entity_data.meta.etag))\\n return response, 200\",\n \"def update( id=UNDEFINED, identifier=UNDEFINED, prioritya=UNDEFINED, priorityb=UNDEFINED, priorityc=UNDEFINED, priorityd=UNDEFINED, prioritye=UNDEFINED, created_at=UNDEFINED, updated_at=UNDEFINED, published_at=UNDEFINED, processed=UNDEFINED):\\n errors = []\\n params = dict( filter( lambda i: not isinstance( i, SV ), locals().items() ) )\\n if 'id' not in params:\\n return None, [(\\\"'id' is a required parameter to update\\\", None, None)]\\n n, errors = note.update( **params )\\n try: \\n return db_to_model(n), errors\\n except:\\n return None, [sys.exc_info()] + errors\",\n \"def put(self, request, pk):\\n return self.update(request, pk)\",\n \"def _update(self, context, values, prune_stats=False):\\n return db.compute_node_update(context, self.compute_node['id'],\\n values, prune_stats)\",\n \"def update(self, *args, **kwargs):\\n if len(args):\\n for i, val in enumerate(args):\\n if i == 0:\\n self.id = val\\n elif i == 1:\\n self.size = val\\n elif i == 2:\\n self.x = val\\n elif i == 3:\\n self.y = val\\n else:\\n for key, val in kwargs.items():\\n if key == \\\"id\\\":\\n self.id = val\\n if key == \\\"size\\\":\\n self.size = val\\n if key == \\\"x\\\":\\n self.x = val\\n if key == \\\"y\\\":\\n self.y = val\",\n \"def updateAll(self):\\n \\tself.idToUpdate=''\\n \\tself.newState=''\\n \\tself.save()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63851154","0.621751","0.61388403","0.6048954","0.60383564","0.59614515","0.5907158","0.5735908","0.5735908","0.5735908","0.5729625","0.570714","0.57034546","0.56934524","0.5678083","0.5675096","0.5666016","0.5653511","0.5618034","0.56139493","0.55728024","0.5554213","0.5550225","0.555009","0.55427927","0.54913074","0.54837966","0.54821897","0.54821444","0.5464683","0.5454559","0.54533744","0.5451581","0.54472864","0.54468966","0.54460955","0.54367375","0.5428244","0.5408789","0.54045415","0.53895503","0.5389347","0.53867036","0.537583","0.5373328","0.536587","0.53608716","0.5349533","0.5349533","0.5349533","0.53488404","0.53329396","0.5329431","0.53278685","0.53175247","0.53143287","0.53113943","0.53113943","0.53113943","0.5310922","0.53053117","0.53053117","0.53053117","0.53053117","0.53053117","0.53053117","0.5305051","0.52935416","0.5289652","0.5288139","0.5287916","0.5281427","0.5272592","0.5266624","0.52562153","0.52518225","0.5250091","0.5249143","0.5248437","0.5246936","0.5238152","0.523301","0.5231779","0.52139413","0.51999646","0.5199787","0.5187186","0.5184364","0.5180897","0.5178353","0.5176757","0.5176243","0.5175901","0.5174451","0.5170448","0.5161253","0.5146794","0.5127374","0.5124103","0.5123271","0.5121881"],"string":"[\n \"0.63851154\",\n \"0.621751\",\n \"0.61388403\",\n \"0.6048954\",\n \"0.60383564\",\n \"0.59614515\",\n \"0.5907158\",\n \"0.5735908\",\n \"0.5735908\",\n \"0.5735908\",\n \"0.5729625\",\n \"0.570714\",\n \"0.57034546\",\n \"0.56934524\",\n \"0.5678083\",\n \"0.5675096\",\n \"0.5666016\",\n \"0.5653511\",\n \"0.5618034\",\n \"0.56139493\",\n \"0.55728024\",\n \"0.5554213\",\n \"0.5550225\",\n \"0.555009\",\n \"0.55427927\",\n \"0.54913074\",\n \"0.54837966\",\n \"0.54821897\",\n \"0.54821444\",\n \"0.5464683\",\n \"0.5454559\",\n \"0.54533744\",\n \"0.5451581\",\n \"0.54472864\",\n \"0.54468966\",\n \"0.54460955\",\n \"0.54367375\",\n \"0.5428244\",\n \"0.5408789\",\n \"0.54045415\",\n \"0.53895503\",\n \"0.5389347\",\n \"0.53867036\",\n \"0.537583\",\n \"0.5373328\",\n \"0.536587\",\n \"0.53608716\",\n \"0.5349533\",\n \"0.5349533\",\n \"0.5349533\",\n \"0.53488404\",\n \"0.53329396\",\n \"0.5329431\",\n \"0.53278685\",\n \"0.53175247\",\n \"0.53143287\",\n \"0.53113943\",\n \"0.53113943\",\n \"0.53113943\",\n \"0.5310922\",\n \"0.53053117\",\n \"0.53053117\",\n \"0.53053117\",\n \"0.53053117\",\n \"0.53053117\",\n \"0.53053117\",\n \"0.5305051\",\n \"0.52935416\",\n \"0.5289652\",\n \"0.5288139\",\n \"0.5287916\",\n \"0.5281427\",\n \"0.5272592\",\n \"0.5266624\",\n \"0.52562153\",\n \"0.52518225\",\n \"0.5250091\",\n \"0.5249143\",\n \"0.5248437\",\n \"0.5246936\",\n \"0.5238152\",\n \"0.523301\",\n \"0.5231779\",\n \"0.52139413\",\n \"0.51999646\",\n \"0.5199787\",\n \"0.5187186\",\n \"0.5184364\",\n \"0.5180897\",\n \"0.5178353\",\n \"0.5176757\",\n \"0.5176243\",\n \"0.5175901\",\n \"0.5174451\",\n \"0.5170448\",\n \"0.5161253\",\n \"0.5146794\",\n \"0.5127374\",\n \"0.5124103\",\n \"0.5123271\",\n \"0.5121881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24398,"cells":{"query":{"kind":"string","value":"Called when the mapper has finished, to allow for any final work to be done."},"document":{"kind":"string","value":"def finish(self):\n logging.info(str(self) + ' Mapper finished.')\n if self.next_mapper is not None:\n logging.info(str(self) + ' Next: ' + str(self.next_mapper))\n self.next_mapper.run()\n pass"},"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 finished(self):\n pass","def _finished(self) -> None:","def finish(self):\n pass","def finish(self):\n pass","def finished(self):\n raise NotImplementedError()","def finished(self):\r\n raise NotImplementedError","def finished(self):","def finish(self):\r\n\r\n self._is_finished = True","def Finish(self):\n pass","def finish(self) -> None:","def finish(self) -> None:","def finished(self):\n\t\telog(\"finished\")","def complete(self):\n pass","def mapper_updated(self):\n self.invalidate()\n return","def finish(self):","def finish(self):","def finalize(self):\n logger.debug(\"Generation Complete\")\n self.events.generation_complete()","def _finish(self):\n self.stage = {}","def finalize(self):\n return","def on_finish(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\n pass","def finalize(self):\r\n pass","def close(self):\n for m in self._mappers:\n m.close()\n self._mappers = []\n self._offsets = []\n self._sizes = []\n self._handler = None","def done(self):\n raise NotImplementedError()","def finish():\n pass","def onDone(self):\n pass","def finalize(self) -> None:\n pass","def finish(self):\n with self._lock: # just to be tidy; lock not really needed to set a boolean\n self._done = True","def __finish(self):\n self.finished.emit()","def done(self):","def done(self):","def finalize(self):","def finalize(self):","def finish():","def finish():","def finish():","def finish():","def _on_finalize(self):\n pass","def finished(self, result):\n raise NotImplementedError(\"Subclasses mut override finished()\")","def finalise(self):","def finish(self) -> None:\n self.__exit__(None, None, None)","def finalize(self) -> None:\n if self._finalized:\n raise ValueError(\"Molecule already finalized.\")\n self._apply_patches()\n self._build_atoms()\n self._remove_dangling_bonds()\n self._structure = self.to_structure()\n self._fill_impropers_cross_maps()\n self._finalized = True","def onFinish(self):\n self.finalizeStats()","def end_serialization(self):\n pass","def done(self):\n self._flush()","def finish_command(self):\n\n # remap source\n orig_nodes = self.data.keys()\n for orig_node in orig_nodes:\n new_node = self.mapping[orig_node] or orig_node\n\n if new_node != orig_node:\n self.data[new_node] = self.data[orig_node]\n del self.data[orig_node]\n\n set_data(self.data,\n create_attrs=self.create_attrs,\n set_values=self.set_values,\n set_values_on_all=self.set_values_on_all)","def map(self):\n map_rupture(self)","def at_idmapper_flush(self):\n return True","def after_map(self, map):\n return map","def after_map(self, map):\n return map","def post_instrument_class(self, mapper):\n pass","def finalize(self):\n if self.finalize_callback:\n self.finalize_callback(self)\n self.finalize_callback_called = True","def finalize(self): # pylint: disable=no-self-use\n return","def _do_mapping(self):\n pass","def finalize_task(self):\n pass","def _end(self):\n\n self.logger.msg1(\"Done\")","def done(self) -> None:\n\n self.event_.set()\n for cb in self.callbacks:\n cb()","def finalize(self):\n self.__finalTime = self.__last_time\n if (self.__resultsPlace is not None):\n self.__trajRecord.close()\n if self.__spatially_resolved:\n # Normalize the spatial data with time.\n self.__spatial_data /= self.__last_time","def finalize(self):\n self.stop()","def complete(self):\n self.chunk_percentage = [1.0] * self.total_steps\n self.progress_updated.emit(self.percentage)\n self.initialized = False","def Finish(self):\n\t\n self.queue.join()","def on_finish(self):\n return self._on_finish","def end(self):\n self.flush()\n\n # Free some memory and disk space\n self._plugins_dict = {}\n self._options_dict = {}\n self._scan_targets = None\n self._errors.cleanup()\n self._jinja2_env = None","def finish(self, result: Dict):","def task_done(self) -> None:\n pass","def end(self):\n self._log.debug('doing ..')\n super().end()\n\n self._log.debug('done')","def finish(self):\r\n self.start_finish()\r\n self.wait_finish()","def afterWork(self):\n pass","def jobComplete(self):\n self._Finished = True\n return","def _onEnd(self, name, completed):\n logging.debug(\"onEnd...\")","def end(self):\n pass","def end(self):\n pass","def end(self):\n pass","def finished(self):\n return False","def finish(self):\n self.connection.reset_arguments()\n self.connection.write_ok()","def _finished(self):\n try:\n self._close()\n except Exception, e:\n log.warn(\"Failed to close device %s: error %s\" %\n (self._devId, str(e)))","def finalize(self):\n routes = self.routes.copy()\n for child in self._children:\n routes.extend(list(child.tree_routes))\n\n # Make a new Map() out of all of the routes.\n rule_map = Map([route.create_rule() for route in routes])\n self._route_map = rule_map\n\n self.finalized = True","def finish(self):\n self.finished = self.finished + 1\n if self._finishedDeferreds is not None:\n observers = self._finishedDeferreds\n self._finishedDeferreds = None\n for obs in observers:\n obs.callback(None)","def finalize(self):\r\n\r\n self.find_parents()\r\n self.order_vertices()\r\n self.set_rotation_matrices()","def _process_finished(self, process):\n self._state = JobState.FINISHED","def done(self):\n self.__queue.task_done()","def end(self):\n self._log.debug('doing ..')\n super().end()\n\n self._servo.end()\n self._mtr.end()\n self._log.debug('done')","def finish_parse(self) -> None:\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def post_process(self):\n pass","def end(self):\n ...","def finalize(self):\n print('Cleaning up...')","def done(self):\n ## All done with the request object\n self.closed = True\n self.d.callback('')","def on_finish(self):","def sync_end(self):","def handle_finish(self, dataset):\n\n logger.info('End of scheduling block message received.')","def finish(self):\n self._release_locks()\n self._fail_out()"],"string":"[\n \"def finished(self):\\n pass\",\n \"def _finished(self) -> None:\",\n \"def finish(self):\\n pass\",\n \"def finish(self):\\n pass\",\n \"def finished(self):\\n raise NotImplementedError()\",\n \"def finished(self):\\r\\n raise NotImplementedError\",\n \"def finished(self):\",\n \"def finish(self):\\r\\n\\r\\n self._is_finished = True\",\n \"def Finish(self):\\n pass\",\n \"def finish(self) -> None:\",\n \"def finish(self) -> None:\",\n \"def finished(self):\\n\\t\\telog(\\\"finished\\\")\",\n \"def complete(self):\\n pass\",\n \"def mapper_updated(self):\\n self.invalidate()\\n return\",\n \"def finish(self):\",\n \"def finish(self):\",\n \"def finalize(self):\\n logger.debug(\\\"Generation Complete\\\")\\n self.events.generation_complete()\",\n \"def _finish(self):\\n self.stage = {}\",\n \"def finalize(self):\\n return\",\n \"def on_finish(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\n pass\",\n \"def finalize(self):\\r\\n pass\",\n \"def close(self):\\n for m in self._mappers:\\n m.close()\\n self._mappers = []\\n self._offsets = []\\n self._sizes = []\\n self._handler = None\",\n \"def done(self):\\n raise NotImplementedError()\",\n \"def finish():\\n pass\",\n \"def onDone(self):\\n pass\",\n \"def finalize(self) -> None:\\n pass\",\n \"def finish(self):\\n with self._lock: # just to be tidy; lock not really needed to set a boolean\\n self._done = True\",\n \"def __finish(self):\\n self.finished.emit()\",\n \"def done(self):\",\n \"def done(self):\",\n \"def finalize(self):\",\n \"def finalize(self):\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def finish():\",\n \"def _on_finalize(self):\\n pass\",\n \"def finished(self, result):\\n raise NotImplementedError(\\\"Subclasses mut override finished()\\\")\",\n \"def finalise(self):\",\n \"def finish(self) -> None:\\n self.__exit__(None, None, None)\",\n \"def finalize(self) -> None:\\n if self._finalized:\\n raise ValueError(\\\"Molecule already finalized.\\\")\\n self._apply_patches()\\n self._build_atoms()\\n self._remove_dangling_bonds()\\n self._structure = self.to_structure()\\n self._fill_impropers_cross_maps()\\n self._finalized = True\",\n \"def onFinish(self):\\n self.finalizeStats()\",\n \"def end_serialization(self):\\n pass\",\n \"def done(self):\\n self._flush()\",\n \"def finish_command(self):\\n\\n # remap source\\n orig_nodes = self.data.keys()\\n for orig_node in orig_nodes:\\n new_node = self.mapping[orig_node] or orig_node\\n\\n if new_node != orig_node:\\n self.data[new_node] = self.data[orig_node]\\n del self.data[orig_node]\\n\\n set_data(self.data,\\n create_attrs=self.create_attrs,\\n set_values=self.set_values,\\n set_values_on_all=self.set_values_on_all)\",\n \"def map(self):\\n map_rupture(self)\",\n \"def at_idmapper_flush(self):\\n return True\",\n \"def after_map(self, map):\\n return map\",\n \"def after_map(self, map):\\n return map\",\n \"def post_instrument_class(self, mapper):\\n pass\",\n \"def finalize(self):\\n if self.finalize_callback:\\n self.finalize_callback(self)\\n self.finalize_callback_called = True\",\n \"def finalize(self): # pylint: disable=no-self-use\\n return\",\n \"def _do_mapping(self):\\n pass\",\n \"def finalize_task(self):\\n pass\",\n \"def _end(self):\\n\\n self.logger.msg1(\\\"Done\\\")\",\n \"def done(self) -> None:\\n\\n self.event_.set()\\n for cb in self.callbacks:\\n cb()\",\n \"def finalize(self):\\n self.__finalTime = self.__last_time\\n if (self.__resultsPlace is not None):\\n self.__trajRecord.close()\\n if self.__spatially_resolved:\\n # Normalize the spatial data with time.\\n self.__spatial_data /= self.__last_time\",\n \"def finalize(self):\\n self.stop()\",\n \"def complete(self):\\n self.chunk_percentage = [1.0] * self.total_steps\\n self.progress_updated.emit(self.percentage)\\n self.initialized = False\",\n \"def Finish(self):\\n\\t\\n self.queue.join()\",\n \"def on_finish(self):\\n return self._on_finish\",\n \"def end(self):\\n self.flush()\\n\\n # Free some memory and disk space\\n self._plugins_dict = {}\\n self._options_dict = {}\\n self._scan_targets = None\\n self._errors.cleanup()\\n self._jinja2_env = None\",\n \"def finish(self, result: Dict):\",\n \"def task_done(self) -> None:\\n pass\",\n \"def end(self):\\n self._log.debug('doing ..')\\n super().end()\\n\\n self._log.debug('done')\",\n \"def finish(self):\\r\\n self.start_finish()\\r\\n self.wait_finish()\",\n \"def afterWork(self):\\n pass\",\n \"def jobComplete(self):\\n self._Finished = True\\n return\",\n \"def _onEnd(self, name, completed):\\n logging.debug(\\\"onEnd...\\\")\",\n \"def end(self):\\n pass\",\n \"def end(self):\\n pass\",\n \"def end(self):\\n pass\",\n \"def finished(self):\\n return False\",\n \"def finish(self):\\n self.connection.reset_arguments()\\n self.connection.write_ok()\",\n \"def _finished(self):\\n try:\\n self._close()\\n except Exception, e:\\n log.warn(\\\"Failed to close device %s: error %s\\\" %\\n (self._devId, str(e)))\",\n \"def finalize(self):\\n routes = self.routes.copy()\\n for child in self._children:\\n routes.extend(list(child.tree_routes))\\n\\n # Make a new Map() out of all of the routes.\\n rule_map = Map([route.create_rule() for route in routes])\\n self._route_map = rule_map\\n\\n self.finalized = True\",\n \"def finish(self):\\n self.finished = self.finished + 1\\n if self._finishedDeferreds is not None:\\n observers = self._finishedDeferreds\\n self._finishedDeferreds = None\\n for obs in observers:\\n obs.callback(None)\",\n \"def finalize(self):\\r\\n\\r\\n self.find_parents()\\r\\n self.order_vertices()\\r\\n self.set_rotation_matrices()\",\n \"def _process_finished(self, process):\\n self._state = JobState.FINISHED\",\n \"def done(self):\\n self.__queue.task_done()\",\n \"def end(self):\\n self._log.debug('doing ..')\\n super().end()\\n\\n self._servo.end()\\n self._mtr.end()\\n self._log.debug('done')\",\n \"def finish_parse(self) -> None:\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def post_process(self):\\n pass\",\n \"def end(self):\\n ...\",\n \"def finalize(self):\\n print('Cleaning up...')\",\n \"def done(self):\\n ## All done with the request object\\n self.closed = True\\n self.d.callback('')\",\n \"def on_finish(self):\",\n \"def sync_end(self):\",\n \"def handle_finish(self, dataset):\\n\\n logger.info('End of scheduling block message received.')\",\n \"def finish(self):\\n self._release_locks()\\n self._fail_out()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6983338","0.67524016","0.6732718","0.6732718","0.6725664","0.6718488","0.6698824","0.6674772","0.6650086","0.65816665","0.65816665","0.6573483","0.6461058","0.6453406","0.6439004","0.6439004","0.6388175","0.63703626","0.6352022","0.63432056","0.6340175","0.6340175","0.6340175","0.6340175","0.6340175","0.6340175","0.6324267","0.6305488","0.62836945","0.6276607","0.6231028","0.622867","0.6202939","0.6194986","0.6192385","0.6192385","0.61882204","0.61882204","0.6176969","0.6176969","0.6176969","0.6176969","0.6110085","0.61095613","0.60949296","0.60926247","0.6081269","0.6075767","0.6075675","0.60631084","0.6054816","0.6037251","0.60199827","0.60063803","0.60063803","0.60041904","0.5997011","0.597849","0.5949191","0.5948211","0.5936867","0.59153277","0.5913426","0.59019214","0.5898521","0.58934677","0.58850086","0.5881828","0.58751816","0.5874363","0.58614486","0.584799","0.5847789","0.583813","0.5837064","0.5835825","0.5835825","0.5835825","0.5829156","0.58263075","0.58146274","0.5811223","0.5804256","0.5793139","0.5782239","0.57797116","0.5778263","0.5777974","0.5775753","0.5775753","0.5775753","0.5775753","0.5775753","0.5766257","0.5745713","0.5745618","0.57434464","0.5727116","0.5718262","0.57137716"],"string":"[\n \"0.6983338\",\n \"0.67524016\",\n \"0.6732718\",\n \"0.6732718\",\n \"0.6725664\",\n \"0.6718488\",\n \"0.6698824\",\n \"0.6674772\",\n \"0.6650086\",\n \"0.65816665\",\n \"0.65816665\",\n \"0.6573483\",\n \"0.6461058\",\n \"0.6453406\",\n \"0.6439004\",\n \"0.6439004\",\n \"0.6388175\",\n \"0.63703626\",\n \"0.6352022\",\n \"0.63432056\",\n \"0.6340175\",\n \"0.6340175\",\n \"0.6340175\",\n \"0.6340175\",\n \"0.6340175\",\n \"0.6340175\",\n \"0.6324267\",\n \"0.6305488\",\n \"0.62836945\",\n \"0.6276607\",\n \"0.6231028\",\n \"0.622867\",\n \"0.6202939\",\n \"0.6194986\",\n \"0.6192385\",\n \"0.6192385\",\n \"0.61882204\",\n \"0.61882204\",\n \"0.6176969\",\n \"0.6176969\",\n \"0.6176969\",\n \"0.6176969\",\n \"0.6110085\",\n \"0.61095613\",\n \"0.60949296\",\n \"0.60926247\",\n \"0.6081269\",\n \"0.6075767\",\n \"0.6075675\",\n \"0.60631084\",\n \"0.6054816\",\n \"0.6037251\",\n \"0.60199827\",\n \"0.60063803\",\n \"0.60063803\",\n \"0.60041904\",\n \"0.5997011\",\n \"0.597849\",\n \"0.5949191\",\n \"0.5948211\",\n \"0.5936867\",\n \"0.59153277\",\n \"0.5913426\",\n \"0.59019214\",\n \"0.5898521\",\n \"0.58934677\",\n \"0.58850086\",\n \"0.5881828\",\n \"0.58751816\",\n \"0.5874363\",\n \"0.58614486\",\n \"0.584799\",\n \"0.5847789\",\n \"0.583813\",\n \"0.5837064\",\n \"0.5835825\",\n \"0.5835825\",\n \"0.5835825\",\n \"0.5829156\",\n \"0.58263075\",\n \"0.58146274\",\n \"0.5811223\",\n \"0.5804256\",\n \"0.5793139\",\n \"0.5782239\",\n \"0.57797116\",\n \"0.5778263\",\n \"0.5777974\",\n \"0.5775753\",\n \"0.5775753\",\n \"0.5775753\",\n \"0.5775753\",\n \"0.5775753\",\n \"0.5766257\",\n \"0.5745713\",\n \"0.5745618\",\n \"0.57434464\",\n \"0.5727116\",\n \"0.5718262\",\n \"0.57137716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8608334"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24399,"cells":{"query":{"kind":"string","value":"Returns a query over the specified kind, with any appropriate filters applied."},"document":{"kind":"string","value":"def get_query(self):\n q = db.Query(self.KIND,keys_only=self.KEYS_ONLY)\n for prop, value in self.FILTERS:\n q.filter(\"%s =\" % prop, value)\n if self.ancestor:\n q.ancestor(self.ancestor)\n q.order(self.ORDER_BY)\n return q"},"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 make_query(kind):\n days = 4\n now = datetime.datetime.now()\n earlier = now - datetime.timedelta(days=days)\n\n query = query_pb2.Query()\n query.kind.add().name = kind\n\n datastore_helper.set_property_filter(query.filter, 'created_at',\n PropertyFilter.GREATER_THAN,\n earlier)\n\n return query","def _get_query_spec(cls, params):\n entity_kind = params[cls.ENTITY_KIND_PARAM]\n filters = params.get(cls.FILTERS_PARAM)\n app = params.get(cls._APP_PARAM)\n ns = params.get(cls.NAMESPACE_PARAM)\n\n return model.QuerySpec(\n entity_kind=cls._get_raw_entity_kind(entity_kind),\n keys_only=bool(params.get(cls.KEYS_ONLY_PARAM, False)),\n filters=filters,\n batch_size=int(params.get(cls.BATCH_SIZE_PARAM, cls._BATCH_SIZE)),\n model_class_path=entity_kind,\n app=app,\n ns=ns)","def search_filter(query_params, query):\n if query_params.get('type') is not None:\n query = query.filter(search.c.kind == query_params.get('type'))\n return query","def query(self, query, request_type=None):\n\n #encode to UTF-8\n try: query = query.encode(\"utf-8\")\n except: query = query.decode('raw_unicode_escape').encode(\"utf-8\")\n\n lowercase_query = query.lower()\n if lowercase_query.startswith(\"select\") or \\\n lowercase_query.startswith(\"describe\") or \\\n lowercase_query.startswith(\"show\") or \\\n request_type==\"GET\":\n\n return self._get(urllib.urlencode({'sql': query}))\n\n else:\n return self._post(urllib.urlencode({'sql': query}))","def build_query(self):\r\n\r\n # this filter is required\r\n query = Metric.query.filter(Metric.metric_type == self.metric_type)\r\n\r\n # get query parameters (parameters which are not here are ignored)\r\n is_active = request.args.get('is_active')\r\n frequency = request.args.get('frequency')\r\n threshold_type = request.args.get('threshold_type')\r\n sort = request.args.get('sort')\r\n\r\n # process each parameter, and if valid add it as a query condition\r\n if is_active is not None:\r\n is_active = is_active.lower() == 'true'\r\n query = Metric.query.filter_by(is_active=is_active)\r\n if frequency is not None:\r\n try:\r\n frequency = Frequency.from_name(frequency)\r\n except ValueError as e:\r\n msg = f\"Invalid 'frequency': {frequency}. Use one of {Frequency.values()}\"\r\n abort(400, message=msg)\r\n query = query.filter_by(frequency=frequency)\r\n if threshold_type is not None:\r\n try:\r\n threshold_type = ThresholdType.from_name(threshold_type)\r\n except ValueError as e:\r\n msg = f\"Invalid 'threshold_type': {threshold_type}. Use one of \" \\\r\n f\"{ThresholdType.values()}\"\r\n abort(400, message=msg)\r\n query = query.filter_by(threshold_type=threshold_type)\r\n if sort is not None and sort.lstrip(\"-\") == 'metric_id':\r\n query = query.order_by(Metric.metric_id.desc())\r\n else:\r\n query = query.order_by(Metric.metric_id)\r\n\r\n return query","def types_query(owner_name):\n query = Products.query.with_entities(Products.type_name.label('Type'))\\\n .filter_by(owner_name=owner_name)\\\n .distinct()\n return query","def showGqlQuery(query):\n proto = query._proto_query\n kind = query._model_class.kind()\n filters = proto.filters()\n boundfilters = proto._GQL__bound_filters\n orderings = proto.orderings()\n hint = proto.hint()\n limit = proto.limit()\n offset = proto._GQL__offset\n\n select = \"SELECT * FROM %s\" % kind\n where = []\n order = []\n\n for k in sorted(filters):\n for clause in filters[k]:\n name, op = clause\n if name==-1: name = 'ANCESTOR'\n where.append(\"%s %s :%s\" % (name, op.upper(), k))\n\n for k in sorted(boundfilters):\n if isinstance(k, tuple):\n op = ' '.join(k)\n else:\n op = k\n where.append(\"%s %r\" % (op, boundfilters[k]))\n\n for p, o in orderings:\n order.append(\"%s %s\" % (p, 'DESC' if o==datastore.Query.DESCENDING else 'ASC'))\n\n gql = select\n if where:\n gql += ' WHERE '+' AND '.join(where)\n if order:\n gql += ' ORDER BY ' + ', '.join(order)\n if limit != -1:\n if offset != -1:\n gql += ' LIMIT %s,%s' % (offset,limit)\n else:\n gql += ' LIMIT %s' % limit\n elif offset != -1:\n gql += ' OFFSET %s' % offset\n return gql","def get_query(cls, model, info: 'ResolveInfo', sort=None, **args):\n query = super().get_query(model, info, sort, **args)\n\n request_filters = args.get(cls.filter_arg)\n if request_filters:\n filter_set = cls.get_filter_set(info)\n query = filter_set.filter(info, query, request_filters)\n\n return query","def query(cls, **kwds):\n #NOTE: Only static properties can be indexed by homer, \n # so we don't worry about querying for dynamic properties\n query = \"\"\n started = False\n for name in kwds:\n if not started:\n pattern = \"%s=:%s\" % (name, name)\n query += pattern\n started = True\n else:\n pattern = \" AND %s=:%s\" % (name, name)\n query += pattern\n\n q = 'SELECT * FROM %s WHERE %s' % (cls.kind(), query)\n query = CqlQuery(cls, q, **kwds)\n query.convert = True\n return query","def query(self, name, python_type, optional=False, **kwargs):\n return self.simple_param('query', name, python_type, optional=optional,\n **kwargs)","def queryComponent(type=None, filter=None, all=0):","def get_sort_query(self, kind, order, is_number):\n pass","def _build_query(self, types=(), paths=(), depth=None, query=None, filterPermissions=True, globFilters=None):\n available_indexes = self.model_catalog.searcher.get_indexes()\n not_indexed_user_filters = {} # Filters that use not indexed fields\n\n user_filters_query = None\n types_query = None\n paths_query = None\n permissions_query = None\n\n partial_queries = []\n\n if query:\n \"\"\"\n # if query is a dict, we convert it to AdvancedQuery\n # @TODO We should make the default query something other than AdvancedQuery\n subqueries = []\n if isinstance(query, dict):\n for attr, value in query.iteritems():\n if isinstance(value, str) and '*' in value:\n subqueries.append(MatchGlob(attr, value))\n else:\n subqueries.append(Eq(attr, value))\n query = And(*subqueries)\n partial_queries.append(query)\n \"\"\"\n partial_queries.append(self._parse_user_query(query))\n\n # Build query from filters passed by user\n if globFilters:\n for key, value in globFilters.iteritems():\n if key in available_indexes:\n if user_filters_query:\n user_filters_query = And(query, MatchRegexp(key, '*%s*' % value))\n else:\n user_filters_query = MatchRegexp(key, '*%s*' % value)\n else:\n not_indexed_user_filters[key] = value\n\n if user_filters_query:\n partial_queries.append(user_filters_query)\n\n # Build the objectImplements query\n if not isinstance(types, (tuple, list)):\n types = (types,)\n types_query_list = [ Eq('objectImplements', dottedname(t)) for t in types ]\n if types_query_list:\n if len(types_query_list) > 1:\n types_query = Or(*types_query_list)\n else:\n types_query = types_query_list[0]\n\n partial_queries.append(types_query)\n\n # Build query for paths\n if paths is not False: # When paths is False we dont add any path condition\n if not paths:\n paths = ('/'.join(self.context.getPhysicalPath()) + '*', )\n elif isinstance(paths, basestring):\n paths = (paths,)\n\n \"\"\" OLD CODE. Why this instead of In? What do we need depth for?\n q = {'query':paths}\n if depth is not None:\n q['depth'] = depth\n paths_query = Generic('path', q)\n \"\"\"\n paths_query = In('path', paths)\n partial_queries.append(paths_query)\n\n # filter based on permissions\n if filterPermissions and allowedRolesAndGroups(self.context):\n permissions_query = In('allowedRolesAndUsers', allowedRolesAndGroups(self.context))\n partial_queries.append(permissions_query)\n\n # Put together all queries\n search_query = And(*partial_queries)\n return (search_query, not_indexed_user_filters)","def query(self):\n q = dict(self._query)\n fworker_check = [{\"spec._fworker\": {\"$exists\": False}}, {\"spec._fworker\": None}, {\"spec._fworker\": self.name}]\n if \"$or\" in q:\n q[\"$and\"] = q.get(\"$and\", [])\n q[\"$and\"].extend([{\"$or\": q.pop(\"$or\")}, {\"$or\": fworker_check}])\n else:\n q[\"$or\"] = fworker_check\n if self.category and isinstance(self.category, str):\n if self.category == \"__none__\":\n q[\"spec._category\"] = {\"$exists\": False}\n else:\n q[\"spec._category\"] = self.category\n elif self.category: # category is list of str\n q[\"spec._category\"] = {\"$in\": self.category}\n\n return q","def _query(self, model_class, **kwargs):\r\n query = model_class.objects\r\n if self.select_for_update:\r\n query = query.select_for_update()\r\n query = query.filter(**kwargs)\r\n return query","def execute_query(self, *, scope: Scope, params: QueryParams) -> QueryResults:","def query():\n data = {'version': config.API_VERSION}\n args = flask.request.args\n limit = args.get('limit', config.DEFAULT_QUERY_LIMIT)\n offset = args.get('offset', 0)\n q = args.get('q', '')\n table = args.get('table')\n filter_params = {'filter': args.get('filter')}\n try:\n total, result = db_client.search(table, q,\n limit, offset,\n **filter_params)\n data['result_count'] = total\n data['results'] = result\n except db.InvalidTable:\n data['error'] = 'Invalid table:'+str(table)\n\n return flask.jsonify(data)","def query(env):\n if app.config['ENABLE_QUERY']:\n envs = environments()\n check_env(env, envs)\n\n form = QueryForm(meta={\n 'csrf_secret': app.config['SECRET_KEY'],\n 'csrf_context': session})\n if form.validate_on_submit():\n if form.endpoints.data == 'pql':\n query = form.query.data\n elif form.query.data[0] == '[':\n query = form.query.data\n else:\n query = '[{0}]'.format(form.query.data)\n result = get_or_abort(\n puppetdb._query,\n form.endpoints.data,\n query=query)\n return render_template('query.html',\n form=form,\n result=result,\n envs=envs,\n current_env=env)\n return render_template('query.html',\n form=form,\n envs=envs,\n current_env=env)\n else:\n log.warn('Access to query interface disabled by administrator..')\n abort(403)","def gql(cls, clause, *args, **kwds):\n query_string = 'SELECT * FROM %s %s' % (cls.kind(), clause)\n query = _query_cache.get(query_string)\n if query is None:\n _query_cache[query_string] = query = db.GqlQuery(query_string)\n query.bind(*args, **kwds)\n return query","def by_type(cls, typ='creditcard'):\n return Filter('type', values=(typ,), operator=Filter.OPERATOR['EQUAL'])","def dynamic_query(model, fields, types, values, operator):\n\t\n\tqueries = []\n\tfor (f, t, v) in zip(fields, types, values):\n\n\t\tif v != None:\n\t\t\tif t == 'in':\n\t\t\t\tkwargs = {str('%s__%s' % (f,t)) : v}\n\t\t\telse:\n\t\t\t\tkwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\n\t\t\tqueries.append(Q(**kwargs))\n\t\n\t# Make sure we have a list of filters\n\tif len(queries) > 0:\n\t\tq = Q()\n\t\t# AND/OR awareness\n\t\tfor query in queries:\n\t\t\tif operator == \"and\":\n\t\t\t\tq = q & query\n\t\t\telif operator == \"or\":\n\t\t\t\tq = q | query\n\t\t\telse:\n\t\t\t\tq = None\n\t\tif q:\n\t\t\t# We have a Q object, return the QuerySet\n\t\t\treturn model.objects.filter(q)\n\telse:\n\t\t# Return an empty result\n\t\treturn {}","def _make_query(self):\r\n raise NotImplementedError()","def create_filter_query(self, collection_name: str, field: str, filter_type: str, filter_values: Union[List[str], str]=None):\n if filter_type == 'contains':\n # return [{'field' : field, 'filter_type' : 'contains', \"condition\":\"==\", \"condition_value\": filter_values}]\n return [{'field': field, 'filter_type': 'regexp', 'condition': '==', 'condition_value': '.*' + str(filter_values) + '.*'}]\n if filter_type == 'exact_match':\n return [{'field' : field, 'filter_type' : 'exact_match', \"condition\":\"==\", \"condition_value\": filter_values}]\n if filter_type == 'categories':\n return [{'field' : field, 'filter_type' : 'categories', \"condition\":\"==\", \"condition_value\": filter_values}]\n if filter_type == 'exists':\n if filter_values is None or filter_values == '==':\n return [{'field' : field, 'filter_type' : 'exists', \"condition\":\"==\", \"condition_value\":\" \"}]\n elif filter_values == '!=':\n return [{'field' : field, 'filter_type' : 'exists', \"condition\":\"!=\", \"condition_value\":\" \"}]\n if filter_type == '<=' or filter_type == '>=' or filter_type == '>' or filter_type == '<' or filter_type == '==':\n if self.collection_schema(collection_name)[field] == 'date':\n return [{'field' : field, 'filter_type' : 'date', \"condition\":filter_type, \"condition_value\": filter_values}]\n elif self.collection_schema(collection_name)[field] == 'numeric':\n return [{'field' : field, 'filter_type' : 'numeric', \"condition\":filter_type, \"condition_value\":filter_values}]\n else:\n raise ValueError(f\"{filter_type} has not been defined. Please choose one of contains/exact_match/exists/categories/>=/<=/>/<.\")","def query(query, ts, **kwargs):\n queryobj = _parse_query(query)\n\n if queryobj['querytype'] in ('select', 'retrieve'):\n return _select(\n queryobj['projection'],\n queryobj['tables'],\n queryobj['where'],\n ts,\n mode=kwargs.get('mode', 'list'),\n cast=kwargs.get('cast', True))\n else:\n # not really a syntax error; replace with TSQLError or something\n # when the proper exception class exists\n raise TSQLSyntaxError(queryobj['querytype'] +\n ' queries are not supported')","def get_query():\n return CiscoVlanIftableRelationshipQuery","def get_query(self):\n return self.query_class(self)","def model_query(context, *args, **kwargs):\n session = kwargs.get('session') or context.session\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\n project_only = kwargs.get('project_only')\n\n query = session.query(*args)\n\n if read_deleted == 'no':\n query = query.filter_by(deleted=False)\n elif read_deleted == 'yes':\n pass # omit the filter to include deleted and active\n elif read_deleted == 'only':\n query = query.filter_by(deleted=True)\n elif read_deleted == 'int_no':\n query = query.filter_by(deleted=0)\n else:\n raise Exception(\n _(\"Unrecognized read_deleted value '%s'\") % read_deleted)\n\n if project_only and _is_user_context(context):\n query = query.filter_by(project_id=context.project_id)\n\n return query","def model_query(context, *args, **kwargs):\n session = kwargs.get('session') or context.session\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\n project_only = kwargs.get('project_only')\n\n query = session.query(*args)\n\n if read_deleted == 'no':\n query = query.filter_by(deleted=False)\n elif read_deleted == 'yes':\n pass # omit the filter to include deleted and active\n elif read_deleted == 'only':\n query = query.filter_by(deleted=True)\n elif read_deleted == 'int_no':\n query = query.filter_by(deleted=0)\n else:\n raise Exception(\n _(\"Unrecognized read_deleted value '%s'\") % read_deleted)\n\n if project_only and _is_user_context(context):\n query = query.filter_by(project_id=context.project_id)\n\n return query","def query(cls):\n query_class = cls.query_class\n return query_class(orm_class=cls)","def make_query(self):","def query(self, q, **kwargs):\n return self._client.query(self._db_name, q, **kwargs)","def Query(self, what, fields, qfilter=None, reason=None):\n query = []\n _AppendReason(query, reason)\n\n body = {\n \"fields\": fields,\n }\n\n _SetItemIf(body, qfilter is not None, \"qfilter\", qfilter)\n # TODO: remove \"filter\" after 2.7\n _SetItemIf(body, qfilter is not None, \"filter\", qfilter)\n\n return self._SendRequest(HTTP_PUT,\n (\"/%s/query/%s\" %\n (GANETI_RAPI_VERSION, what)), query, body)","def model_query(context, *args, **kwargs):\n session = kwargs.get('session') or get_session()\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\n project_only = kwargs.get('project_only')\n\n query = session.query(*args)\n\n if read_deleted == 'no':\n query = query.filter_by(deleted=False)\n elif read_deleted == 'yes':\n pass # omit the filter to include deleted and active\n elif read_deleted == 'only':\n query = query.filter_by(deleted=True)\n else:\n raise Exception(\n _(\"Unrecognized read_deleted value '%s'\") % read_deleted)\n\n if project_only and is_user_context(context):\n query = query.filter_by(project_id=context.project_id)\n\n return query","def model_query(context, *args, **kwargs):\n session = kwargs.get('session') or get_session()\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\n project_only = kwargs.get('project_only')\n\n query = session.query(*args)\n\n if read_deleted == 'no':\n query = query.filter_by(deleted=False)\n elif read_deleted == 'yes':\n pass # omit the filter to include deleted and active\n elif read_deleted == 'only':\n query = query.filter_by(deleted=True)\n else:\n raise Exception(\n _(\"Unrecognized read_deleted value '%s'\") % read_deleted)\n\n if project_only and is_user_context(context):\n query = query.filter_by(project_id=context.project_id)\n\n return query","def gws_q(self, query, attribute, data):\n \n gws_q = query.format(attribute, data) #attribute = SQL table\n \n query_df = db.query(gws_q) \n return query_df","def query(cls, *attrs):\n if len(attrs) == 0:\n attrs = [cls]\n return _s().query(*attrs)","def query(resource: T) -> Union[Iterable[T], Query[T]]:\n if not db:\n status()\n return db.query(resource)","def get_query_from_driver(driver, wrapper=None):\n if wrapper:\n return driver.query.from_object(\n wrapper,\n ).first().query\n\n return driver.query","def _get_query(self):\n\n endpoint = ENDPOINTS[self.sync_data.endpoint_index]\n marker = self.sync_data.markers.get(self.sync_data.endpoint_index, START_OF_TIME)\n\n query_string = \"select \" + \",\".join(ENDPOINT_QUERY_FIELDS[endpoint])\n\n # ZOQL does not support the `order by` sorting\n query_string = query_string + \" from {} where UpdatedDate > '{}'\".format(\n endpoint,\n marker\n )\n\n return query_string","def query(self, klass):\n return self.getSession().query(klass)","def query(q,epr,f='application/sparql-results+json'):\n\n try:\n params = {'query': q}\n params = urllib.urlencode(params)\n opener = urllib2.build_opener(urllib2.HTTPHandler)\n request = urllib2.Request(epr+'?'+params)\n request.add_header('Accept', f)\n request.get_method = lambda: 'GET'\n url = opener.open(request)\n return url.read()\n except Exception, e:\n traceback.print_exc(file=sys.stdout)\n raise e","def get_matching_events(cls, start_date=None, end_date=None, kind=None):\n\n query = cls.query.order_by(cls.date)\n\n if start_date:\n query = query.filter(cls.date >= start_date)\n\n if end_date:\n query = query.filter(cls.date <= end_date)\n\n if kind and kind != 'all':\n query = query.filter(cls.kind == kind)\n\n return query.all()","def find(self, cls, **attr):\n query_str = \"\"\"select from {} where \"\"\".format(cls) + \\\n \" and \".join([\"\"\"{} = {}\"\"\".format(\n key, \"\"\"\\\"{}\\\"\"\"\".format(value) if isinstance(value, str) else value) \\\n for key, value in attr.items() if value is not None])\n q = self.sql_query(query_str)\n return q","def query(self):\n return Query(from_=self)","def qry(cls, entity, order_by_date='-modified', compare_date=None,\n date=None, time_offset=None,\n compare_version=None, version=None,\n **kwargs):\n qry = entity.query(**kwargs)\n if order_by_date == '-modified':\n qry = qry.order(-cls.modified)\n elif order_by_date == 'modified':\n qry = qry.order(cls.modified)\n elif order_by_date == 'created':\n qry = qry.order(cls.created)\n elif order_by_date == '-created':\n qry = qry.order(-cls.created)\n\n if date:\n if isinstance(date, basestring):\n date = datetime.datetime.strptime(date,\"%Y-%m-%d %H:%M:%S\")\n if time_offset:\n date = date + datetime.timedelta(seconds=time_offset)\n if compare_date == '>modified' :\n qry = qry.filter(cls.modified > date)\n elif compare_date == '>=modified' :\n qry = qry.filter(cls.modified >= date)\n elif compare_date == '<modified' :\n qry = qry.filter(cls.modified < date)\n elif compare_date == '<=modified' :\n qry = qry.filter(cls.modified <= date)\n elif compare_date == '>created' :\n qry = qry.filter(cls.created > date)\n elif compare_date == '>=created' :\n qry = qry.filter(cls.created >= date)\n elif compare_date == '<created' :\n qry = qry.filter(cls.created < date)\n elif compare_date == '<=created' :\n qry = qry.filter(cls.created <= date)\n\n if version:\n if compare_version == '>' :\n qry = qry.filter(cls.version > version)\n elif compare_version == '>=' :\n qry = qry.filter(cls.version >= version)\n elif compare_version == '<' :\n qry = qry.filter(cls.version < version)\n elif compare_version == '<=' :\n qry = qry.filter(cls.version <= version)\n elif compare_version == '==' :\n qry = qry.filter(cls.version == version)\n return qry","def build_query(self):\r\n # build query from base class add required field for joining with parent\r\n query = super().build_query()\r\n query = query.filter(Metric.metric_id == QuantModelMetric.metric_id)\r\n\r\n # get the remaining query parameters\r\n asset_class = request.args.get('asset_class')\r\n model_name = request.args.get('model_name')\r\n pricing_library = request.args.get('pricing_library')\r\n\r\n # process each parameter and, if valid, add as a query condition\r\n if asset_class is not None:\r\n query = query.filter(QuantModelMetric.asset_class == asset_class)\r\n if model_name is not None:\r\n query = query.filter(QuantModelMetric.model_name == model_name)\r\n if pricing_library is not None:\r\n query = query.filter(QuantModelMetric.pricing_library == pricing_library)\r\n return query","def expand_type_query(owner_name: str, type_name: []) -> 'session query':\n critical_level = get_critical_level(owner_name, type_name)\n\n ordered = db.session.query(\n func.sum(SpecificOrders.quantity).label('number')\n )\\\n .join(Orders, Orders.order_id == SpecificOrders.order_id)\\\n .filter(\n and_(\n Orders.supplier_name == owner_name,\n SpecificOrders.type_name.in_(type_name)\n )\n\n )\n\n query = select([Products.type_name.label('Type'),\n Products.serial_number.label('Serial number'),\n Products.producent.label('Producent'),\n Products.model.label('Model'),\n Products.product_condition.label('Condition'),\n Products.additonal_info.label('Additional info'),\n Products.appear_in_order.label('Bind to order')])\\\n .where(\n and_(\n Products.owner_name == owner_name,\n Products.type_name.in_(type_name)\n )\n ).order_by(Products.appear_in_order.asc(),Products.serial_number.asc())\n return db.session.query(aliased(query)), ordered, critical_level","def raw_query(\n # TODO: Passing the whole clickhouse query here is needed as long\n # as the execute method depends on it. Otherwise we can make this\n # file rely either entirely on clickhouse query or entirely on\n # the formatter.\n clickhouse_query: Union[Query, CompositeQuery[Table]],\n request_settings: RequestSettings,\n formatted_query: FormattedQuery,\n reader: Reader,\n timer: Timer,\n query_metadata: SnubaQueryMetadata,\n stats: MutableMapping[str, Any],\n trace_id: Optional[str] = None,\n robust: bool = False,\n) -> QueryResult:\n all_confs = state.get_all_configs()\n query_settings: MutableMapping[str, Any] = {\n k.split(\"/\", 1)[1]: v\n for k, v in all_confs.items()\n if k.startswith(\"query_settings/\")\n }\n\n timer.mark(\"get_configs\")\n\n sql = formatted_query.get_sql()\n\n update_with_status = partial(\n update_query_metadata_and_stats,\n clickhouse_query,\n sql,\n timer,\n stats,\n query_metadata,\n query_settings,\n trace_id,\n )\n\n execute_query_strategy = (\n execute_query_with_readthrough_caching\n if state.get_config(\"use_readthrough_query_cache\", 1)\n else execute_query_with_caching\n )\n\n try:\n result = execute_query_strategy(\n clickhouse_query,\n request_settings,\n formatted_query,\n reader,\n timer,\n stats,\n query_settings,\n robust=robust,\n )\n except Exception as cause:\n if isinstance(cause, RateLimitExceeded):\n stats = update_with_status(QueryStatus.RATE_LIMITED)\n else:\n with configure_scope() as scope:\n if isinstance(cause, ClickhouseError):\n scope.fingerprint = [\"{{default}}\", str(cause.code)]\n if scope.span:\n if cause.code == errors.ErrorCodes.TOO_SLOW:\n sentry_sdk.set_tag(\"timeout\", \"predicted\")\n elif cause.code == errors.ErrorCodes.TIMEOUT_EXCEEDED:\n sentry_sdk.set_tag(\"timeout\", \"query_timeout\")\n elif cause.code in (\n errors.ErrorCodes.SOCKET_TIMEOUT,\n errors.ErrorCodes.NETWORK_ERROR,\n ):\n sentry_sdk.set_tag(\"timeout\", \"network\")\n elif isinstance(cause, (TimeoutError, ExecutionTimeoutError)):\n if scope.span:\n sentry_sdk.set_tag(\"timeout\", \"cache_timeout\")\n\n logger.exception(\"Error running query: %s\\n%s\", sql, cause)\n stats = update_with_status(QueryStatus.ERROR)\n raise QueryException(\n {\n \"stats\": stats,\n \"sql\": sql,\n \"experiments\": clickhouse_query.get_experiments(),\n }\n ) from cause\n else:\n stats = update_with_status(QueryStatus.SUCCESS)\n return QueryResult(\n result,\n {\n \"stats\": stats,\n \"sql\": sql,\n \"experiments\": clickhouse_query.get_experiments(),\n },\n )","def get_resource_query(self):\n pass","def get_resource_query(self):\n pass","def __init__(self, kind=None, filters={}, _app=None, keys_only=False,\n compile=True, cursor=None, _namespace=None):\n if kind is not None:\n datastore_types.ValidateString(kind, 'kind',\n datastore_errors.BadArgumentError)\n\n self.__kind = kind\n self.__orderings = []\n self.__filter_order = {}\n self.update(filters)\n\n self.__app = datastore_types.ResolveAppIdNamespace(_app,\n _namespace).to_encoded()\n self.__keys_only = keys_only\n self.__compile = compile\n self.__cursor = cursor","def make_complex_query_set(self):\n\n query = self.request.GET.get(\"q\")\n category_name = self.request.GET.get(\"category_name\")\n o_net_soc_code = self.request.GET.get(\"o_net_soc_code\")\n description = self.request.GET.get(\"description\")\n job_title = self.request.GET.get(\"job_title\")\n level = self.request.GET.get(\"level\", '')\n\n q_object = Q()\n\n if query:\n q_object.add((\n Q(category__category_name__icontains=query) |\n Q(category__o_net_soc_code__icontains=query) |\n Q(category__description__icontains=query) |\n Q(category__job_title__description__icontains=query) |\n Q(category__job_title__title__icontains=query)\n ), Q.OR)\n\n if query.isnumeric():\n q_object.add(\n Q(category__job_title__level__icontains=int(query)), Q.OR)\n\n else:\n if category_name:\n q_object.add(\n Q(category__category_name__icontains=category_name),\n Q.AND)\n\n if o_net_soc_code:\n q_object.add(\n Q(category__o_net_soc_code__icontains=o_net_soc_code),\n Q.AND)\n\n if description:\n q_object.add((\n Q(category__description__icontains=description) |\n Q(\n category__job_title__description__icontains=description)\n ), Q.AND)\n\n if job_title:\n q_object.add(\n Q(category__job_title__title__icontains=job_title),\n Q.AND)\n\n if level:\n if level.isnumeric():\n q_object.add(\n Q(category__job_title__level__icontains=int(level)),\n Q.AND)\n else:\n raise Exception(\n ErrorMessage.WRONG_FIELD_TYPE.value.format(\"level\",\n \"numeric\"))\n\n return q_object","def build_query(self):\r\n query = super().build_query()\r\n query = query.filter(Metric.metric_id == MlModelMetric.metric_id)\r\n algorithm = request.args.get('algorithm')\r\n if algorithm is not None:\r\n query = query.filter(MlModelMetric.algorithm == algorithm)\r\n return query","def query_criteria(self, *, calibration_level=None,\n data_product_type=None, intent=None,\n obs_collection=None, instrument_name=None,\n filters=None, proposal=None, async_job=True, output_file=None,\n output_format=\"votable\", verbose=False,\n get_query=False):\n\n parameters = []\n if calibration_level is not None:\n parameters.append(\"calibration_level={}\".format(\n self.__get_calibration_level(calibration_level)))\n if data_product_type is not None:\n if isinstance(data_product_type, str):\n parameters.append(\"data_product_type LIKE '%{}%'\".format(\n data_product_type))\n else:\n raise ValueError(\"data_product_type must be a string\")\n if intent is not None:\n if isinstance(intent, str):\n parameters.append(\"intent LIKE '%{}%'\".format(intent.lower()))\n else:\n raise ValueError(\"intent must be a string\")\n if proposal is not None:\n if isinstance(proposal, int):\n parameters.append(\"proposal_id = '{}'\".format(proposal))\n else:\n raise ValueError(\"Proposal ID must be an integer\")\n if self.__check_list_strings(obs_collection):\n parameters.append(\"(collection LIKE '%{}%')\".format(\n \"%' OR collection LIKE '%\".join(obs_collection)\n ))\n if self.__check_list_strings(instrument_name):\n parameters.append(\"(instrument_name LIKE '%{}%')\".format(\n \"%' OR instrument_name LIKE '%\".join(instrument_name)\n ))\n if self.__check_list_strings(filters):\n parameters.append(\"(instrument_configuration LIKE '%{}%')\"\n .format(\"%' OR instrument_configuration \"\n \"LIKE '%\".join(filters)))\n query = \"select * from ehst.archive\"\n if parameters:\n query += \" where({})\".format(\" AND \".join(parameters))\n if verbose:\n log.info(query)\n if get_query:\n return query\n table = self.query_tap(query=query, async_job=async_job,\n output_file=output_file,\n output_format=output_format,\n verbose=verbose)\n return table","def _getQuery(self, request):\n q = Conference.query()\n inequality_filter, filters = self._formatFilters(request.filters)\n\n # If exists, sort on inequality filter first\n if not inequality_filter:\n q = q.order(Conference.name)\n else:\n q = q.order(ndb.GenericProperty(inequality_filter))\n q = q.order(Conference.name)\n\n for filtr in filters:\n if filtr[\"field\"] in [\"month\", \"maxAttendees\"]:\n filtr[\"value\"] = int(filtr[\"value\"])\n formatted_query = ndb.query.FilterNode(filtr[\"field\"], filtr[\"operator\"], filtr[\"value\"])\n q = q.filter(formatted_query)\n return q","def q(cls) -> Query:\n if not cls.s:\n raise M2Error('No DB session defined')\n return cls.s.query(cls)","def query(self, **kwargs):","def make_complex_query_set(self):\n\n query = self.request.GET.get(\"q\")\n program_id = self.request.META.get('HTTP_X_SVMS_PROGRAM_ID')\n category = self.request.GET.get(\"category\")\n title = self.request.GET.get(\"title\")\n level = self.request.GET.get(\"level\")\n description = self.request.GET.get(\"description\")\n status = self.request.GET.get(\"status\")\n job_tag = self.request.GET.get(\"job_tag\")\n\n q_object = Q()\n\n if query:\n q_object.add((\n Q(program_id=query) |\n Q(category=query) |\n Q(title__icontains=query) |\n #Q(category__category_name__icontains=query) |\n Q(description__icontains=query) |\n Q(job_tag__tag__in=str(query).split(\",\"))\n ), Q.OR)\n\n if query.isnumeric():\n q_object.add(\n Q(level__icontains=int(query)), Q.OR)\n\n q_object.add(Q(status=strtobool(query)), Q.OR) if query in [\n \"true\", \"True\", \"False\", \"false\"] else None\n\n else:\n if program_id:\n q_object.add(\n Q(program_id=program_id),\n Q.AND)\n\n if category:\n q_object.add(\n Q(category=category),\n Q.AND)\n if title:\n q_object.add(\n Q(title__icontains=title),\n Q.AND)\n\n if description:\n q_object.add(\n Q(description__icontains=description), Q.AND)\n\n if job_tag:\n q_object.add(\n Q(job_tag__tag__in=str(job_tag).split(\",\")),\n Q.AND)\n\n if level:\n if level.isnumeric():\n q_object.add(\n Q(level__icontains=int(level)),\n Q.AND)\n else:\n raise Exception(\n ErrorMessage.WRONG_FIELD_TYPE.value.format(\"level\",\n \"numeric\"))\n\n q_object.add(Q(status=strtobool(status)), Q.AND) if status in [\n \"true\", \"True\", \"False\", \"false\"] else None\n\n return q_object","def query(params: Params):\n return service.query(**params.query, n_neighbors=params.n_neighbors)","def query(self):\n return Query(self)","def query(self, query, initNs=None, initBindings=None, queryGraph=None, **kwargs):\n\n# r_queryType = pattern.search(query).group(\"prefixes\").upper()\n# print(r_queryType)\n uri = self.rest_services[\"repository\"]\n infer = kwargs.get('infer',None)\n #timeout = kwargs.get('timeout',\"0\")\n payload = {\"$\"+k: v.n3() for k,v in initBindings.items()}\n\n payload[\"infer\"] = self.infer if infer is None else infer\n payload[\"infer\"] = str(payload[\"infer\"]).lower()\n #payload[\"$\"+timeout]=0\n payload[\"query\"] = query\n r = requests.post(uri, data=payload,\n stream=True,\n headers= {\"Accept\" : \"application/sparql-results+json,application/trix\",\n 'connection': 'keep-alive',\n 'Accept-Encoding': 'gzip,deflate',\n \"Content-Type\" :\"application/x-www-form-urlencoded\"})\n\n r.raw.decode_content = True\n if r.headers['Content-Type'] == 'application/sparql-results+json;charset=UTF-8':\n return self.__make_result(r)\n elif r.headers['Content-Type'] == 'application/trix;charset=UTF-8':\n return self.__make_trix_generator__(r)\n else:\n raise ValueError(\"Response content type not parsable {r}\".format(r=r.text))","def dynamiQ(fields, types, values, operator='or'):\r\n from django.db.models import Q\r\n\r\n queries = []\r\n q = None\r\n for (f, t, v) in zip(fields, types, values):\r\n # We only want to build a Q with a value\r\n if v != \"\":\r\n kwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\r\n queries.append(Q(**kwargs))\r\n\r\n # Make sure we have a list of filters\r\n if len(queries) > 0:\r\n q = Q()\r\n # AND/OR awareness\r\n for query in queries:\r\n if operator == \"and\":\r\n q = q & query\r\n elif operator == \"or\":\r\n q = q | query\r\n else:\r\n q = None\r\n\r\n return q","def model_query(model, *args, **kwargs):\n with session_for_read() as session:\n query = session.query(model, *args)\n return query","def query(querystring: str,\n db: tsdb.Database,\n **kwargs):\n queryobj = _parse_query(querystring)\n\n if queryobj['type'] in ('select', 'retrieve'):\n return _select(\n queryobj['projection'],\n queryobj['relations'],\n queryobj['condition'],\n db,\n record_class=kwargs.get('record_class', None))\n else:\n # not really a syntax error; replace with TSQLError or something\n # when the proper exception class exists\n raise TSQLSyntaxError(queryobj['type'] + ' queries are not supported',\n text=querystring)","def get_query(params, filters):\n engine, session = connect_to_db(DB_NAME, CORE_DIR)\n\n q = session.query(*params) # kick off the query\n\n classes = []\n for p in params:\n parent_class = p.parent.class_\n classes.append(parent_class) if parent_class not in classes else None # need order, so hack around a set...\n\n\n base = classes.pop(0) # grab first class from list\n linked = [base] # the first class is inherently already in the join-chain\n\n if classes: # any more classes?\n for c in classes:\n relations_for_c = relations.get(c.__name__)\n\n if not relations_for_c:\n msg = f'{c.__name__} does not have any defined relationships.'\n raise NotImplementedError(msg)\n\n relation = relations_for_c.get(base.__name__)\n\n if relation:\n q = q.join(c, relation.key == relation.fkey)\n else:\n msg = f'{c.__name__} is not directly related to {base} in the schema.'\n raise NotImplementedError(msg)\n\n for f in filters:\n q = q.filter(f)\n\n return q.all()[:10]","def query(engine: sa.engine, query_params: Dict[str, Any]) -> sa.engine.ResultProxy:\r\n with engine.connect() as con:\r\n attr_col = [query_params[Toml.ATTR]]\r\n cols = [sa.Column(x) for x in attr_col + query_params[Toml.COLUMNS]]\r\n table = query_params[Toml.TABLE]\r\n s = sa.select(cols)\r\n s.append_from(sa.text(table))\r\n s.append_whereclause(sa.text(query_params[Toml.EXCLUDE_BY] + ' not in :exclude')\r\n .bindparams(sa.bindparam('exclude', expanding=True)))\r\n return con.execute(s, {\r\n 'exclude': query_params[Toml.EXCLUDE]\r\n })","def album_filter(query_params, query):\n table = Album.__table__\n col_name = table.c.release_date\n if query_params.get('start_year') is not None \\\n and query_params.get('end_year') is not None:\n filt_statement = and_(\n col_name >= date(int(query_params.get('start_year')), 1, 1),\n col_name <= date(int(query_params.get('end_year')), 12, 31))\n query = query.filter(filt_statement)\n elif query_params.get('start_year') is not None:\n query = query.filter(\n col_name >= date(int(query_params.get('start_year')), 1, 1))\n elif query_params.get('end_year') is not None:\n query = query.filter(\n col_name <= date(int(query_params.get('end_year')), 12, 31))\n if query_params.get('num_tracks') is not None:\n query = query.filter(\n table.c.num_tracks == int(query_params.get('num_tracks')))\n if query_params.get('label') is not None:\n query = query.filter(table.c.label == str(query_params.get('label')))\n return query","def qry(cls, name=None, username=None, email=None, \\\n active=None, admin=None,\n permissions=None, verified=None,\n location=None, **kwargs):\n #qry = cls.query(**kwargs)\n qry = model.Base.qry(model.User,**kwargs)\n if name:\n qry = qry.filter(cls.name==name)\n if username:\n qry = qry.filter(cls.username==username)\n if email:\n qry = qry.filter(cls.email==email)\n if active:\n qry = qry.filter(cls.active==active)\n if admin:\n qry = qry.filter(cls.admin==admin)\n if permissions:\n qry = qry.filter(cls.permissions==permissions)\n if verified:\n qry = qry.filter(cls.verified==verified)\n if location:\n qry = qry.filter(cls.location==location)\n #else filter for private True and False\n return qry","def knowledge_query():\n params = flask.request.get_json()\n if params is None or 'sql' not in params:\n return flask.jsonify({'error': 'No SQL specified in request'})\n else:\n knowledge_store = KnowledgeStore(settings['FLATMAP_ROOT'], create=False, read_only=True)\n result = knowledge_store.query(params.get('sql'), params.get('params', []))\n knowledge_store.close()\n if 'error' in result:\n app.logger.warning('SQL: {}'.format(result['error']))\n return flask.jsonify(result)","def query(self):\r\n raise NotImplementedError","def filter(self, **kwargs):\n kwargs['query'] += ' FROM {0}'\n return kwargs","def query_graphql(raw_query, endpoint):\n query = \" \".join(shlex.split(raw_query, posix=False))\n r = requests.get(endpoint, params={\"query\": query})\n if r.status_code == 200:\n return r.json()\n elif r.status_code == 400:\n response = r.json()\n assert \"errors\" in response\n raise GraphQLError(\"\".join([e[\"message\"] for e in response[\"errors\"]]))\n else:\n raise requests.exceptions.RequestException(\n f\"HTTP Status: {r.status_code}, Response Body: {r.text}\"\n )","def query(self, **kwargs):\n\n return query.query(self._host, self._session, **kwargs)","def create_query(self, keywords=None, servicetype=None, \n waveband=None, sqlpred=None):\n srch = RegistryQuery(self._baseurl)\n if sqlpred:\n srch.addpredicate(sqlpred)\n if waveband:\n srch.waveband = waveband\n if servicetype:\n srch.servicetype = servicetype\n if keywords:\n srch.addkeywords(keywords)\n return srch","def gen_query(self, criteria, target_id, for_stats=False):\n query = self.db.session.query(models.Url).filter_by(target_id=target_id)\n # Check if criteria is url search\n if criteria.get('search', None):\n if criteria.get('url', None):\n if isinstance(criteria.get('url'), list):\n criteria['url'] = criteria['url'][0]\n query = query.filter(models.Url.url.like('%%%s%%' % criteria['url']))\n else: # If not search\n if criteria.get('url', None):\n if isinstance(criteria.get('url'), str):\n query = query.filter_by(url=criteria['url'])\n if isinstance(criteria.get('url'), list):\n query = query.filter(models.Url.url.in_(criteria['url']))\n # For the following section doesn't matter if filter/search because\n # it doesn't make sense to search in a boolean column :P\n if criteria.get('visited', None):\n if isinstance(criteria.get('visited'), list):\n criteria['visited'] = criteria['visited'][0]\n query = query.filter_by(visited=self.config.ConvertStrToBool(criteria['visited']))\n if criteria.get('scope', None):\n if isinstance(criteria.get('scope'), list):\n criteria['scope'] = criteria['scope'][0]\n query = query.filter_by(scope=self.config.ConvertStrToBool(criteria['scope']))\n if not for_stats: # Query for stats can't have limit and offset\n try:\n if criteria.get('offset', None):\n if isinstance(criteria.get('offset'), list):\n criteria['offset'] = criteria['offset'][0]\n query = query.offset(int(criteria['offset']))\n if criteria.get('limit', None):\n if isinstance(criteria.get('limit'), list):\n criteria['limit'] = criteria['limit'][0]\n query = query.limit(int(criteria['limit']))\n except ValueError:\n raise InvalidParameterType(\"Invalid parameter type for transaction db\")\n return query","def sql(self, q):\r\n params = base.get_params(None, locals())\r\n url = '{0}/{1}'.format(self.get_url(), 'sql')\r\n\r\n return http.Request('POST', url, params), parsers.parse_json","def query(self, params):\n if not isinstance(params, dict) or not params:\n raise BadRequest('Non-empty dictionary is expected')\n\n url = self._dbname + '/_query'\n return self._connection.get(url, params).json()","def query(self, query):","def where(**kwargs):\n return QueryBuilder(Card).where(**kwargs)","def CreateQuery(self, pathInfo, opts, httpConfig, limit=None):\n\n web.debug(\"QueryFactory.CreateQuery\")\n web.debug(\"QueryFactory.CreateQuery: pathInfo = %s\" % pathInfo)\n web.debug(\"QueryFactory.CreateQuery: opts = %s\" % opts)\n web.debug(\"QueryFactory.CreateQuery: limit = %s\" % limit)\n\n query = None\n if pathInfo == \"/initiatives\":\n query = InitiativeQuery(opts, httpConfig)\n elif pathInfo == \"/frameworks\":\n query = FrameworkQuery(opts, httpConfig)\n elif pathInfo == \"/sets\":\n query = SetQuery(opts, httpConfig)\n elif pathInfo == \"/grade_levels\":\n query = GradeQuery(opts, httpConfig)\n elif pathInfo == \"/competency_containers\":\n query = ContainerQuery(opts, httpConfig)\n elif pathInfo == \"/competencys\":\n query = CompetencyQuery(opts, httpConfig)\n elif pathInfo == \"/domains\":\n query = DomainQuery(opts, httpConfig)\n elif pathInfo == \"/clusters\":\n query = ClusterQuery(opts, httpConfig)\n elif pathInfo == \"/standards\":\n query = StandardQuery(opts, httpConfig)\n elif pathInfo == \"/standard_components\":\n query = ComponentQuery(opts, httpConfig)\n\n elif pathInfo == \"/strands\":\n query = StrandQuery(opts, httpConfig)\n elif pathInfo == \"/anchor_standards\":\n query = AnchorQuery(opts, httpConfig)\n elif pathInfo == \"/anchor_standard_sections\":\n query = SectionQuery(opts, httpConfig)\n\n elif pathInfo in [\"/competency_paths\", \"/competency_path/\"]:\n query = PathQuery(opts, httpConfig)\n elif pathInfo in [\"/learning_resources\", \"/learning_resource/\"]:\n query = ResourceQuery(opts, httpConfig)\n\n\n elif pathInfo.find(\"/property_names\") != -1:\n # Get singular type name\n lriType = pathInfo.split(\"/property_names\")[0].strip(\"/\").rstrip(\"s\")\n query = PropertyQuery(lriType, opts, httpConfig)\n\n if limit is not None:\n query.setLimit(limit)\n\n #web.debug(\"QueryFactory.CreateQuery: query = %r\" % query)\n return query","def _getQuery(self, request):\n q = Conference.query()\n inequality_filter, filters = self._formatFilters(request.filters)\n # If exists, sort on inequality filter first\n if not inequality_filter:\n q = q.order(Conference.name)\n else:\n q = q.order(ndb.GenericProperty(inequality_filter))\n q = q.order(Conference.name)\n for filtr in filters:\n if filtr[\"field\"] in [\"month\", \"maxAttendees\"]:\n try:\n filtr[\"value\"] = int(filtr[\"value\"])\n except ValueError:\n raise endpoints.BadRequestException(\n \"Non-integer in integer field.\")\n formatted_query = ndb.query.FilterNode(\n filtr[\"field\"], filtr[\"operator\"], filtr[\"value\"])\n q = q.filter(formatted_query)\n return q","def query(output, query):\n gqlapi = gql.get_api()\n print_output(output, gqlapi.query(query))","def __init__(\n self,\n kind=None,\n project=None,\n namespace=None,\n ancestor=None,\n filters=(),\n projection=(),\n order=(),\n distinct_on=(),\n limit=None):\n self.kind = kind\n self.project = project\n self.namespace = namespace\n self.ancestor = ancestor\n self.filters = filters or ()\n self.projection = projection\n self.order = order\n self.distinct_on = distinct_on\n self.limit = limit","def _find(self, cls, data_source, **attr):\n sub_query = \"\"\"select from {} where \"\"\".format(cls) + \\\n \" and \".join([\"\"\"{} = {}\"\"\".format(\n key, \"\"\"\\\"{}\\\"\"\"\".format(value) if isinstance(value, str) else value) \\\n for key, value in attr.items() if value is not None])\n if data_source is None:\n q = self.sql_query(sub_query)\n else:\n q = self.sql_query(\n \"\"\" select from ({sub_query}) \\\n let $q = (select from (select expand($parent.$parent.current.in('Owns')))\n where @class='DataSource' and @rid = {rid}) \\\n where $q.size() = 1\"\"\".format(sub_query = sub_query, rid = data_source._id))\n return q","def get_queryset(self):\n queryset = Food.objects.all()\n name = self.request.query_params.get('name', None)\n ndb_no = self.request.query_params.get('ndb_no', None)\n if name is not None:\n queryset = queryset.filter(name=name)\n elif ndb_no is not None:\n queryset = queryset.filter(ndb_no=ndb_no)\n return queryset","def make_complex_query_set(self):\n\n query = self.request.GET.get(\"q\")\n category = self.request.GET.get(\"category\")\n title = self.request.GET.get(\"title\")\n\n q_object = Q()\n\n if query:\n q_object.add((\n Q(category__category_name__icontains=query) |\n Q(title__icontains=query) \n ), Q.OR)\n\n else:\n if category:\n q_object.add(\n Q(category=category),\n Q.AND)\n if title:\n q_object.add(\n Q(title__icontains=title),\n Q.AND)\n\n return q_object","def model_query(model, *args, **kwargs):\n\n with _session_for_read() as session:\n query = session.query(model, *args)\n return query","def search(datatype=None, dataType=None, pageSize=None, page=None):\n\n # create the full list of all calls implemented.\n data = [\n calls_get_helper('calls'),\n calls_get_helper('commoncropnames'),\n calls_get_helper('crops'),\n calls_get_helper('germplasm', versions=VERSIONS_LATEST),\n calls_get_helper('locations'),\n calls_get_helper('locations/{locationDbId}'),\n calls_get_helper('observationunits', versions=VERSIONS_LATEST),\n calls_get_helper('phenotypes-search', versions=VERSIONS_1_2),\n calls_get_helper('programs'),\n calls_get_helper('seasons'),\n calls_get_helper('studies'),\n calls_get_helper('studies/{studyDbId}'),\n calls_get_helper('studies/{studyDbId}/germplasm'),\n calls_get_helper('studies/{studyDbId}/layouts'),\n calls_get_helper('trials')\n ]\n\n # filter on datatype\n if dataType:\n data = [d for d in data if dataType in d['dataTypes']]\n elif datatype:\n data = [d for d in data if datatype in d['dataTypes']]\n\n # total number of rows\n count = len(data)\n\n # add a limit\n if not pageSize:\n pageSize = len(data)\n if not page:\n page = 0\n data = data[page * pageSize:(page + 1) * pageSize]\n\n # return the resulting data\n return helper.create_result({\"data\": data}, count, pageSize, page)","def smart_query(collection, condition):\r\n smart_condition = list()\r\n for condition_key, condition_value in condition.iteritems():\r\n if isinstance(condition_value, dict):\r\n # We do not optimize complicate conditions.\r\n smart_condition.append({condition_key: condition_value})\r\n else:\r\n smart_condition.append({\"$or\": [\r\n {condition_key: condition_value},\r\n {condition_key: None},\r\n {condition_key: {\"$exists\": False}}\r\n ]})\r\n query_condition = {\"$and\": smart_condition}\r\n debug.print_as_json(query_condition)\r\n return query(collection, query_condition)","def get_raw_query(self):\n # create a raw query\n if len(self.criteria) > 1:\n # more than one criteria, create a AND query\n raw_query = {\"$and\": self.criteria}\n else:\n # one criteria, raw query is the criteria\n raw_query = self.criteria[0]\n\n return raw_query","def api_query(self, **kwargs):\n with self._api_lock:\n return self._api_query(kwargs)","def index( self, trans, **kwd ):\n # Example URL: http://localhost:9009/api/repository_revisions\n repository_metadata_dicts = []\n # Build up an anded clause list of filters.\n clause_list = []\n # Filter by downloadable if received.\n downloadable = kwd.get( 'downloadable', None )\n if downloadable is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.downloadable == util.string_as_bool( downloadable ) )\n # Filter by malicious if received.\n malicious = kwd.get( 'malicious', None )\n if malicious is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.malicious == util.string_as_bool( malicious ) )\n # Filter by tools_functionally_correct if received.\n tools_functionally_correct = kwd.get( 'tools_functionally_correct', None )\n if tools_functionally_correct is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.tools_functionally_correct == util.string_as_bool( tools_functionally_correct ) )\n # Filter by missing_test_components if received.\n missing_test_components = kwd.get( 'missing_test_components', None )\n if missing_test_components is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.missing_test_components == util.string_as_bool( missing_test_components ) )\n # Filter by do_not_test if received.\n do_not_test = kwd.get( 'do_not_test', None )\n if do_not_test is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.do_not_test == util.string_as_bool( do_not_test ) )\n # Filter by includes_tools if received.\n includes_tools = kwd.get( 'includes_tools', None )\n if includes_tools is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.includes_tools == util.string_as_bool( includes_tools ) )\n # Filter by test_install_error if received.\n test_install_error = kwd.get( 'test_install_error', None )\n if test_install_error is not None:\n clause_list.append( trans.model.RepositoryMetadata.table.c.test_install_error == util.string_as_bool( test_install_error ) )\n # Filter by skip_tool_test if received.\n skip_tool_test = kwd.get( 'skip_tool_test', None )\n if skip_tool_test is not None:\n skip_tool_test = util.string_as_bool( skip_tool_test )\n skipped_metadata_ids_subquery = select( [ trans.app.model.SkipToolTest.table.c.repository_metadata_id ] )\n if skip_tool_test:\n clause_list.append( trans.model.RepositoryMetadata.id.in_( skipped_metadata_ids_subquery ) )\n else:\n clause_list.append( not_( trans.model.RepositoryMetadata.id.in_( skipped_metadata_ids_subquery ) ) )\n # Generate and execute the query.\n try:\n query = trans.sa_session.query( trans.app.model.RepositoryMetadata ) \\\n .filter( and_( *clause_list ) ) \\\n .order_by( trans.app.model.RepositoryMetadata.table.c.repository_id ) \\\n .all()\n for repository_metadata in query:\n repository_metadata_dict = repository_metadata.get_api_value( view='collection',\n value_mapper=default_value_mapper( trans, repository_metadata ) )\n repository_metadata_dict[ 'url' ] = web.url_for( controller='repository_revisions',\n action='show',\n id=trans.security.encode_id( repository_metadata.id ) )\n repository_metadata_dicts.append( repository_metadata_dict )\n return repository_metadata_dicts\n except Exception, e:\n message = \"Error in the Tool Shed repository_revisions API in index: \" + str( e )\n log.error( message, exc_info=True )\n trans.response.status = 500\n return message","def query(self, *, sparql: str) -> Result:\n pass","def perform_query(index_node, query_type):\n\n when = now()\n\n resp = do_query(index_node.name,\n [filter.value for filter in query_type.filters.all()],\n [facet.name for facet in query_type.facets.all()])\n\n client, _ = Host.objects.get_or_create(name=gethostname())\n \n response = Response.objects.create(\n index_node=index_node,\n status_code=resp['status_code'],\n datetime=when,\n client=client,\n query_type=query_type)\n\n if response.status_code == 200:\n \n response_data = ResponseData.objects.create(\n num_found=resp['num_found']\n )\n for facet_name, counts in resp['facet_counts'].items():\n for value, count in counts.items():\n facet, _ = Facet.objects.get_or_create(name=facet_name)\n facet_value, _ = \\\n FacetValue.objects.get_or_create(facet=facet,\n value=value)\n facet_value_count = \\\n FacetValueCount.objects.create(count=count,\n facet_value=facet_value,\n response_data=response_data)\n response.data = response_data\n response.save()","def test_query_generic_embedded_document(self):\n\n class A(EmbeddedDocument):\n a_name = StringField()\n\n class B(EmbeddedDocument):\n b_name = StringField()\n\n class Doc(Document):\n document = GenericEmbeddedDocumentField(choices=(A, B))\n\n Doc.drop_collection()\n Doc(document=A(a_name=\"A doc\")).save()\n Doc(document=B(b_name=\"B doc\")).save()\n\n # Using raw in filter working fine\n assert Doc.objects(__raw__={\"document.a_name\": \"A doc\"}).count() == 1\n assert Doc.objects(__raw__={\"document.b_name\": \"B doc\"}).count() == 1\n assert Doc.objects(document__a_name=\"A doc\").count() == 1\n assert Doc.objects(document__b_name=\"B doc\").count() == 1","def _build_filter_part(self, cls, filters, order_by=None, select=None):\r\n import types\r\n query_parts = []\r\n\r\n order_by_filtered = False\r\n\r\n if order_by:\r\n if order_by[0] == \"-\":\r\n order_by_method = \"DESC\";\r\n order_by = order_by[1:]\r\n else:\r\n order_by_method = \"ASC\";\r\n\r\n if select:\r\n if order_by and order_by in select:\r\n order_by_filtered = True\r\n query_parts.append(\"(%s)\" % select)\r\n\r\n if isinstance(filters, str) or isinstance(filters, unicode):\r\n query = \"WHERE %s AND `__type__` = '%s'\" % (filters, cls.__name__)\r\n if order_by in [\"__id__\", \"itemName()\"]:\r\n query += \" ORDER BY itemName() %s\" % order_by_method\r\n elif order_by != None:\r\n query += \" ORDER BY `%s` %s\" % (order_by, order_by_method)\r\n return query\r\n\r\n for filter in filters:\r\n filter_parts = []\r\n filter_props = filter[0]\r\n if type(filter_props) != list:\r\n filter_props = [filter_props]\r\n for filter_prop in filter_props:\r\n (name, op) = filter_prop.strip().split(\" \", 1)\r\n value = filter[1]\r\n property = cls.find_property(name)\r\n if name == order_by:\r\n order_by_filtered = True\r\n if types.TypeType(value) == types.ListType:\r\n filter_parts_sub = []\r\n for val in value:\r\n val = self.encode_value(property, val)\r\n if isinstance(val, list):\r\n for v in val:\r\n filter_parts_sub.append(self._build_filter(property, name, op, v))\r\n else:\r\n filter_parts_sub.append(self._build_filter(property, name, op, val))\r\n filter_parts.append(\"(%s)\" % (\" OR \".join(filter_parts_sub)))\r\n else:\r\n val = self.encode_value(property, value)\r\n if isinstance(val, list):\r\n for v in val:\r\n filter_parts.append(self._build_filter(property, name, op, v))\r\n else:\r\n filter_parts.append(self._build_filter(property, name, op, val))\r\n query_parts.append(\"(%s)\" % (\" or \".join(filter_parts)))\r\n\r\n\r\n type_query = \"(`__type__` = '%s'\" % cls.__name__\r\n for subclass in self._get_all_decendents(cls).keys():\r\n type_query += \" or `__type__` = '%s'\" % subclass\r\n type_query +=\")\"\r\n query_parts.append(type_query)\r\n\r\n order_by_query = \"\"\r\n\r\n if order_by:\r\n if not order_by_filtered:\r\n query_parts.append(\"`%s` LIKE '%%'\" % order_by)\r\n if order_by in [\"__id__\", \"itemName()\"]:\r\n order_by_query = \" ORDER BY itemName() %s\" % order_by_method\r\n else:\r\n order_by_query = \" ORDER BY `%s` %s\" % (order_by, order_by_method)\r\n\r\n if len(query_parts) > 0:\r\n return \"WHERE %s %s\" % (\" AND \".join(query_parts), order_by_query)\r\n else:\r\n return \"\"","def query(self,\n query: str,\n datatype: str = \"response\",\n page: int = 0,\n indices: str = \"\") -> dict:\n endpoint = \"/api/responses/\"\n if datatype == \"cert\":\n endpoint = \"/api/certs/\"\n elif datatype == \"domain\":\n endpoint = \"/api/domains/\"\n ret = self._request(\n endpoint=endpoint,\n params={\n \"q\": query,\n \"indices\": indices,\n \"start\": page * 20,\n },\n )\n return ret","def get_query(id: Optional[str] = None,\n query_pack_name: Optional[str] = None,\n resource_group_name: Optional[str] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetQueryResult:\n __args__ = dict()\n __args__['id'] = id\n __args__['queryPackName'] = query_pack_name\n __args__['resourceGroupName'] = resource_group_name\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __ret__ = pulumi.runtime.invoke('azure-native:operationalinsights/v20190901:getQuery', __args__, opts=opts, typ=GetQueryResult).value\n\n return AwaitableGetQueryResult(\n author=pulumi.get(__ret__, 'author'),\n body=pulumi.get(__ret__, 'body'),\n description=pulumi.get(__ret__, 'description'),\n display_name=pulumi.get(__ret__, 'display_name'),\n id=pulumi.get(__ret__, 'id'),\n name=pulumi.get(__ret__, 'name'),\n properties=pulumi.get(__ret__, 'properties'),\n related=pulumi.get(__ret__, 'related'),\n system_data=pulumi.get(__ret__, 'system_data'),\n tags=pulumi.get(__ret__, 'tags'),\n time_created=pulumi.get(__ret__, 'time_created'),\n time_modified=pulumi.get(__ret__, 'time_modified'),\n type=pulumi.get(__ret__, 'type'))","def _get_query(self) -> 'Query':\n subquery = graphene_sqlalchemy.get_query(self.model, self.info.context)\n\n request_filters = self.graphql_args.get(self.filter_arg)\n if request_filters:\n filter_set = self._get_filter_set(self.info)\n subquery = filter_set.filter(self.info, subquery, request_filters)\n\n aliased_model = aliased(\n self.model, subquery.subquery(with_labels=True)\n )\n\n query = (\n graphene_sqlalchemy.get_query(self.parent_model, self.info.context)\n .join(aliased_model, self.relation)\n .options(\n contains_eager(self.relation, alias=aliased_model),\n Load(self.parent_model).load_only(*self.parent_model_pks),\n )\n )\n query = self._sorted_query(\n query, self.graphql_args.get('sort'), aliased_model\n )\n return query","def ng_query(self, request, *args, **kwargs):\r\n return self.build_json_response(self.get_queryset())"],"string":"[\n \"def make_query(kind):\\n days = 4\\n now = datetime.datetime.now()\\n earlier = now - datetime.timedelta(days=days)\\n\\n query = query_pb2.Query()\\n query.kind.add().name = kind\\n\\n datastore_helper.set_property_filter(query.filter, 'created_at',\\n PropertyFilter.GREATER_THAN,\\n earlier)\\n\\n return query\",\n \"def _get_query_spec(cls, params):\\n entity_kind = params[cls.ENTITY_KIND_PARAM]\\n filters = params.get(cls.FILTERS_PARAM)\\n app = params.get(cls._APP_PARAM)\\n ns = params.get(cls.NAMESPACE_PARAM)\\n\\n return model.QuerySpec(\\n entity_kind=cls._get_raw_entity_kind(entity_kind),\\n keys_only=bool(params.get(cls.KEYS_ONLY_PARAM, False)),\\n filters=filters,\\n batch_size=int(params.get(cls.BATCH_SIZE_PARAM, cls._BATCH_SIZE)),\\n model_class_path=entity_kind,\\n app=app,\\n ns=ns)\",\n \"def search_filter(query_params, query):\\n if query_params.get('type') is not None:\\n query = query.filter(search.c.kind == query_params.get('type'))\\n return query\",\n \"def query(self, query, request_type=None):\\n\\n #encode to UTF-8\\n try: query = query.encode(\\\"utf-8\\\")\\n except: query = query.decode('raw_unicode_escape').encode(\\\"utf-8\\\")\\n\\n lowercase_query = query.lower()\\n if lowercase_query.startswith(\\\"select\\\") or \\\\\\n lowercase_query.startswith(\\\"describe\\\") or \\\\\\n lowercase_query.startswith(\\\"show\\\") or \\\\\\n request_type==\\\"GET\\\":\\n\\n return self._get(urllib.urlencode({'sql': query}))\\n\\n else:\\n return self._post(urllib.urlencode({'sql': query}))\",\n \"def build_query(self):\\r\\n\\r\\n # this filter is required\\r\\n query = Metric.query.filter(Metric.metric_type == self.metric_type)\\r\\n\\r\\n # get query parameters (parameters which are not here are ignored)\\r\\n is_active = request.args.get('is_active')\\r\\n frequency = request.args.get('frequency')\\r\\n threshold_type = request.args.get('threshold_type')\\r\\n sort = request.args.get('sort')\\r\\n\\r\\n # process each parameter, and if valid add it as a query condition\\r\\n if is_active is not None:\\r\\n is_active = is_active.lower() == 'true'\\r\\n query = Metric.query.filter_by(is_active=is_active)\\r\\n if frequency is not None:\\r\\n try:\\r\\n frequency = Frequency.from_name(frequency)\\r\\n except ValueError as e:\\r\\n msg = f\\\"Invalid 'frequency': {frequency}. Use one of {Frequency.values()}\\\"\\r\\n abort(400, message=msg)\\r\\n query = query.filter_by(frequency=frequency)\\r\\n if threshold_type is not None:\\r\\n try:\\r\\n threshold_type = ThresholdType.from_name(threshold_type)\\r\\n except ValueError as e:\\r\\n msg = f\\\"Invalid 'threshold_type': {threshold_type}. Use one of \\\" \\\\\\r\\n f\\\"{ThresholdType.values()}\\\"\\r\\n abort(400, message=msg)\\r\\n query = query.filter_by(threshold_type=threshold_type)\\r\\n if sort is not None and sort.lstrip(\\\"-\\\") == 'metric_id':\\r\\n query = query.order_by(Metric.metric_id.desc())\\r\\n else:\\r\\n query = query.order_by(Metric.metric_id)\\r\\n\\r\\n return query\",\n \"def types_query(owner_name):\\n query = Products.query.with_entities(Products.type_name.label('Type'))\\\\\\n .filter_by(owner_name=owner_name)\\\\\\n .distinct()\\n return query\",\n \"def showGqlQuery(query):\\n proto = query._proto_query\\n kind = query._model_class.kind()\\n filters = proto.filters()\\n boundfilters = proto._GQL__bound_filters\\n orderings = proto.orderings()\\n hint = proto.hint()\\n limit = proto.limit()\\n offset = proto._GQL__offset\\n\\n select = \\\"SELECT * FROM %s\\\" % kind\\n where = []\\n order = []\\n\\n for k in sorted(filters):\\n for clause in filters[k]:\\n name, op = clause\\n if name==-1: name = 'ANCESTOR'\\n where.append(\\\"%s %s :%s\\\" % (name, op.upper(), k))\\n\\n for k in sorted(boundfilters):\\n if isinstance(k, tuple):\\n op = ' '.join(k)\\n else:\\n op = k\\n where.append(\\\"%s %r\\\" % (op, boundfilters[k]))\\n\\n for p, o in orderings:\\n order.append(\\\"%s %s\\\" % (p, 'DESC' if o==datastore.Query.DESCENDING else 'ASC'))\\n\\n gql = select\\n if where:\\n gql += ' WHERE '+' AND '.join(where)\\n if order:\\n gql += ' ORDER BY ' + ', '.join(order)\\n if limit != -1:\\n if offset != -1:\\n gql += ' LIMIT %s,%s' % (offset,limit)\\n else:\\n gql += ' LIMIT %s' % limit\\n elif offset != -1:\\n gql += ' OFFSET %s' % offset\\n return gql\",\n \"def get_query(cls, model, info: 'ResolveInfo', sort=None, **args):\\n query = super().get_query(model, info, sort, **args)\\n\\n request_filters = args.get(cls.filter_arg)\\n if request_filters:\\n filter_set = cls.get_filter_set(info)\\n query = filter_set.filter(info, query, request_filters)\\n\\n return query\",\n \"def query(cls, **kwds):\\n #NOTE: Only static properties can be indexed by homer, \\n # so we don't worry about querying for dynamic properties\\n query = \\\"\\\"\\n started = False\\n for name in kwds:\\n if not started:\\n pattern = \\\"%s=:%s\\\" % (name, name)\\n query += pattern\\n started = True\\n else:\\n pattern = \\\" AND %s=:%s\\\" % (name, name)\\n query += pattern\\n\\n q = 'SELECT * FROM %s WHERE %s' % (cls.kind(), query)\\n query = CqlQuery(cls, q, **kwds)\\n query.convert = True\\n return query\",\n \"def query(self, name, python_type, optional=False, **kwargs):\\n return self.simple_param('query', name, python_type, optional=optional,\\n **kwargs)\",\n \"def queryComponent(type=None, filter=None, all=0):\",\n \"def get_sort_query(self, kind, order, is_number):\\n pass\",\n \"def _build_query(self, types=(), paths=(), depth=None, query=None, filterPermissions=True, globFilters=None):\\n available_indexes = self.model_catalog.searcher.get_indexes()\\n not_indexed_user_filters = {} # Filters that use not indexed fields\\n\\n user_filters_query = None\\n types_query = None\\n paths_query = None\\n permissions_query = None\\n\\n partial_queries = []\\n\\n if query:\\n \\\"\\\"\\\"\\n # if query is a dict, we convert it to AdvancedQuery\\n # @TODO We should make the default query something other than AdvancedQuery\\n subqueries = []\\n if isinstance(query, dict):\\n for attr, value in query.iteritems():\\n if isinstance(value, str) and '*' in value:\\n subqueries.append(MatchGlob(attr, value))\\n else:\\n subqueries.append(Eq(attr, value))\\n query = And(*subqueries)\\n partial_queries.append(query)\\n \\\"\\\"\\\"\\n partial_queries.append(self._parse_user_query(query))\\n\\n # Build query from filters passed by user\\n if globFilters:\\n for key, value in globFilters.iteritems():\\n if key in available_indexes:\\n if user_filters_query:\\n user_filters_query = And(query, MatchRegexp(key, '*%s*' % value))\\n else:\\n user_filters_query = MatchRegexp(key, '*%s*' % value)\\n else:\\n not_indexed_user_filters[key] = value\\n\\n if user_filters_query:\\n partial_queries.append(user_filters_query)\\n\\n # Build the objectImplements query\\n if not isinstance(types, (tuple, list)):\\n types = (types,)\\n types_query_list = [ Eq('objectImplements', dottedname(t)) for t in types ]\\n if types_query_list:\\n if len(types_query_list) > 1:\\n types_query = Or(*types_query_list)\\n else:\\n types_query = types_query_list[0]\\n\\n partial_queries.append(types_query)\\n\\n # Build query for paths\\n if paths is not False: # When paths is False we dont add any path condition\\n if not paths:\\n paths = ('/'.join(self.context.getPhysicalPath()) + '*', )\\n elif isinstance(paths, basestring):\\n paths = (paths,)\\n\\n \\\"\\\"\\\" OLD CODE. Why this instead of In? What do we need depth for?\\n q = {'query':paths}\\n if depth is not None:\\n q['depth'] = depth\\n paths_query = Generic('path', q)\\n \\\"\\\"\\\"\\n paths_query = In('path', paths)\\n partial_queries.append(paths_query)\\n\\n # filter based on permissions\\n if filterPermissions and allowedRolesAndGroups(self.context):\\n permissions_query = In('allowedRolesAndUsers', allowedRolesAndGroups(self.context))\\n partial_queries.append(permissions_query)\\n\\n # Put together all queries\\n search_query = And(*partial_queries)\\n return (search_query, not_indexed_user_filters)\",\n \"def query(self):\\n q = dict(self._query)\\n fworker_check = [{\\\"spec._fworker\\\": {\\\"$exists\\\": False}}, {\\\"spec._fworker\\\": None}, {\\\"spec._fworker\\\": self.name}]\\n if \\\"$or\\\" in q:\\n q[\\\"$and\\\"] = q.get(\\\"$and\\\", [])\\n q[\\\"$and\\\"].extend([{\\\"$or\\\": q.pop(\\\"$or\\\")}, {\\\"$or\\\": fworker_check}])\\n else:\\n q[\\\"$or\\\"] = fworker_check\\n if self.category and isinstance(self.category, str):\\n if self.category == \\\"__none__\\\":\\n q[\\\"spec._category\\\"] = {\\\"$exists\\\": False}\\n else:\\n q[\\\"spec._category\\\"] = self.category\\n elif self.category: # category is list of str\\n q[\\\"spec._category\\\"] = {\\\"$in\\\": self.category}\\n\\n return q\",\n \"def _query(self, model_class, **kwargs):\\r\\n query = model_class.objects\\r\\n if self.select_for_update:\\r\\n query = query.select_for_update()\\r\\n query = query.filter(**kwargs)\\r\\n return query\",\n \"def execute_query(self, *, scope: Scope, params: QueryParams) -> QueryResults:\",\n \"def query():\\n data = {'version': config.API_VERSION}\\n args = flask.request.args\\n limit = args.get('limit', config.DEFAULT_QUERY_LIMIT)\\n offset = args.get('offset', 0)\\n q = args.get('q', '')\\n table = args.get('table')\\n filter_params = {'filter': args.get('filter')}\\n try:\\n total, result = db_client.search(table, q,\\n limit, offset,\\n **filter_params)\\n data['result_count'] = total\\n data['results'] = result\\n except db.InvalidTable:\\n data['error'] = 'Invalid table:'+str(table)\\n\\n return flask.jsonify(data)\",\n \"def query(env):\\n if app.config['ENABLE_QUERY']:\\n envs = environments()\\n check_env(env, envs)\\n\\n form = QueryForm(meta={\\n 'csrf_secret': app.config['SECRET_KEY'],\\n 'csrf_context': session})\\n if form.validate_on_submit():\\n if form.endpoints.data == 'pql':\\n query = form.query.data\\n elif form.query.data[0] == '[':\\n query = form.query.data\\n else:\\n query = '[{0}]'.format(form.query.data)\\n result = get_or_abort(\\n puppetdb._query,\\n form.endpoints.data,\\n query=query)\\n return render_template('query.html',\\n form=form,\\n result=result,\\n envs=envs,\\n current_env=env)\\n return render_template('query.html',\\n form=form,\\n envs=envs,\\n current_env=env)\\n else:\\n log.warn('Access to query interface disabled by administrator..')\\n abort(403)\",\n \"def gql(cls, clause, *args, **kwds):\\n query_string = 'SELECT * FROM %s %s' % (cls.kind(), clause)\\n query = _query_cache.get(query_string)\\n if query is None:\\n _query_cache[query_string] = query = db.GqlQuery(query_string)\\n query.bind(*args, **kwds)\\n return query\",\n \"def by_type(cls, typ='creditcard'):\\n return Filter('type', values=(typ,), operator=Filter.OPERATOR['EQUAL'])\",\n \"def dynamic_query(model, fields, types, values, operator):\\n\\t\\n\\tqueries = []\\n\\tfor (f, t, v) in zip(fields, types, values):\\n\\n\\t\\tif v != None:\\n\\t\\t\\tif t == 'in':\\n\\t\\t\\t\\tkwargs = {str('%s__%s' % (f,t)) : v}\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\\n\\t\\t\\tqueries.append(Q(**kwargs))\\n\\t\\n\\t# Make sure we have a list of filters\\n\\tif len(queries) > 0:\\n\\t\\tq = Q()\\n\\t\\t# AND/OR awareness\\n\\t\\tfor query in queries:\\n\\t\\t\\tif operator == \\\"and\\\":\\n\\t\\t\\t\\tq = q & query\\n\\t\\t\\telif operator == \\\"or\\\":\\n\\t\\t\\t\\tq = q | query\\n\\t\\t\\telse:\\n\\t\\t\\t\\tq = None\\n\\t\\tif q:\\n\\t\\t\\t# We have a Q object, return the QuerySet\\n\\t\\t\\treturn model.objects.filter(q)\\n\\telse:\\n\\t\\t# Return an empty result\\n\\t\\treturn {}\",\n \"def _make_query(self):\\r\\n raise NotImplementedError()\",\n \"def create_filter_query(self, collection_name: str, field: str, filter_type: str, filter_values: Union[List[str], str]=None):\\n if filter_type == 'contains':\\n # return [{'field' : field, 'filter_type' : 'contains', \\\"condition\\\":\\\"==\\\", \\\"condition_value\\\": filter_values}]\\n return [{'field': field, 'filter_type': 'regexp', 'condition': '==', 'condition_value': '.*' + str(filter_values) + '.*'}]\\n if filter_type == 'exact_match':\\n return [{'field' : field, 'filter_type' : 'exact_match', \\\"condition\\\":\\\"==\\\", \\\"condition_value\\\": filter_values}]\\n if filter_type == 'categories':\\n return [{'field' : field, 'filter_type' : 'categories', \\\"condition\\\":\\\"==\\\", \\\"condition_value\\\": filter_values}]\\n if filter_type == 'exists':\\n if filter_values is None or filter_values == '==':\\n return [{'field' : field, 'filter_type' : 'exists', \\\"condition\\\":\\\"==\\\", \\\"condition_value\\\":\\\" \\\"}]\\n elif filter_values == '!=':\\n return [{'field' : field, 'filter_type' : 'exists', \\\"condition\\\":\\\"!=\\\", \\\"condition_value\\\":\\\" \\\"}]\\n if filter_type == '<=' or filter_type == '>=' or filter_type == '>' or filter_type == '<' or filter_type == '==':\\n if self.collection_schema(collection_name)[field] == 'date':\\n return [{'field' : field, 'filter_type' : 'date', \\\"condition\\\":filter_type, \\\"condition_value\\\": filter_values}]\\n elif self.collection_schema(collection_name)[field] == 'numeric':\\n return [{'field' : field, 'filter_type' : 'numeric', \\\"condition\\\":filter_type, \\\"condition_value\\\":filter_values}]\\n else:\\n raise ValueError(f\\\"{filter_type} has not been defined. Please choose one of contains/exact_match/exists/categories/>=/<=/>/<.\\\")\",\n \"def query(query, ts, **kwargs):\\n queryobj = _parse_query(query)\\n\\n if queryobj['querytype'] in ('select', 'retrieve'):\\n return _select(\\n queryobj['projection'],\\n queryobj['tables'],\\n queryobj['where'],\\n ts,\\n mode=kwargs.get('mode', 'list'),\\n cast=kwargs.get('cast', True))\\n else:\\n # not really a syntax error; replace with TSQLError or something\\n # when the proper exception class exists\\n raise TSQLSyntaxError(queryobj['querytype'] +\\n ' queries are not supported')\",\n \"def get_query():\\n return CiscoVlanIftableRelationshipQuery\",\n \"def get_query(self):\\n return self.query_class(self)\",\n \"def model_query(context, *args, **kwargs):\\n session = kwargs.get('session') or context.session\\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\\n project_only = kwargs.get('project_only')\\n\\n query = session.query(*args)\\n\\n if read_deleted == 'no':\\n query = query.filter_by(deleted=False)\\n elif read_deleted == 'yes':\\n pass # omit the filter to include deleted and active\\n elif read_deleted == 'only':\\n query = query.filter_by(deleted=True)\\n elif read_deleted == 'int_no':\\n query = query.filter_by(deleted=0)\\n else:\\n raise Exception(\\n _(\\\"Unrecognized read_deleted value '%s'\\\") % read_deleted)\\n\\n if project_only and _is_user_context(context):\\n query = query.filter_by(project_id=context.project_id)\\n\\n return query\",\n \"def model_query(context, *args, **kwargs):\\n session = kwargs.get('session') or context.session\\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\\n project_only = kwargs.get('project_only')\\n\\n query = session.query(*args)\\n\\n if read_deleted == 'no':\\n query = query.filter_by(deleted=False)\\n elif read_deleted == 'yes':\\n pass # omit the filter to include deleted and active\\n elif read_deleted == 'only':\\n query = query.filter_by(deleted=True)\\n elif read_deleted == 'int_no':\\n query = query.filter_by(deleted=0)\\n else:\\n raise Exception(\\n _(\\\"Unrecognized read_deleted value '%s'\\\") % read_deleted)\\n\\n if project_only and _is_user_context(context):\\n query = query.filter_by(project_id=context.project_id)\\n\\n return query\",\n \"def query(cls):\\n query_class = cls.query_class\\n return query_class(orm_class=cls)\",\n \"def make_query(self):\",\n \"def query(self, q, **kwargs):\\n return self._client.query(self._db_name, q, **kwargs)\",\n \"def Query(self, what, fields, qfilter=None, reason=None):\\n query = []\\n _AppendReason(query, reason)\\n\\n body = {\\n \\\"fields\\\": fields,\\n }\\n\\n _SetItemIf(body, qfilter is not None, \\\"qfilter\\\", qfilter)\\n # TODO: remove \\\"filter\\\" after 2.7\\n _SetItemIf(body, qfilter is not None, \\\"filter\\\", qfilter)\\n\\n return self._SendRequest(HTTP_PUT,\\n (\\\"/%s/query/%s\\\" %\\n (GANETI_RAPI_VERSION, what)), query, body)\",\n \"def model_query(context, *args, **kwargs):\\n session = kwargs.get('session') or get_session()\\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\\n project_only = kwargs.get('project_only')\\n\\n query = session.query(*args)\\n\\n if read_deleted == 'no':\\n query = query.filter_by(deleted=False)\\n elif read_deleted == 'yes':\\n pass # omit the filter to include deleted and active\\n elif read_deleted == 'only':\\n query = query.filter_by(deleted=True)\\n else:\\n raise Exception(\\n _(\\\"Unrecognized read_deleted value '%s'\\\") % read_deleted)\\n\\n if project_only and is_user_context(context):\\n query = query.filter_by(project_id=context.project_id)\\n\\n return query\",\n \"def model_query(context, *args, **kwargs):\\n session = kwargs.get('session') or get_session()\\n read_deleted = kwargs.get('read_deleted') or context.read_deleted\\n project_only = kwargs.get('project_only')\\n\\n query = session.query(*args)\\n\\n if read_deleted == 'no':\\n query = query.filter_by(deleted=False)\\n elif read_deleted == 'yes':\\n pass # omit the filter to include deleted and active\\n elif read_deleted == 'only':\\n query = query.filter_by(deleted=True)\\n else:\\n raise Exception(\\n _(\\\"Unrecognized read_deleted value '%s'\\\") % read_deleted)\\n\\n if project_only and is_user_context(context):\\n query = query.filter_by(project_id=context.project_id)\\n\\n return query\",\n \"def gws_q(self, query, attribute, data):\\n \\n gws_q = query.format(attribute, data) #attribute = SQL table\\n \\n query_df = db.query(gws_q) \\n return query_df\",\n \"def query(cls, *attrs):\\n if len(attrs) == 0:\\n attrs = [cls]\\n return _s().query(*attrs)\",\n \"def query(resource: T) -> Union[Iterable[T], Query[T]]:\\n if not db:\\n status()\\n return db.query(resource)\",\n \"def get_query_from_driver(driver, wrapper=None):\\n if wrapper:\\n return driver.query.from_object(\\n wrapper,\\n ).first().query\\n\\n return driver.query\",\n \"def _get_query(self):\\n\\n endpoint = ENDPOINTS[self.sync_data.endpoint_index]\\n marker = self.sync_data.markers.get(self.sync_data.endpoint_index, START_OF_TIME)\\n\\n query_string = \\\"select \\\" + \\\",\\\".join(ENDPOINT_QUERY_FIELDS[endpoint])\\n\\n # ZOQL does not support the `order by` sorting\\n query_string = query_string + \\\" from {} where UpdatedDate > '{}'\\\".format(\\n endpoint,\\n marker\\n )\\n\\n return query_string\",\n \"def query(self, klass):\\n return self.getSession().query(klass)\",\n \"def query(q,epr,f='application/sparql-results+json'):\\n\\n try:\\n params = {'query': q}\\n params = urllib.urlencode(params)\\n opener = urllib2.build_opener(urllib2.HTTPHandler)\\n request = urllib2.Request(epr+'?'+params)\\n request.add_header('Accept', f)\\n request.get_method = lambda: 'GET'\\n url = opener.open(request)\\n return url.read()\\n except Exception, e:\\n traceback.print_exc(file=sys.stdout)\\n raise e\",\n \"def get_matching_events(cls, start_date=None, end_date=None, kind=None):\\n\\n query = cls.query.order_by(cls.date)\\n\\n if start_date:\\n query = query.filter(cls.date >= start_date)\\n\\n if end_date:\\n query = query.filter(cls.date <= end_date)\\n\\n if kind and kind != 'all':\\n query = query.filter(cls.kind == kind)\\n\\n return query.all()\",\n \"def find(self, cls, **attr):\\n query_str = \\\"\\\"\\\"select from {} where \\\"\\\"\\\".format(cls) + \\\\\\n \\\" and \\\".join([\\\"\\\"\\\"{} = {}\\\"\\\"\\\".format(\\n key, \\\"\\\"\\\"\\\\\\\"{}\\\\\\\"\\\"\\\"\\\".format(value) if isinstance(value, str) else value) \\\\\\n for key, value in attr.items() if value is not None])\\n q = self.sql_query(query_str)\\n return q\",\n \"def query(self):\\n return Query(from_=self)\",\n \"def qry(cls, entity, order_by_date='-modified', compare_date=None,\\n date=None, time_offset=None,\\n compare_version=None, version=None,\\n **kwargs):\\n qry = entity.query(**kwargs)\\n if order_by_date == '-modified':\\n qry = qry.order(-cls.modified)\\n elif order_by_date == 'modified':\\n qry = qry.order(cls.modified)\\n elif order_by_date == 'created':\\n qry = qry.order(cls.created)\\n elif order_by_date == '-created':\\n qry = qry.order(-cls.created)\\n\\n if date:\\n if isinstance(date, basestring):\\n date = datetime.datetime.strptime(date,\\\"%Y-%m-%d %H:%M:%S\\\")\\n if time_offset:\\n date = date + datetime.timedelta(seconds=time_offset)\\n if compare_date == '>modified' :\\n qry = qry.filter(cls.modified > date)\\n elif compare_date == '>=modified' :\\n qry = qry.filter(cls.modified >= date)\\n elif compare_date == '<modified' :\\n qry = qry.filter(cls.modified < date)\\n elif compare_date == '<=modified' :\\n qry = qry.filter(cls.modified <= date)\\n elif compare_date == '>created' :\\n qry = qry.filter(cls.created > date)\\n elif compare_date == '>=created' :\\n qry = qry.filter(cls.created >= date)\\n elif compare_date == '<created' :\\n qry = qry.filter(cls.created < date)\\n elif compare_date == '<=created' :\\n qry = qry.filter(cls.created <= date)\\n\\n if version:\\n if compare_version == '>' :\\n qry = qry.filter(cls.version > version)\\n elif compare_version == '>=' :\\n qry = qry.filter(cls.version >= version)\\n elif compare_version == '<' :\\n qry = qry.filter(cls.version < version)\\n elif compare_version == '<=' :\\n qry = qry.filter(cls.version <= version)\\n elif compare_version == '==' :\\n qry = qry.filter(cls.version == version)\\n return qry\",\n \"def build_query(self):\\r\\n # build query from base class add required field for joining with parent\\r\\n query = super().build_query()\\r\\n query = query.filter(Metric.metric_id == QuantModelMetric.metric_id)\\r\\n\\r\\n # get the remaining query parameters\\r\\n asset_class = request.args.get('asset_class')\\r\\n model_name = request.args.get('model_name')\\r\\n pricing_library = request.args.get('pricing_library')\\r\\n\\r\\n # process each parameter and, if valid, add as a query condition\\r\\n if asset_class is not None:\\r\\n query = query.filter(QuantModelMetric.asset_class == asset_class)\\r\\n if model_name is not None:\\r\\n query = query.filter(QuantModelMetric.model_name == model_name)\\r\\n if pricing_library is not None:\\r\\n query = query.filter(QuantModelMetric.pricing_library == pricing_library)\\r\\n return query\",\n \"def expand_type_query(owner_name: str, type_name: []) -> 'session query':\\n critical_level = get_critical_level(owner_name, type_name)\\n\\n ordered = db.session.query(\\n func.sum(SpecificOrders.quantity).label('number')\\n )\\\\\\n .join(Orders, Orders.order_id == SpecificOrders.order_id)\\\\\\n .filter(\\n and_(\\n Orders.supplier_name == owner_name,\\n SpecificOrders.type_name.in_(type_name)\\n )\\n\\n )\\n\\n query = select([Products.type_name.label('Type'),\\n Products.serial_number.label('Serial number'),\\n Products.producent.label('Producent'),\\n Products.model.label('Model'),\\n Products.product_condition.label('Condition'),\\n Products.additonal_info.label('Additional info'),\\n Products.appear_in_order.label('Bind to order')])\\\\\\n .where(\\n and_(\\n Products.owner_name == owner_name,\\n Products.type_name.in_(type_name)\\n )\\n ).order_by(Products.appear_in_order.asc(),Products.serial_number.asc())\\n return db.session.query(aliased(query)), ordered, critical_level\",\n \"def raw_query(\\n # TODO: Passing the whole clickhouse query here is needed as long\\n # as the execute method depends on it. Otherwise we can make this\\n # file rely either entirely on clickhouse query or entirely on\\n # the formatter.\\n clickhouse_query: Union[Query, CompositeQuery[Table]],\\n request_settings: RequestSettings,\\n formatted_query: FormattedQuery,\\n reader: Reader,\\n timer: Timer,\\n query_metadata: SnubaQueryMetadata,\\n stats: MutableMapping[str, Any],\\n trace_id: Optional[str] = None,\\n robust: bool = False,\\n) -> QueryResult:\\n all_confs = state.get_all_configs()\\n query_settings: MutableMapping[str, Any] = {\\n k.split(\\\"/\\\", 1)[1]: v\\n for k, v in all_confs.items()\\n if k.startswith(\\\"query_settings/\\\")\\n }\\n\\n timer.mark(\\\"get_configs\\\")\\n\\n sql = formatted_query.get_sql()\\n\\n update_with_status = partial(\\n update_query_metadata_and_stats,\\n clickhouse_query,\\n sql,\\n timer,\\n stats,\\n query_metadata,\\n query_settings,\\n trace_id,\\n )\\n\\n execute_query_strategy = (\\n execute_query_with_readthrough_caching\\n if state.get_config(\\\"use_readthrough_query_cache\\\", 1)\\n else execute_query_with_caching\\n )\\n\\n try:\\n result = execute_query_strategy(\\n clickhouse_query,\\n request_settings,\\n formatted_query,\\n reader,\\n timer,\\n stats,\\n query_settings,\\n robust=robust,\\n )\\n except Exception as cause:\\n if isinstance(cause, RateLimitExceeded):\\n stats = update_with_status(QueryStatus.RATE_LIMITED)\\n else:\\n with configure_scope() as scope:\\n if isinstance(cause, ClickhouseError):\\n scope.fingerprint = [\\\"{{default}}\\\", str(cause.code)]\\n if scope.span:\\n if cause.code == errors.ErrorCodes.TOO_SLOW:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"predicted\\\")\\n elif cause.code == errors.ErrorCodes.TIMEOUT_EXCEEDED:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"query_timeout\\\")\\n elif cause.code in (\\n errors.ErrorCodes.SOCKET_TIMEOUT,\\n errors.ErrorCodes.NETWORK_ERROR,\\n ):\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"network\\\")\\n elif isinstance(cause, (TimeoutError, ExecutionTimeoutError)):\\n if scope.span:\\n sentry_sdk.set_tag(\\\"timeout\\\", \\\"cache_timeout\\\")\\n\\n logger.exception(\\\"Error running query: %s\\\\n%s\\\", sql, cause)\\n stats = update_with_status(QueryStatus.ERROR)\\n raise QueryException(\\n {\\n \\\"stats\\\": stats,\\n \\\"sql\\\": sql,\\n \\\"experiments\\\": clickhouse_query.get_experiments(),\\n }\\n ) from cause\\n else:\\n stats = update_with_status(QueryStatus.SUCCESS)\\n return QueryResult(\\n result,\\n {\\n \\\"stats\\\": stats,\\n \\\"sql\\\": sql,\\n \\\"experiments\\\": clickhouse_query.get_experiments(),\\n },\\n )\",\n \"def get_resource_query(self):\\n pass\",\n \"def get_resource_query(self):\\n pass\",\n \"def __init__(self, kind=None, filters={}, _app=None, keys_only=False,\\n compile=True, cursor=None, _namespace=None):\\n if kind is not None:\\n datastore_types.ValidateString(kind, 'kind',\\n datastore_errors.BadArgumentError)\\n\\n self.__kind = kind\\n self.__orderings = []\\n self.__filter_order = {}\\n self.update(filters)\\n\\n self.__app = datastore_types.ResolveAppIdNamespace(_app,\\n _namespace).to_encoded()\\n self.__keys_only = keys_only\\n self.__compile = compile\\n self.__cursor = cursor\",\n \"def make_complex_query_set(self):\\n\\n query = self.request.GET.get(\\\"q\\\")\\n category_name = self.request.GET.get(\\\"category_name\\\")\\n o_net_soc_code = self.request.GET.get(\\\"o_net_soc_code\\\")\\n description = self.request.GET.get(\\\"description\\\")\\n job_title = self.request.GET.get(\\\"job_title\\\")\\n level = self.request.GET.get(\\\"level\\\", '')\\n\\n q_object = Q()\\n\\n if query:\\n q_object.add((\\n Q(category__category_name__icontains=query) |\\n Q(category__o_net_soc_code__icontains=query) |\\n Q(category__description__icontains=query) |\\n Q(category__job_title__description__icontains=query) |\\n Q(category__job_title__title__icontains=query)\\n ), Q.OR)\\n\\n if query.isnumeric():\\n q_object.add(\\n Q(category__job_title__level__icontains=int(query)), Q.OR)\\n\\n else:\\n if category_name:\\n q_object.add(\\n Q(category__category_name__icontains=category_name),\\n Q.AND)\\n\\n if o_net_soc_code:\\n q_object.add(\\n Q(category__o_net_soc_code__icontains=o_net_soc_code),\\n Q.AND)\\n\\n if description:\\n q_object.add((\\n Q(category__description__icontains=description) |\\n Q(\\n category__job_title__description__icontains=description)\\n ), Q.AND)\\n\\n if job_title:\\n q_object.add(\\n Q(category__job_title__title__icontains=job_title),\\n Q.AND)\\n\\n if level:\\n if level.isnumeric():\\n q_object.add(\\n Q(category__job_title__level__icontains=int(level)),\\n Q.AND)\\n else:\\n raise Exception(\\n ErrorMessage.WRONG_FIELD_TYPE.value.format(\\\"level\\\",\\n \\\"numeric\\\"))\\n\\n return q_object\",\n \"def build_query(self):\\r\\n query = super().build_query()\\r\\n query = query.filter(Metric.metric_id == MlModelMetric.metric_id)\\r\\n algorithm = request.args.get('algorithm')\\r\\n if algorithm is not None:\\r\\n query = query.filter(MlModelMetric.algorithm == algorithm)\\r\\n return query\",\n \"def query_criteria(self, *, calibration_level=None,\\n data_product_type=None, intent=None,\\n obs_collection=None, instrument_name=None,\\n filters=None, proposal=None, async_job=True, output_file=None,\\n output_format=\\\"votable\\\", verbose=False,\\n get_query=False):\\n\\n parameters = []\\n if calibration_level is not None:\\n parameters.append(\\\"calibration_level={}\\\".format(\\n self.__get_calibration_level(calibration_level)))\\n if data_product_type is not None:\\n if isinstance(data_product_type, str):\\n parameters.append(\\\"data_product_type LIKE '%{}%'\\\".format(\\n data_product_type))\\n else:\\n raise ValueError(\\\"data_product_type must be a string\\\")\\n if intent is not None:\\n if isinstance(intent, str):\\n parameters.append(\\\"intent LIKE '%{}%'\\\".format(intent.lower()))\\n else:\\n raise ValueError(\\\"intent must be a string\\\")\\n if proposal is not None:\\n if isinstance(proposal, int):\\n parameters.append(\\\"proposal_id = '{}'\\\".format(proposal))\\n else:\\n raise ValueError(\\\"Proposal ID must be an integer\\\")\\n if self.__check_list_strings(obs_collection):\\n parameters.append(\\\"(collection LIKE '%{}%')\\\".format(\\n \\\"%' OR collection LIKE '%\\\".join(obs_collection)\\n ))\\n if self.__check_list_strings(instrument_name):\\n parameters.append(\\\"(instrument_name LIKE '%{}%')\\\".format(\\n \\\"%' OR instrument_name LIKE '%\\\".join(instrument_name)\\n ))\\n if self.__check_list_strings(filters):\\n parameters.append(\\\"(instrument_configuration LIKE '%{}%')\\\"\\n .format(\\\"%' OR instrument_configuration \\\"\\n \\\"LIKE '%\\\".join(filters)))\\n query = \\\"select * from ehst.archive\\\"\\n if parameters:\\n query += \\\" where({})\\\".format(\\\" AND \\\".join(parameters))\\n if verbose:\\n log.info(query)\\n if get_query:\\n return query\\n table = self.query_tap(query=query, async_job=async_job,\\n output_file=output_file,\\n output_format=output_format,\\n verbose=verbose)\\n return table\",\n \"def _getQuery(self, request):\\n q = Conference.query()\\n inequality_filter, filters = self._formatFilters(request.filters)\\n\\n # If exists, sort on inequality filter first\\n if not inequality_filter:\\n q = q.order(Conference.name)\\n else:\\n q = q.order(ndb.GenericProperty(inequality_filter))\\n q = q.order(Conference.name)\\n\\n for filtr in filters:\\n if filtr[\\\"field\\\"] in [\\\"month\\\", \\\"maxAttendees\\\"]:\\n filtr[\\\"value\\\"] = int(filtr[\\\"value\\\"])\\n formatted_query = ndb.query.FilterNode(filtr[\\\"field\\\"], filtr[\\\"operator\\\"], filtr[\\\"value\\\"])\\n q = q.filter(formatted_query)\\n return q\",\n \"def q(cls) -> Query:\\n if not cls.s:\\n raise M2Error('No DB session defined')\\n return cls.s.query(cls)\",\n \"def query(self, **kwargs):\",\n \"def make_complex_query_set(self):\\n\\n query = self.request.GET.get(\\\"q\\\")\\n program_id = self.request.META.get('HTTP_X_SVMS_PROGRAM_ID')\\n category = self.request.GET.get(\\\"category\\\")\\n title = self.request.GET.get(\\\"title\\\")\\n level = self.request.GET.get(\\\"level\\\")\\n description = self.request.GET.get(\\\"description\\\")\\n status = self.request.GET.get(\\\"status\\\")\\n job_tag = self.request.GET.get(\\\"job_tag\\\")\\n\\n q_object = Q()\\n\\n if query:\\n q_object.add((\\n Q(program_id=query) |\\n Q(category=query) |\\n Q(title__icontains=query) |\\n #Q(category__category_name__icontains=query) |\\n Q(description__icontains=query) |\\n Q(job_tag__tag__in=str(query).split(\\\",\\\"))\\n ), Q.OR)\\n\\n if query.isnumeric():\\n q_object.add(\\n Q(level__icontains=int(query)), Q.OR)\\n\\n q_object.add(Q(status=strtobool(query)), Q.OR) if query in [\\n \\\"true\\\", \\\"True\\\", \\\"False\\\", \\\"false\\\"] else None\\n\\n else:\\n if program_id:\\n q_object.add(\\n Q(program_id=program_id),\\n Q.AND)\\n\\n if category:\\n q_object.add(\\n Q(category=category),\\n Q.AND)\\n if title:\\n q_object.add(\\n Q(title__icontains=title),\\n Q.AND)\\n\\n if description:\\n q_object.add(\\n Q(description__icontains=description), Q.AND)\\n\\n if job_tag:\\n q_object.add(\\n Q(job_tag__tag__in=str(job_tag).split(\\\",\\\")),\\n Q.AND)\\n\\n if level:\\n if level.isnumeric():\\n q_object.add(\\n Q(level__icontains=int(level)),\\n Q.AND)\\n else:\\n raise Exception(\\n ErrorMessage.WRONG_FIELD_TYPE.value.format(\\\"level\\\",\\n \\\"numeric\\\"))\\n\\n q_object.add(Q(status=strtobool(status)), Q.AND) if status in [\\n \\\"true\\\", \\\"True\\\", \\\"False\\\", \\\"false\\\"] else None\\n\\n return q_object\",\n \"def query(params: Params):\\n return service.query(**params.query, n_neighbors=params.n_neighbors)\",\n \"def query(self):\\n return Query(self)\",\n \"def query(self, query, initNs=None, initBindings=None, queryGraph=None, **kwargs):\\n\\n# r_queryType = pattern.search(query).group(\\\"prefixes\\\").upper()\\n# print(r_queryType)\\n uri = self.rest_services[\\\"repository\\\"]\\n infer = kwargs.get('infer',None)\\n #timeout = kwargs.get('timeout',\\\"0\\\")\\n payload = {\\\"$\\\"+k: v.n3() for k,v in initBindings.items()}\\n\\n payload[\\\"infer\\\"] = self.infer if infer is None else infer\\n payload[\\\"infer\\\"] = str(payload[\\\"infer\\\"]).lower()\\n #payload[\\\"$\\\"+timeout]=0\\n payload[\\\"query\\\"] = query\\n r = requests.post(uri, data=payload,\\n stream=True,\\n headers= {\\\"Accept\\\" : \\\"application/sparql-results+json,application/trix\\\",\\n 'connection': 'keep-alive',\\n 'Accept-Encoding': 'gzip,deflate',\\n \\\"Content-Type\\\" :\\\"application/x-www-form-urlencoded\\\"})\\n\\n r.raw.decode_content = True\\n if r.headers['Content-Type'] == 'application/sparql-results+json;charset=UTF-8':\\n return self.__make_result(r)\\n elif r.headers['Content-Type'] == 'application/trix;charset=UTF-8':\\n return self.__make_trix_generator__(r)\\n else:\\n raise ValueError(\\\"Response content type not parsable {r}\\\".format(r=r.text))\",\n \"def dynamiQ(fields, types, values, operator='or'):\\r\\n from django.db.models import Q\\r\\n\\r\\n queries = []\\r\\n q = None\\r\\n for (f, t, v) in zip(fields, types, values):\\r\\n # We only want to build a Q with a value\\r\\n if v != \\\"\\\":\\r\\n kwargs = {str('%s__%s' % (f,t)) : str('%s' % v)}\\r\\n queries.append(Q(**kwargs))\\r\\n\\r\\n # Make sure we have a list of filters\\r\\n if len(queries) > 0:\\r\\n q = Q()\\r\\n # AND/OR awareness\\r\\n for query in queries:\\r\\n if operator == \\\"and\\\":\\r\\n q = q & query\\r\\n elif operator == \\\"or\\\":\\r\\n q = q | query\\r\\n else:\\r\\n q = None\\r\\n\\r\\n return q\",\n \"def model_query(model, *args, **kwargs):\\n with session_for_read() as session:\\n query = session.query(model, *args)\\n return query\",\n \"def query(querystring: str,\\n db: tsdb.Database,\\n **kwargs):\\n queryobj = _parse_query(querystring)\\n\\n if queryobj['type'] in ('select', 'retrieve'):\\n return _select(\\n queryobj['projection'],\\n queryobj['relations'],\\n queryobj['condition'],\\n db,\\n record_class=kwargs.get('record_class', None))\\n else:\\n # not really a syntax error; replace with TSQLError or something\\n # when the proper exception class exists\\n raise TSQLSyntaxError(queryobj['type'] + ' queries are not supported',\\n text=querystring)\",\n \"def get_query(params, filters):\\n engine, session = connect_to_db(DB_NAME, CORE_DIR)\\n\\n q = session.query(*params) # kick off the query\\n\\n classes = []\\n for p in params:\\n parent_class = p.parent.class_\\n classes.append(parent_class) if parent_class not in classes else None # need order, so hack around a set...\\n\\n\\n base = classes.pop(0) # grab first class from list\\n linked = [base] # the first class is inherently already in the join-chain\\n\\n if classes: # any more classes?\\n for c in classes:\\n relations_for_c = relations.get(c.__name__)\\n\\n if not relations_for_c:\\n msg = f'{c.__name__} does not have any defined relationships.'\\n raise NotImplementedError(msg)\\n\\n relation = relations_for_c.get(base.__name__)\\n\\n if relation:\\n q = q.join(c, relation.key == relation.fkey)\\n else:\\n msg = f'{c.__name__} is not directly related to {base} in the schema.'\\n raise NotImplementedError(msg)\\n\\n for f in filters:\\n q = q.filter(f)\\n\\n return q.all()[:10]\",\n \"def query(engine: sa.engine, query_params: Dict[str, Any]) -> sa.engine.ResultProxy:\\r\\n with engine.connect() as con:\\r\\n attr_col = [query_params[Toml.ATTR]]\\r\\n cols = [sa.Column(x) for x in attr_col + query_params[Toml.COLUMNS]]\\r\\n table = query_params[Toml.TABLE]\\r\\n s = sa.select(cols)\\r\\n s.append_from(sa.text(table))\\r\\n s.append_whereclause(sa.text(query_params[Toml.EXCLUDE_BY] + ' not in :exclude')\\r\\n .bindparams(sa.bindparam('exclude', expanding=True)))\\r\\n return con.execute(s, {\\r\\n 'exclude': query_params[Toml.EXCLUDE]\\r\\n })\",\n \"def album_filter(query_params, query):\\n table = Album.__table__\\n col_name = table.c.release_date\\n if query_params.get('start_year') is not None \\\\\\n and query_params.get('end_year') is not None:\\n filt_statement = and_(\\n col_name >= date(int(query_params.get('start_year')), 1, 1),\\n col_name <= date(int(query_params.get('end_year')), 12, 31))\\n query = query.filter(filt_statement)\\n elif query_params.get('start_year') is not None:\\n query = query.filter(\\n col_name >= date(int(query_params.get('start_year')), 1, 1))\\n elif query_params.get('end_year') is not None:\\n query = query.filter(\\n col_name <= date(int(query_params.get('end_year')), 12, 31))\\n if query_params.get('num_tracks') is not None:\\n query = query.filter(\\n table.c.num_tracks == int(query_params.get('num_tracks')))\\n if query_params.get('label') is not None:\\n query = query.filter(table.c.label == str(query_params.get('label')))\\n return query\",\n \"def qry(cls, name=None, username=None, email=None, \\\\\\n active=None, admin=None,\\n permissions=None, verified=None,\\n location=None, **kwargs):\\n #qry = cls.query(**kwargs)\\n qry = model.Base.qry(model.User,**kwargs)\\n if name:\\n qry = qry.filter(cls.name==name)\\n if username:\\n qry = qry.filter(cls.username==username)\\n if email:\\n qry = qry.filter(cls.email==email)\\n if active:\\n qry = qry.filter(cls.active==active)\\n if admin:\\n qry = qry.filter(cls.admin==admin)\\n if permissions:\\n qry = qry.filter(cls.permissions==permissions)\\n if verified:\\n qry = qry.filter(cls.verified==verified)\\n if location:\\n qry = qry.filter(cls.location==location)\\n #else filter for private True and False\\n return qry\",\n \"def knowledge_query():\\n params = flask.request.get_json()\\n if params is None or 'sql' not in params:\\n return flask.jsonify({'error': 'No SQL specified in request'})\\n else:\\n knowledge_store = KnowledgeStore(settings['FLATMAP_ROOT'], create=False, read_only=True)\\n result = knowledge_store.query(params.get('sql'), params.get('params', []))\\n knowledge_store.close()\\n if 'error' in result:\\n app.logger.warning('SQL: {}'.format(result['error']))\\n return flask.jsonify(result)\",\n \"def query(self):\\r\\n raise NotImplementedError\",\n \"def filter(self, **kwargs):\\n kwargs['query'] += ' FROM {0}'\\n return kwargs\",\n \"def query_graphql(raw_query, endpoint):\\n query = \\\" \\\".join(shlex.split(raw_query, posix=False))\\n r = requests.get(endpoint, params={\\\"query\\\": query})\\n if r.status_code == 200:\\n return r.json()\\n elif r.status_code == 400:\\n response = r.json()\\n assert \\\"errors\\\" in response\\n raise GraphQLError(\\\"\\\".join([e[\\\"message\\\"] for e in response[\\\"errors\\\"]]))\\n else:\\n raise requests.exceptions.RequestException(\\n f\\\"HTTP Status: {r.status_code}, Response Body: {r.text}\\\"\\n )\",\n \"def query(self, **kwargs):\\n\\n return query.query(self._host, self._session, **kwargs)\",\n \"def create_query(self, keywords=None, servicetype=None, \\n waveband=None, sqlpred=None):\\n srch = RegistryQuery(self._baseurl)\\n if sqlpred:\\n srch.addpredicate(sqlpred)\\n if waveband:\\n srch.waveband = waveband\\n if servicetype:\\n srch.servicetype = servicetype\\n if keywords:\\n srch.addkeywords(keywords)\\n return srch\",\n \"def gen_query(self, criteria, target_id, for_stats=False):\\n query = self.db.session.query(models.Url).filter_by(target_id=target_id)\\n # Check if criteria is url search\\n if criteria.get('search', None):\\n if criteria.get('url', None):\\n if isinstance(criteria.get('url'), list):\\n criteria['url'] = criteria['url'][0]\\n query = query.filter(models.Url.url.like('%%%s%%' % criteria['url']))\\n else: # If not search\\n if criteria.get('url', None):\\n if isinstance(criteria.get('url'), str):\\n query = query.filter_by(url=criteria['url'])\\n if isinstance(criteria.get('url'), list):\\n query = query.filter(models.Url.url.in_(criteria['url']))\\n # For the following section doesn't matter if filter/search because\\n # it doesn't make sense to search in a boolean column :P\\n if criteria.get('visited', None):\\n if isinstance(criteria.get('visited'), list):\\n criteria['visited'] = criteria['visited'][0]\\n query = query.filter_by(visited=self.config.ConvertStrToBool(criteria['visited']))\\n if criteria.get('scope', None):\\n if isinstance(criteria.get('scope'), list):\\n criteria['scope'] = criteria['scope'][0]\\n query = query.filter_by(scope=self.config.ConvertStrToBool(criteria['scope']))\\n if not for_stats: # Query for stats can't have limit and offset\\n try:\\n if criteria.get('offset', None):\\n if isinstance(criteria.get('offset'), list):\\n criteria['offset'] = criteria['offset'][0]\\n query = query.offset(int(criteria['offset']))\\n if criteria.get('limit', None):\\n if isinstance(criteria.get('limit'), list):\\n criteria['limit'] = criteria['limit'][0]\\n query = query.limit(int(criteria['limit']))\\n except ValueError:\\n raise InvalidParameterType(\\\"Invalid parameter type for transaction db\\\")\\n return query\",\n \"def sql(self, q):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/{1}'.format(self.get_url(), 'sql')\\r\\n\\r\\n return http.Request('POST', url, params), parsers.parse_json\",\n \"def query(self, params):\\n if not isinstance(params, dict) or not params:\\n raise BadRequest('Non-empty dictionary is expected')\\n\\n url = self._dbname + '/_query'\\n return self._connection.get(url, params).json()\",\n \"def query(self, query):\",\n \"def where(**kwargs):\\n return QueryBuilder(Card).where(**kwargs)\",\n \"def CreateQuery(self, pathInfo, opts, httpConfig, limit=None):\\n\\n web.debug(\\\"QueryFactory.CreateQuery\\\")\\n web.debug(\\\"QueryFactory.CreateQuery: pathInfo = %s\\\" % pathInfo)\\n web.debug(\\\"QueryFactory.CreateQuery: opts = %s\\\" % opts)\\n web.debug(\\\"QueryFactory.CreateQuery: limit = %s\\\" % limit)\\n\\n query = None\\n if pathInfo == \\\"/initiatives\\\":\\n query = InitiativeQuery(opts, httpConfig)\\n elif pathInfo == \\\"/frameworks\\\":\\n query = FrameworkQuery(opts, httpConfig)\\n elif pathInfo == \\\"/sets\\\":\\n query = SetQuery(opts, httpConfig)\\n elif pathInfo == \\\"/grade_levels\\\":\\n query = GradeQuery(opts, httpConfig)\\n elif pathInfo == \\\"/competency_containers\\\":\\n query = ContainerQuery(opts, httpConfig)\\n elif pathInfo == \\\"/competencys\\\":\\n query = CompetencyQuery(opts, httpConfig)\\n elif pathInfo == \\\"/domains\\\":\\n query = DomainQuery(opts, httpConfig)\\n elif pathInfo == \\\"/clusters\\\":\\n query = ClusterQuery(opts, httpConfig)\\n elif pathInfo == \\\"/standards\\\":\\n query = StandardQuery(opts, httpConfig)\\n elif pathInfo == \\\"/standard_components\\\":\\n query = ComponentQuery(opts, httpConfig)\\n\\n elif pathInfo == \\\"/strands\\\":\\n query = StrandQuery(opts, httpConfig)\\n elif pathInfo == \\\"/anchor_standards\\\":\\n query = AnchorQuery(opts, httpConfig)\\n elif pathInfo == \\\"/anchor_standard_sections\\\":\\n query = SectionQuery(opts, httpConfig)\\n\\n elif pathInfo in [\\\"/competency_paths\\\", \\\"/competency_path/\\\"]:\\n query = PathQuery(opts, httpConfig)\\n elif pathInfo in [\\\"/learning_resources\\\", \\\"/learning_resource/\\\"]:\\n query = ResourceQuery(opts, httpConfig)\\n\\n\\n elif pathInfo.find(\\\"/property_names\\\") != -1:\\n # Get singular type name\\n lriType = pathInfo.split(\\\"/property_names\\\")[0].strip(\\\"/\\\").rstrip(\\\"s\\\")\\n query = PropertyQuery(lriType, opts, httpConfig)\\n\\n if limit is not None:\\n query.setLimit(limit)\\n\\n #web.debug(\\\"QueryFactory.CreateQuery: query = %r\\\" % query)\\n return query\",\n \"def _getQuery(self, request):\\n q = Conference.query()\\n inequality_filter, filters = self._formatFilters(request.filters)\\n # If exists, sort on inequality filter first\\n if not inequality_filter:\\n q = q.order(Conference.name)\\n else:\\n q = q.order(ndb.GenericProperty(inequality_filter))\\n q = q.order(Conference.name)\\n for filtr in filters:\\n if filtr[\\\"field\\\"] in [\\\"month\\\", \\\"maxAttendees\\\"]:\\n try:\\n filtr[\\\"value\\\"] = int(filtr[\\\"value\\\"])\\n except ValueError:\\n raise endpoints.BadRequestException(\\n \\\"Non-integer in integer field.\\\")\\n formatted_query = ndb.query.FilterNode(\\n filtr[\\\"field\\\"], filtr[\\\"operator\\\"], filtr[\\\"value\\\"])\\n q = q.filter(formatted_query)\\n return q\",\n \"def query(output, query):\\n gqlapi = gql.get_api()\\n print_output(output, gqlapi.query(query))\",\n \"def __init__(\\n self,\\n kind=None,\\n project=None,\\n namespace=None,\\n ancestor=None,\\n filters=(),\\n projection=(),\\n order=(),\\n distinct_on=(),\\n limit=None):\\n self.kind = kind\\n self.project = project\\n self.namespace = namespace\\n self.ancestor = ancestor\\n self.filters = filters or ()\\n self.projection = projection\\n self.order = order\\n self.distinct_on = distinct_on\\n self.limit = limit\",\n \"def _find(self, cls, data_source, **attr):\\n sub_query = \\\"\\\"\\\"select from {} where \\\"\\\"\\\".format(cls) + \\\\\\n \\\" and \\\".join([\\\"\\\"\\\"{} = {}\\\"\\\"\\\".format(\\n key, \\\"\\\"\\\"\\\\\\\"{}\\\\\\\"\\\"\\\"\\\".format(value) if isinstance(value, str) else value) \\\\\\n for key, value in attr.items() if value is not None])\\n if data_source is None:\\n q = self.sql_query(sub_query)\\n else:\\n q = self.sql_query(\\n \\\"\\\"\\\" select from ({sub_query}) \\\\\\n let $q = (select from (select expand($parent.$parent.current.in('Owns')))\\n where @class='DataSource' and @rid = {rid}) \\\\\\n where $q.size() = 1\\\"\\\"\\\".format(sub_query = sub_query, rid = data_source._id))\\n return q\",\n \"def get_queryset(self):\\n queryset = Food.objects.all()\\n name = self.request.query_params.get('name', None)\\n ndb_no = self.request.query_params.get('ndb_no', None)\\n if name is not None:\\n queryset = queryset.filter(name=name)\\n elif ndb_no is not None:\\n queryset = queryset.filter(ndb_no=ndb_no)\\n return queryset\",\n \"def make_complex_query_set(self):\\n\\n query = self.request.GET.get(\\\"q\\\")\\n category = self.request.GET.get(\\\"category\\\")\\n title = self.request.GET.get(\\\"title\\\")\\n\\n q_object = Q()\\n\\n if query:\\n q_object.add((\\n Q(category__category_name__icontains=query) |\\n Q(title__icontains=query) \\n ), Q.OR)\\n\\n else:\\n if category:\\n q_object.add(\\n Q(category=category),\\n Q.AND)\\n if title:\\n q_object.add(\\n Q(title__icontains=title),\\n Q.AND)\\n\\n return q_object\",\n \"def model_query(model, *args, **kwargs):\\n\\n with _session_for_read() as session:\\n query = session.query(model, *args)\\n return query\",\n \"def search(datatype=None, dataType=None, pageSize=None, page=None):\\n\\n # create the full list of all calls implemented.\\n data = [\\n calls_get_helper('calls'),\\n calls_get_helper('commoncropnames'),\\n calls_get_helper('crops'),\\n calls_get_helper('germplasm', versions=VERSIONS_LATEST),\\n calls_get_helper('locations'),\\n calls_get_helper('locations/{locationDbId}'),\\n calls_get_helper('observationunits', versions=VERSIONS_LATEST),\\n calls_get_helper('phenotypes-search', versions=VERSIONS_1_2),\\n calls_get_helper('programs'),\\n calls_get_helper('seasons'),\\n calls_get_helper('studies'),\\n calls_get_helper('studies/{studyDbId}'),\\n calls_get_helper('studies/{studyDbId}/germplasm'),\\n calls_get_helper('studies/{studyDbId}/layouts'),\\n calls_get_helper('trials')\\n ]\\n\\n # filter on datatype\\n if dataType:\\n data = [d for d in data if dataType in d['dataTypes']]\\n elif datatype:\\n data = [d for d in data if datatype in d['dataTypes']]\\n\\n # total number of rows\\n count = len(data)\\n\\n # add a limit\\n if not pageSize:\\n pageSize = len(data)\\n if not page:\\n page = 0\\n data = data[page * pageSize:(page + 1) * pageSize]\\n\\n # return the resulting data\\n return helper.create_result({\\\"data\\\": data}, count, pageSize, page)\",\n \"def smart_query(collection, condition):\\r\\n smart_condition = list()\\r\\n for condition_key, condition_value in condition.iteritems():\\r\\n if isinstance(condition_value, dict):\\r\\n # We do not optimize complicate conditions.\\r\\n smart_condition.append({condition_key: condition_value})\\r\\n else:\\r\\n smart_condition.append({\\\"$or\\\": [\\r\\n {condition_key: condition_value},\\r\\n {condition_key: None},\\r\\n {condition_key: {\\\"$exists\\\": False}}\\r\\n ]})\\r\\n query_condition = {\\\"$and\\\": smart_condition}\\r\\n debug.print_as_json(query_condition)\\r\\n return query(collection, query_condition)\",\n \"def get_raw_query(self):\\n # create a raw query\\n if len(self.criteria) > 1:\\n # more than one criteria, create a AND query\\n raw_query = {\\\"$and\\\": self.criteria}\\n else:\\n # one criteria, raw query is the criteria\\n raw_query = self.criteria[0]\\n\\n return raw_query\",\n \"def api_query(self, **kwargs):\\n with self._api_lock:\\n return self._api_query(kwargs)\",\n \"def index( self, trans, **kwd ):\\n # Example URL: http://localhost:9009/api/repository_revisions\\n repository_metadata_dicts = []\\n # Build up an anded clause list of filters.\\n clause_list = []\\n # Filter by downloadable if received.\\n downloadable = kwd.get( 'downloadable', None )\\n if downloadable is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.downloadable == util.string_as_bool( downloadable ) )\\n # Filter by malicious if received.\\n malicious = kwd.get( 'malicious', None )\\n if malicious is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.malicious == util.string_as_bool( malicious ) )\\n # Filter by tools_functionally_correct if received.\\n tools_functionally_correct = kwd.get( 'tools_functionally_correct', None )\\n if tools_functionally_correct is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.tools_functionally_correct == util.string_as_bool( tools_functionally_correct ) )\\n # Filter by missing_test_components if received.\\n missing_test_components = kwd.get( 'missing_test_components', None )\\n if missing_test_components is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.missing_test_components == util.string_as_bool( missing_test_components ) )\\n # Filter by do_not_test if received.\\n do_not_test = kwd.get( 'do_not_test', None )\\n if do_not_test is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.do_not_test == util.string_as_bool( do_not_test ) )\\n # Filter by includes_tools if received.\\n includes_tools = kwd.get( 'includes_tools', None )\\n if includes_tools is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.includes_tools == util.string_as_bool( includes_tools ) )\\n # Filter by test_install_error if received.\\n test_install_error = kwd.get( 'test_install_error', None )\\n if test_install_error is not None:\\n clause_list.append( trans.model.RepositoryMetadata.table.c.test_install_error == util.string_as_bool( test_install_error ) )\\n # Filter by skip_tool_test if received.\\n skip_tool_test = kwd.get( 'skip_tool_test', None )\\n if skip_tool_test is not None:\\n skip_tool_test = util.string_as_bool( skip_tool_test )\\n skipped_metadata_ids_subquery = select( [ trans.app.model.SkipToolTest.table.c.repository_metadata_id ] )\\n if skip_tool_test:\\n clause_list.append( trans.model.RepositoryMetadata.id.in_( skipped_metadata_ids_subquery ) )\\n else:\\n clause_list.append( not_( trans.model.RepositoryMetadata.id.in_( skipped_metadata_ids_subquery ) ) )\\n # Generate and execute the query.\\n try:\\n query = trans.sa_session.query( trans.app.model.RepositoryMetadata ) \\\\\\n .filter( and_( *clause_list ) ) \\\\\\n .order_by( trans.app.model.RepositoryMetadata.table.c.repository_id ) \\\\\\n .all()\\n for repository_metadata in query:\\n repository_metadata_dict = repository_metadata.get_api_value( view='collection',\\n value_mapper=default_value_mapper( trans, repository_metadata ) )\\n repository_metadata_dict[ 'url' ] = web.url_for( controller='repository_revisions',\\n action='show',\\n id=trans.security.encode_id( repository_metadata.id ) )\\n repository_metadata_dicts.append( repository_metadata_dict )\\n return repository_metadata_dicts\\n except Exception, e:\\n message = \\\"Error in the Tool Shed repository_revisions API in index: \\\" + str( e )\\n log.error( message, exc_info=True )\\n trans.response.status = 500\\n return message\",\n \"def query(self, *, sparql: str) -> Result:\\n pass\",\n \"def perform_query(index_node, query_type):\\n\\n when = now()\\n\\n resp = do_query(index_node.name,\\n [filter.value for filter in query_type.filters.all()],\\n [facet.name for facet in query_type.facets.all()])\\n\\n client, _ = Host.objects.get_or_create(name=gethostname())\\n \\n response = Response.objects.create(\\n index_node=index_node,\\n status_code=resp['status_code'],\\n datetime=when,\\n client=client,\\n query_type=query_type)\\n\\n if response.status_code == 200:\\n \\n response_data = ResponseData.objects.create(\\n num_found=resp['num_found']\\n )\\n for facet_name, counts in resp['facet_counts'].items():\\n for value, count in counts.items():\\n facet, _ = Facet.objects.get_or_create(name=facet_name)\\n facet_value, _ = \\\\\\n FacetValue.objects.get_or_create(facet=facet,\\n value=value)\\n facet_value_count = \\\\\\n FacetValueCount.objects.create(count=count,\\n facet_value=facet_value,\\n response_data=response_data)\\n response.data = response_data\\n response.save()\",\n \"def test_query_generic_embedded_document(self):\\n\\n class A(EmbeddedDocument):\\n a_name = StringField()\\n\\n class B(EmbeddedDocument):\\n b_name = StringField()\\n\\n class Doc(Document):\\n document = GenericEmbeddedDocumentField(choices=(A, B))\\n\\n Doc.drop_collection()\\n Doc(document=A(a_name=\\\"A doc\\\")).save()\\n Doc(document=B(b_name=\\\"B doc\\\")).save()\\n\\n # Using raw in filter working fine\\n assert Doc.objects(__raw__={\\\"document.a_name\\\": \\\"A doc\\\"}).count() == 1\\n assert Doc.objects(__raw__={\\\"document.b_name\\\": \\\"B doc\\\"}).count() == 1\\n assert Doc.objects(document__a_name=\\\"A doc\\\").count() == 1\\n assert Doc.objects(document__b_name=\\\"B doc\\\").count() == 1\",\n \"def _build_filter_part(self, cls, filters, order_by=None, select=None):\\r\\n import types\\r\\n query_parts = []\\r\\n\\r\\n order_by_filtered = False\\r\\n\\r\\n if order_by:\\r\\n if order_by[0] == \\\"-\\\":\\r\\n order_by_method = \\\"DESC\\\";\\r\\n order_by = order_by[1:]\\r\\n else:\\r\\n order_by_method = \\\"ASC\\\";\\r\\n\\r\\n if select:\\r\\n if order_by and order_by in select:\\r\\n order_by_filtered = True\\r\\n query_parts.append(\\\"(%s)\\\" % select)\\r\\n\\r\\n if isinstance(filters, str) or isinstance(filters, unicode):\\r\\n query = \\\"WHERE %s AND `__type__` = '%s'\\\" % (filters, cls.__name__)\\r\\n if order_by in [\\\"__id__\\\", \\\"itemName()\\\"]:\\r\\n query += \\\" ORDER BY itemName() %s\\\" % order_by_method\\r\\n elif order_by != None:\\r\\n query += \\\" ORDER BY `%s` %s\\\" % (order_by, order_by_method)\\r\\n return query\\r\\n\\r\\n for filter in filters:\\r\\n filter_parts = []\\r\\n filter_props = filter[0]\\r\\n if type(filter_props) != list:\\r\\n filter_props = [filter_props]\\r\\n for filter_prop in filter_props:\\r\\n (name, op) = filter_prop.strip().split(\\\" \\\", 1)\\r\\n value = filter[1]\\r\\n property = cls.find_property(name)\\r\\n if name == order_by:\\r\\n order_by_filtered = True\\r\\n if types.TypeType(value) == types.ListType:\\r\\n filter_parts_sub = []\\r\\n for val in value:\\r\\n val = self.encode_value(property, val)\\r\\n if isinstance(val, list):\\r\\n for v in val:\\r\\n filter_parts_sub.append(self._build_filter(property, name, op, v))\\r\\n else:\\r\\n filter_parts_sub.append(self._build_filter(property, name, op, val))\\r\\n filter_parts.append(\\\"(%s)\\\" % (\\\" OR \\\".join(filter_parts_sub)))\\r\\n else:\\r\\n val = self.encode_value(property, value)\\r\\n if isinstance(val, list):\\r\\n for v in val:\\r\\n filter_parts.append(self._build_filter(property, name, op, v))\\r\\n else:\\r\\n filter_parts.append(self._build_filter(property, name, op, val))\\r\\n query_parts.append(\\\"(%s)\\\" % (\\\" or \\\".join(filter_parts)))\\r\\n\\r\\n\\r\\n type_query = \\\"(`__type__` = '%s'\\\" % cls.__name__\\r\\n for subclass in self._get_all_decendents(cls).keys():\\r\\n type_query += \\\" or `__type__` = '%s'\\\" % subclass\\r\\n type_query +=\\\")\\\"\\r\\n query_parts.append(type_query)\\r\\n\\r\\n order_by_query = \\\"\\\"\\r\\n\\r\\n if order_by:\\r\\n if not order_by_filtered:\\r\\n query_parts.append(\\\"`%s` LIKE '%%'\\\" % order_by)\\r\\n if order_by in [\\\"__id__\\\", \\\"itemName()\\\"]:\\r\\n order_by_query = \\\" ORDER BY itemName() %s\\\" % order_by_method\\r\\n else:\\r\\n order_by_query = \\\" ORDER BY `%s` %s\\\" % (order_by, order_by_method)\\r\\n\\r\\n if len(query_parts) > 0:\\r\\n return \\\"WHERE %s %s\\\" % (\\\" AND \\\".join(query_parts), order_by_query)\\r\\n else:\\r\\n return \\\"\\\"\",\n \"def query(self,\\n query: str,\\n datatype: str = \\\"response\\\",\\n page: int = 0,\\n indices: str = \\\"\\\") -> dict:\\n endpoint = \\\"/api/responses/\\\"\\n if datatype == \\\"cert\\\":\\n endpoint = \\\"/api/certs/\\\"\\n elif datatype == \\\"domain\\\":\\n endpoint = \\\"/api/domains/\\\"\\n ret = self._request(\\n endpoint=endpoint,\\n params={\\n \\\"q\\\": query,\\n \\\"indices\\\": indices,\\n \\\"start\\\": page * 20,\\n },\\n )\\n return ret\",\n \"def get_query(id: Optional[str] = None,\\n query_pack_name: Optional[str] = None,\\n resource_group_name: Optional[str] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetQueryResult:\\n __args__ = dict()\\n __args__['id'] = id\\n __args__['queryPackName'] = query_pack_name\\n __args__['resourceGroupName'] = resource_group_name\\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\\n __ret__ = pulumi.runtime.invoke('azure-native:operationalinsights/v20190901:getQuery', __args__, opts=opts, typ=GetQueryResult).value\\n\\n return AwaitableGetQueryResult(\\n author=pulumi.get(__ret__, 'author'),\\n body=pulumi.get(__ret__, 'body'),\\n description=pulumi.get(__ret__, 'description'),\\n display_name=pulumi.get(__ret__, 'display_name'),\\n id=pulumi.get(__ret__, 'id'),\\n name=pulumi.get(__ret__, 'name'),\\n properties=pulumi.get(__ret__, 'properties'),\\n related=pulumi.get(__ret__, 'related'),\\n system_data=pulumi.get(__ret__, 'system_data'),\\n tags=pulumi.get(__ret__, 'tags'),\\n time_created=pulumi.get(__ret__, 'time_created'),\\n time_modified=pulumi.get(__ret__, 'time_modified'),\\n type=pulumi.get(__ret__, 'type'))\",\n \"def _get_query(self) -> 'Query':\\n subquery = graphene_sqlalchemy.get_query(self.model, self.info.context)\\n\\n request_filters = self.graphql_args.get(self.filter_arg)\\n if request_filters:\\n filter_set = self._get_filter_set(self.info)\\n subquery = filter_set.filter(self.info, subquery, request_filters)\\n\\n aliased_model = aliased(\\n self.model, subquery.subquery(with_labels=True)\\n )\\n\\n query = (\\n graphene_sqlalchemy.get_query(self.parent_model, self.info.context)\\n .join(aliased_model, self.relation)\\n .options(\\n contains_eager(self.relation, alias=aliased_model),\\n Load(self.parent_model).load_only(*self.parent_model_pks),\\n )\\n )\\n query = self._sorted_query(\\n query, self.graphql_args.get('sort'), aliased_model\\n )\\n return query\",\n \"def ng_query(self, request, *args, **kwargs):\\r\\n return self.build_json_response(self.get_queryset())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74351525","0.65386915","0.6099638","0.6088493","0.60041225","0.5947028","0.5898798","0.5851256","0.5801757","0.5797533","0.5785968","0.57396966","0.57052547","0.5698724","0.56677943","0.5620565","0.55979","0.5590759","0.558977","0.5579419","0.55156595","0.5474221","0.5430953","0.5422154","0.5406055","0.54020685","0.5389638","0.5389638","0.5381821","0.5379857","0.53625387","0.5361918","0.53498816","0.53498816","0.534303","0.5339625","0.53125167","0.5290986","0.5283155","0.5280502","0.5275785","0.52706","0.5256749","0.5247265","0.5240466","0.52300054","0.52233464","0.5189009","0.51724434","0.51724434","0.5168759","0.5162714","0.51570237","0.51477695","0.5142684","0.5115832","0.51094","0.5098886","0.5093185","0.5092978","0.5087462","0.50861984","0.50860775","0.5074683","0.50695145","0.50625706","0.5061672","0.50610304","0.5059946","0.5057306","0.50467116","0.5043552","0.50390404","0.50286007","0.50272036","0.5021506","0.5019417","0.50105375","0.50050294","0.5003444","0.50031066","0.4993394","0.49891013","0.49868113","0.4986264","0.4981522","0.4970607","0.49684188","0.49549738","0.49513227","0.4950514","0.49499717","0.4949345","0.49478984","0.49450764","0.49430755","0.49405786","0.493494","0.49330297","0.4932182"],"string":"[\n \"0.74351525\",\n \"0.65386915\",\n \"0.6099638\",\n \"0.6088493\",\n \"0.60041225\",\n \"0.5947028\",\n \"0.5898798\",\n \"0.5851256\",\n \"0.5801757\",\n \"0.5797533\",\n \"0.5785968\",\n \"0.57396966\",\n \"0.57052547\",\n \"0.5698724\",\n \"0.56677943\",\n \"0.5620565\",\n \"0.55979\",\n \"0.5590759\",\n \"0.558977\",\n \"0.5579419\",\n \"0.55156595\",\n \"0.5474221\",\n \"0.5430953\",\n \"0.5422154\",\n \"0.5406055\",\n \"0.54020685\",\n \"0.5389638\",\n \"0.5389638\",\n \"0.5381821\",\n \"0.5379857\",\n \"0.53625387\",\n \"0.5361918\",\n \"0.53498816\",\n \"0.53498816\",\n \"0.534303\",\n \"0.5339625\",\n \"0.53125167\",\n \"0.5290986\",\n \"0.5283155\",\n \"0.5280502\",\n \"0.5275785\",\n \"0.52706\",\n \"0.5256749\",\n \"0.5247265\",\n \"0.5240466\",\n \"0.52300054\",\n \"0.52233464\",\n \"0.5189009\",\n \"0.51724434\",\n \"0.51724434\",\n \"0.5168759\",\n \"0.5162714\",\n \"0.51570237\",\n \"0.51477695\",\n \"0.5142684\",\n \"0.5115832\",\n \"0.51094\",\n \"0.5098886\",\n \"0.5093185\",\n \"0.5092978\",\n \"0.5087462\",\n \"0.50861984\",\n \"0.50860775\",\n \"0.5074683\",\n \"0.50695145\",\n \"0.50625706\",\n \"0.5061672\",\n \"0.50610304\",\n \"0.5059946\",\n \"0.5057306\",\n \"0.50467116\",\n \"0.5043552\",\n \"0.50390404\",\n \"0.50286007\",\n \"0.50272036\",\n \"0.5021506\",\n \"0.5019417\",\n \"0.50105375\",\n \"0.50050294\",\n \"0.5003444\",\n \"0.50031066\",\n \"0.4993394\",\n \"0.49891013\",\n \"0.49868113\",\n \"0.4986264\",\n \"0.4981522\",\n \"0.4970607\",\n \"0.49684188\",\n \"0.49549738\",\n \"0.49513227\",\n \"0.4950514\",\n \"0.49499717\",\n \"0.4949345\",\n \"0.49478984\",\n \"0.49450764\",\n \"0.49430755\",\n \"0.49405786\",\n \"0.493494\",\n \"0.49330297\",\n \"0.4932182\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60751003"},"document_rank":{"kind":"string","value":"4"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":243,"numItemsPerPage":100,"numTotalItems":95772,"offset":24300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MTA0MzU4NCwianRpIjoiNTNiZWU0ZDktOTQ3NS00NzdiLTg4ZGQtNGNiYWRlMmVmMTczIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTEwNDcxODQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.EDDcCcr6khgtKDdvv99oENeAmvvFVHJ5H1JSc9wPbKKYePifFX2g_8jFOoFoqC_EkWsu4x2Pge6wJjSuEEwzAw","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 |
|---|---|---|---|---|---|---|
Build new_events This factory method is actually the events factory. | def build_events(self) -> list:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_new_event(self):\n pass",
"def handle_new_events(self, events):\n for event in events:\n self.events.append(\n self.create_event_object(\n event[0],\n event[1],\n int(event[2])))",
"def create_event(self... | [
"0.7068018",
"0.6923349",
"0.6733583",
"0.6481142",
"0.6407484",
"0.63098305",
"0.6274381",
"0.62523794",
"0.61910576",
"0.61229914",
"0.601929",
"0.6007083",
"0.6007083",
"0.6007083",
"0.60045576",
"0.597696",
"0.595828",
"0.593561",
"0.5929939",
"0.5923887",
"0.5875728",
... | 0.6995154 | 1 |
Collecting new events and push them into the events buffer | def collect_new_events(self) -> list:
self.logger.debug('Collecting new events...')
events = self.build_events()
if not events:
self.logger.debug('No new events.')
for event in events:
self.logger.info('A new event has been detected: {}'.format(event))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_events(self):\n while 1:\n try:\n self.events_local.append(self._q.get(False))\n except queue.Empty:\n break",
"def slurp_events(self):\n while self.has_event():\n self.get_event()",
"def _store_events(self, c, e):\n ... | [
"0.7208618",
"0.69300455",
"0.67458445",
"0.6702277",
"0.64130634",
"0.6407206",
"0.6382773",
"0.63692826",
"0.6364064",
"0.6345537",
"0.6214517",
"0.6210405",
"0.61788917",
"0.61758673",
"0.6163426",
"0.6151569",
"0.6115069",
"0.6052047",
"0.6035892",
"0.6028083",
"0.6023511... | 0.81267637 | 0 |
Return the first event in the events buffer. if the events buffer is empty, return None. | def pull_event(self):
self._buffer_buisy_mutex.acquire()
event = None
if self._events_buffer:
event = self._events_buffer.pop(0)
self._dilivered_events_stack.push(event.hash)
self._buffer_buisy_mutex.release()
if event:
self.logger.info('Pullin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next(self):\r\n ready = select.select([self.filehandle],[ ], [ ], 0)[0]\r\n if ready:\r\n s = os.read(self.filehandle, Format.EventSize)\r\n if s:\r\n event = EventStruct.EventStruct(self)\r\n event.decode(s)\r\n return event\r\n\r\n return None",
"def get_event(self):... | [
"0.68624073",
"0.675701",
"0.65967983",
"0.64074314",
"0.6368702",
"0.6367154",
"0.6064259",
"0.6038515",
"0.5982681",
"0.5966734",
"0.59468913",
"0.59100795",
"0.58604395",
"0.58548284",
"0.5846003",
"0.58087397",
"0.5797214",
"0.5741647",
"0.568052",
"0.56763804",
"0.567339... | 0.6717159 | 2 |
Collect and store events in infinite loop with interval `_check_for_new_events_interval` | def run(self):
self.logger.info(f'Running {self.__class__.__name__}')
while True:
last_check = time.time()
self.collect_new_events()
while time.time() - last_check < self._check_for_new_events_interval:
self.logger.debug('Waiting for new events collect... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_events(self):\n while 1:\n try:\n self.events_local.append(self._q.get(False))\n except queue.Empty:\n break",
"def collect_new_events(self) -> list:\n self.logger.debug('Collecting new events...')\n events = self.build_events()\n... | [
"0.7514532",
"0.7251609",
"0.69642305",
"0.6617071",
"0.64833236",
"0.6442508",
"0.64266163",
"0.6419499",
"0.62670517",
"0.6204146",
"0.6163505",
"0.6123297",
"0.6066979",
"0.60647124",
"0.6037076",
"0.6023934",
"0.60231",
"0.6019544",
"0.5935497",
"0.591859",
"0.58918107",
... | 0.705858 | 2 |
A factory method that build and return all the scope instances of the endpoint | def collect_all(self) -> list:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scope(self): # noqa: ANN201",
"def scope(self) -> List[Region]:\n return [self]",
"def _construct_endpoints(self):\n # Functions\n async def get_function_list_data(request: web.Request):\n entrypoints = [elm.to_dict() for elm in self._function_manager.definitions.values()]\... | [
"0.5739762",
"0.5559985",
"0.5545814",
"0.5464133",
"0.5434428",
"0.5422983",
"0.536801",
"0.5362967",
"0.5270679",
"0.526368",
"0.522724",
"0.5190502",
"0.5137176",
"0.51323414",
"0.51149523",
"0.5109984",
"0.50831056",
"0.5074194",
"0.5068082",
"0.5059394",
"0.5058056",
"... | 0.0 | -1 |
Return whether the bot is pollable or not | def pollable(self):
return bool(self.ScopeCollector) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_poll(self):\n return self.subscription_list.mode == gnmi_pb2.SubscriptionList.POLL",
"def should_poll(self):\n return self._should_poll",
"def should_poll(self):\n return self.notifier.socket is not None",
"def should_poll(self) -> bool:\n return True",
"def should_po... | [
"0.71498877",
"0.7049278",
"0.70060855",
"0.68412566",
"0.68412566",
"0.68412566",
"0.68330795",
"0.68330795",
"0.68330795",
"0.68330795",
"0.68330795",
"0.68330795",
"0.68330795",
"0.6816082",
"0.6816082",
"0.6816082",
"0.6816082",
"0.6816082",
"0.6816082",
"0.6816082",
"0.6... | 0.634647 | 59 |
Return the conditional tasks of this bot. | def get_conditional_tasks(self, scope: EndpointScope=None):
from nudgebot.tasks import ConditionalTask
conditional_tasks = [task for task in self._tasks if issubclass(task, ConditionalTask)]
if scope:
static_hierarchy = [ps.__class__ for ps in scope.hierarchy]
conditional... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_created_tasks(self):\n tasks = []\n for task_config in get_task_configs(self.context):\n task = task_config.get_created_task(self.context)\n if not task:\n continue\n matched, not_matched = task.start_conditions_status()\n if not not_... | [
"0.651819",
"0.6293233",
"0.62041074",
"0.61520755",
"0.6030803",
"0.60058683",
"0.59421945",
"0.59181774",
"0.58944106",
"0.5864872",
"0.5841039",
"0.57834464",
"0.57781357",
"0.57735986",
"0.5766781",
"0.5705261",
"0.5684001",
"0.5660684",
"0.5619601",
"0.5606973",
"0.56057... | 0.7749001 | 0 |
If the bot is pollable, performing a poll, collecting all the scopes from the scopes collectors, updating statistics and handling tasks. | def poll(self):
if not self.pollable:
self.logger.warning('Poll has been triggered but the bot is not pollable! Return;')
return
self._busy_mutext.acquire()
try:
self.logger.info('Stating poll')
for scope in self.ScopeCollector.collect_all():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def poll(self, ctx, choice=None):\n\n if choice is None or choice.lower() in (\"online\", \"voice\"):\n suggestions = get_suggestions(get_users(ctx, choice))\n\n if suggestions:\n poll_id = create_strawpoll(\"What to play?\", suggestions)\n\n if poll... | [
"0.54762065",
"0.53788805",
"0.53186905",
"0.53170043",
"0.5184612",
"0.5109608",
"0.5096446",
"0.50746995",
"0.50663227",
"0.5019184",
"0.5006015",
"0.4936928",
"0.4913336",
"0.4876137",
"0.48729563",
"0.48675004",
"0.4866862",
"0.48607504",
"0.48592043",
"0.48447618",
"0.48... | 0.8014664 | 0 |
Pulling new events from the event factory, collecting statistics and handling tasks | def handle_events(self):
self._busy_mutext.acquire()
try:
event = self.EventsFactory.pull_event()
while event:
self.logger.debug('Handling new event: {}'.format(event.id))
event_endpoint_scope_classes = event.EndpointScope.get_static_hierarchy()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle_new_events(self, events):\n for event in events:\n self.events.append(\n self.create_event_object(\n event[0],\n event[1],\n int(event[2])))",
"def collect_new_events(self) -> list:\n self.logger.debug('Co... | [
"0.6928928",
"0.66840243",
"0.65027535",
"0.64619464",
"0.6460602",
"0.6405665",
"0.635793",
"0.6357241",
"0.6314258",
"0.62627983",
"0.62376845",
"0.6235711",
"0.62312156",
"0.62292194",
"0.6201306",
"0.61748487",
"0.61748487",
"0.61693776",
"0.61435163",
"0.61425567",
"0.61... | 0.75559413 | 0 |
Run the bot's main loop. Checking each cycle for new events, collecting statistics and handling tasks. | def run(self):
if self.pollable:
self.poll()
if not self.EventsFactory.is_alive():
self.EventsFactory.start()
while True:
if not self.EventsFactory.is_alive():
self.logger.error(f'{self} events factory has died..')
raise SubThre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n self.logger.info(f'Running {self.__class__.__name__}')\n while True:\n last_check = time.time()\n self.collect_new_events()\n while time.time() - last_check < self._check_for_new_events_interval:\n self.logger.debug('Waiting for new eve... | [
"0.7277891",
"0.7167473",
"0.7075082",
"0.6992124",
"0.69774413",
"0.6944734",
"0.6898651",
"0.6894622",
"0.68806136",
"0.6825181",
"0.67936915",
"0.6781551",
"0.6758954",
"0.6758954",
"0.6722563",
"0.67086315",
"0.66868275",
"0.66772085",
"0.6672398",
"0.6656355",
"0.6614758... | 0.0 | -1 |
This returns a json object with the current weather data | def getData(tme=currentTime):
# attempts request 10 times
for attempt in range(10):
try:
# make a request to the url and return it in json format
url = "https://api.darksky.net/forecast/%s/%s,%s,%s?exclude=minutely,hourly,daily,alerts,flags" % (API_KEY, LAT, LNG, tme)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_weather(self):\n with urllib.request.urlopen(self.url) as response:\n json_data = response.read().decode('utf-8')\n\n data = json.loads(json_data)\n\n weather = {}\n weather['current'] = {\n 'temp': round(data['current']['temp_f']),\n 'humidity':... | [
"0.8403848",
"0.79218674",
"0.75721085",
"0.7333801",
"0.73297447",
"0.7300376",
"0.71959585",
"0.7157717",
"0.714969",
"0.71045464",
"0.7076542",
"0.70307815",
"0.69357234",
"0.6829944",
"0.68273324",
"0.68176526",
"0.68121034",
"0.6744426",
"0.6736956",
"0.6727928",
"0.6727... | 0.0 | -1 |
convert temperature to Celsius and round to tenths place always has fahrenheit temperatures from source | def convertTemp(t, convertTo="C"):
# check if target temperature is celcius (metric)
if convertTo == "C":
# returns celcius (metric) temperature
return round(((5 / 9) * (t - 32)), 1)
else:
# returns fahrenheit but rounded
return round(t, 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_f_to_c(temp_in_farenheit): ## ##\n celsiustemp = round((temp_in_farenheit - 32) * 5/9, 1) ##\n return celsiustemp ##",
"def fahr_to_celsius(temp):\n... | [
"0.78028524",
"0.7697944",
"0.7693355",
"0.7597741",
"0.7461831",
"0.7330447",
"0.7304864",
"0.72830915",
"0.72584087",
"0.7248814",
"0.7248472",
"0.72136587",
"0.71933347",
"0.7159759",
"0.7137415",
"0.7072251",
"0.70268846",
"0.7010395",
"0.70004326",
"0.6964403",
"0.692998... | 0.7118849 | 15 |
returns wind direction by converting to cardinal direction | def convertToWindDirection(wb):
if wb >= 0 and wb < 11.25:
return "N"
elif wb >= 11.25 and wb < 33.75:
return "NNE"
elif wb >= 33.75 and wb < 56.25:
return "NE"
elif wb >= 56.25 and wb < 78.75:
return "ENE"
elif wb >= 78.75 and wb < 101.25:
return "E"
elif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wind_direction(self):\n names = ['anc_wind_direction']\n return self.sensor.get_with_fallback('wind_direction', names)",
"def wind_direction(self):\n return self.flow_field.wind_direction",
"async def direction(self, value) -> str:\n if value is None:\n return \"N\"\n... | [
"0.8051601",
"0.772605",
"0.7561617",
"0.6858852",
"0.6829403",
"0.6813727",
"0.6801408",
"0.6787277",
"0.67743737",
"0.6764944",
"0.67020386",
"0.6669546",
"0.66545075",
"0.6628825",
"0.6559923",
"0.65528166",
"0.65011674",
"0.6466648",
"0.64575577",
"0.64373934",
"0.6432996... | 0.74717367 | 3 |
Return feature complexity value | def complexity(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_complexity(self):\n if self.layer_type() == nn.Conv2d:\n return pow(self.layer_type.get_sub_value(\"conv_window_size\"), 2) * self.layer_type.get_sub_value(\n \"out_features\")\n elif self.layer_type() == nn.Linear:\n return self.layer_type.get_sub_value(\... | [
"0.6790964",
"0.66218597",
"0.641455",
"0.6044887",
"0.60209787",
"0.5925947",
"0.591959",
"0.5895237",
"0.58917314",
"0.5765962",
"0.56985533",
"0.567084",
"0.567084",
"0.567084",
"0.567084",
"0.567084",
"0.565596",
"0.564267",
"0.56411445",
"0.5639347",
"0.5630512",
"0.56... | 0.7181252 | 0 |
The value of the feature is the min distance between any object in the extension of c1 and any object on the extension of c2, moving only along redges. | def denotation(self, model):
ext_c1 = model.uncompressed_denotation(self.c1)
ext_c2 = model.uncompressed_denotation(self.c2)
ext_r = model.uncompressed_denotation(self.r)
# (Debugging)
# ec1 = sorted(cache.universe.value(x) for x in cache.uncompress(ext_c1, self.c1.ARITY))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def minimum_distance(object_1, object_2):\n\n # package import\n import numpy as np\n\n # main algorithm\n minimum_distance = 100000\n\n for coord_1 in object_1:\n for coord_2 in object_2:\n distance_btwn_coords = np.linalg.norm(coord_1 - coord_2)\n if distance_btwn_coor... | [
"0.64672554",
"0.6217276",
"0.61850023",
"0.6081567",
"0.606083",
"0.5999995",
"0.5996432",
"0.5954135",
"0.59468925",
"0.5916301",
"0.5907533",
"0.58643496",
"0.58624357",
"0.5848533",
"0.5842086",
"0.5776009",
"0.57662404",
"0.5752642",
"0.57183474",
"0.5716433",
"0.5711440... | 0.0 | -1 |
The value of the feature is f1 < f2 | def denotation(self, model):
ext_f1 = self.f1.denotation(model)
ext_f2 = self.f2.denotation(model)
return ext_f1 < ext_f2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __gt__(self, other):\n return self.__f > other.get_f()",
"def __ge__(self,f2):\n return self > f2 or self == f2",
"def __gt__(self, other):\n return self.x ** 2 + self.y ** 2 > other.x ** 2 + other.y ** 2",
"def threshad(f, f1, f2=None):\n\n if f2 is None: \n y = binary(f1 <=... | [
"0.7495265",
"0.74074596",
"0.73894393",
"0.7220509",
"0.71422136",
"0.7136578",
"0.71185535",
"0.70948553",
"0.70477045",
"0.69834864",
"0.69177634",
"0.686342",
"0.6826311",
"0.6817896",
"0.6801876",
"0.67579144",
"0.6755326",
"0.67524177",
"0.674877",
"0.67084754",
"0.6631... | 0.0 | -1 |
The feature evaluates to true iff the nullary atom is true in the given state | def denotation(self, model):
# return self.atom.extension(cache, state)
return model.primitive_denotation(self.atom) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_true(node):\n return is_scalar_cst(node, True) or is_vector_uniform_cst(node, True)",
"def on_true(self) -> global___Expression:",
"def __bool__(self):\n return len(self._states_) > 0",
"def fullGrid(state):\n return not ((state[:, :, 0] + state[:, :, 1]) == 0).any()",
"def boolean_func... | [
"0.6562623",
"0.65170795",
"0.6263885",
"0.61745733",
"0.6139357",
"0.6104485",
"0.6104217",
"0.60726494",
"0.60725033",
"0.6036591",
"0.60332745",
"0.60322684",
"0.60322684",
"0.6001883",
"0.5990397",
"0.5982798",
"0.5947548",
"0.59247506",
"0.59022444",
"0.58872384",
"0.588... | 0.0 | -1 |
r"""compute amplitude phase error compute amplitude phase error of two complex valued matrix | def ampphaerror(orig, reco):
amp_orig = np.abs(orig)
amp_reco = np.abs(reco)
pha_orig = np.angle(orig)
pha_reco = np.angle(reco)
# print(np.abs(amp_orig - amp_reco))
# print(np.abs(pha_orig - pha_reco))
# print(np.mean(np.abs(amp_orig - amp_reco)))
# print(np.mean(np.abs(pha_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_phase_amplitude_damping_error_noncanonical(self):\n error = phase_amplitude_damping_error(0.25, 0.5, 0.3, canonical_kraus=False)\n circ, p = error.error_term(0)\n self.assertEqual(p, 1, msg=\"Kraus probability\")\n self.assertEqual(circ[0][\"qubits\"], [0])\n self.assert... | [
"0.57301235",
"0.5672069",
"0.5634887",
"0.55991733",
"0.5460378",
"0.5439556",
"0.5384441",
"0.53555703",
"0.53211105",
"0.53139055",
"0.53101045",
"0.5309513",
"0.5285496",
"0.5270891",
"0.5257104",
"0.5252667",
"0.5211097",
"0.5206943",
"0.52064764",
"0.519271",
"0.5184854... | 0.63241947 | 0 |
r"""Mean Squared Error The Mean Squared Error (MSE) is expressed as | def mse(o, r):
return np.mean(np.square((np.abs(o).astype(float) - np.abs(r).astype(float)))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MSE(actual, noisy):\n mean_squared_error(actual, noisy)",
"def MeanSqError(self):\r\n\t\treturn self.mse",
"def compute_MSE(e):\n\n return 1/2*np.mean(e**2)",
"def MeanSquaredError(y_data, y_model):\n\tn = np.size(y_model)\n\tMSE = (1/n)*np.sum((y_data-y_model)**2)\n\n\treturn MSE",
"def mse(ac... | [
"0.8507595",
"0.8144864",
"0.8103423",
"0.8007305",
"0.7935467",
"0.791784",
"0.7868778",
"0.7831256",
"0.7799074",
"0.773619",
"0.7590051",
"0.7585499",
"0.75660074",
"0.7517208",
"0.75151676",
"0.75089014",
"0.75050557",
"0.7480824",
"0.74724436",
"0.74634266",
"0.7453086",... | 0.6980898 | 56 |
Print 6 power 3 | def six_cubed():
print(math.pow(6, 3)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def six_cubed():\n print(math.pow(6,3))",
"def print_pow():\n a = get_inp_pow()\n n = get_inp_pow('power')\n print(a, \"^\", n, \" = \", pow(a, n), sep='')",
"def print_power(x):\r\n if(type(x)!=int):\r\n if(power(x)==1 or power(x)==0):\r\n print(calc_power(x))\r\n else:... | [
"0.80794406",
"0.739419",
"0.66700226",
"0.6589733",
"0.6485324",
"0.638416",
"0.6293852",
"0.62722826",
"0.61774296",
"0.61550194",
"0.61198187",
"0.59969866",
"0.5990775",
"0.59640026",
"0.59278244",
"0.59264386",
"0.59198284",
"0.5873405",
"0.5873405",
"0.5857948",
"0.5857... | 0.80480736 | 1 |
Print the hypotenuse of straight angled triangle with 3 and 5 rib lengths | def hypotenuse():
print(math.sqrt(5*5 + 3*3)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def triangular_area():\n print(1*1/2, 2*2/2, 3*3/2, 4*4/2, 5*5/2, 6*6/2, 7*7/2, 8*8/2, 9*9/2,\n 10*10/2)",
"def hypotenuse():\n print(math.sqrt(5**2 +3**2))",
"def triangle(self):\n \n R = Householder.triangle_operation(self)[0] \n \n return(R.round(10))",
"de... | [
"0.716252",
"0.69258684",
"0.68606097",
"0.68530416",
"0.6835748",
"0.67376614",
"0.66448975",
"0.66325754",
"0.65477556",
"0.65080655",
"0.6503776",
"0.64483434",
"0.64430314",
"0.6440897",
"0.6418103",
"0.6221835",
"0.6206969",
"0.6188036",
"0.6169473",
"0.6046872",
"0.6028... | 0.70707786 | 1 |
Some original examples in SQuAD have indices wrong by 1 or 2 character. We test and fix this here. | def _get_correct_alignement(context, answer):
gold_text = answer["text"]
start_idx = answer["answer_start"]
end_idx = start_idx + len(gold_text)
if context[start_idx:end_idx] == gold_text:
return start_idx, end_idx # When the gold label position is good
elif context[start_idx - 1 : end_idx ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_index_geq_3(self):\n self.insert()\n data = self.tbl[6:]\n assert self.check(self.idata[2:], data)",
"def test_stochatreat_input_idx_col_str(correct_params):\n idx_col_not_str = 0\n with pytest.raises(TypeError):\n stochatreat(\n data=correct_params[\"data\"]... | [
"0.58099073",
"0.56744087",
"0.56158406",
"0.5522892",
"0.5503032",
"0.54781187",
"0.5442574",
"0.5439417",
"0.5433266",
"0.5433266",
"0.5433081",
"0.541962",
"0.5385678",
"0.53835106",
"0.53824735",
"0.52802736",
"0.52733016",
"0.52319086",
"0.5225618",
"0.5197222",
"0.51944... | 0.0 | -1 |
first match is returned in match case | def get_answer_indices_from_sentence(answer_text: str, sentence: str, loose_match: bool = False):
# sometimes extracted answers does not match with the original text :/
try:
pattern = r"(?<![a-zA-Z0-9])(%s)(?![a-zA-Z0-9])" % re.escape(answer_text)
match_str = re.search(pattern, sentence)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_match(s,patterns):\n\n for p in patterns:\n m=p.match(s)\n if m:\n return p,m\n return None,None",
"def _FindFirstCompoundMatch(matches):\n for m in matches:\n if isinstance(m.value, models.Compound):\n return m\n return None",
"def match(self, ite... | [
"0.6874615",
"0.66699106",
"0.65208817",
"0.6322175",
"0.62504864",
"0.62194806",
"0.61659265",
"0.6103416",
"0.60927224",
"0.60927224",
"0.6083921",
"0.6060716",
"0.6040884",
"0.59855664",
"0.59727067",
"0.59399265",
"0.5920194",
"0.59165275",
"0.5913169",
"0.5902508",
"0.58... | 0.0 | -1 |
Removes the citations that consist of a pair of brackets having a substring containing at least one digit inside them. | def remove_citations(text: str) -> str:
text = re.sub("\[[a-zA-Z]\]", "", text)
return re.sub(r"\[(\s|\w)*\d+(\s|\w)*\]", "", text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _remove_between_square_brackets(text):\n return re.sub('\\[[^]]*\\]', '', text)",
"def clean_all_brackets(text):\n if \"[\" in text and \"]\" in text:\n text = delete_first_brackets(text)\n return clean_all_brackets(text)\n else:\n return text",
"def clean_newick_string(self, ... | [
"0.627086",
"0.6270785",
"0.605527",
"0.5885382",
"0.58816636",
"0.5716584",
"0.55261326",
"0.54964125",
"0.5492156",
"0.5491435",
"0.54455703",
"0.5420037",
"0.54059094",
"0.5369905",
"0.5256885",
"0.52483344",
"0.5220134",
"0.51920635",
"0.51877683",
"0.51309067",
"0.512497... | 0.6384374 | 0 |
Create and return a `User` with superuser powers. Superuser powers means that this user is an admin that can do anything they want. | def create_superuser(self, username, email, password, **kwargs):
kwargs.setdefault('is_staff', True)
kwargs.setdefault('is_superuser', True)
if kwargs.get('is_staff') is not True:
raise ValueError('Superuser must have is_staff=True.')
if kwargs.get('is_superuser') is not Tru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user_as_admin(self, *args, **kwargs):\n profile = self.create_user(*args, **kwargs)\n profile.make_administrator()\n return profile",
"def create_superuser(self, username, major, password):\r\n user = self.create_user(username, major, password=password,)\r\n user.is_admi... | [
"0.7354598",
"0.7346853",
"0.7292081",
"0.72741586",
"0.7273662",
"0.722427",
"0.7210906",
"0.7199503",
"0.71846986",
"0.7173363",
"0.7138555",
"0.71200466",
"0.7115839",
"0.7092951",
"0.70887464",
"0.708154",
"0.7074986",
"0.706979",
"0.7068387",
"0.70664716",
"0.70519775",
... | 0.0 | -1 |
Allows us to get a user's token by calling `user.token` instead of `user.generate_jwt_token(). The `` decorator above makes this possible. `token` is called a "dynamic property". | def token(self):
return self._generate_jwt_token() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def UserToken(self) -> object:",
"def _get_token(self):\n return user.get_token()",
"async def get_user(token: str = Depends(get_user_token_strict)) -> schemas.UserToken:\n token_info = await security.decode_jwt(token)\n return schemas.UserToken.from_token(token_info)",
"def decorated(*args, **k... | [
"0.74925566",
"0.71262574",
"0.7045925",
"0.6967166",
"0.6867049",
"0.68216413",
"0.6814544",
"0.6807034",
"0.6781353",
"0.67762995",
"0.6704667",
"0.66133755",
"0.659621",
"0.6594218",
"0.6567751",
"0.6567751",
"0.65423006",
"0.6423605",
"0.6423605",
"0.6415719",
"0.64120895... | 0.67203206 | 10 |
Generates a JSON Web Token that stores this user's ID and has an expiry date set to 60 days into the future. | def _generate_jwt_token(self):
import jwt
from datetime import datetime, timedelta
from django.conf import settings
dt = datetime.now() + timedelta(days=60)
token = jwt.encode({
'id': self.pk,
'username': self.username,
'exp': int(dt.strftime... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_jwt_token(self):\n dt = datetime.now() + timedelta(days=60)\n\n token = jwt.encode({\n 'id': self.pk,\n 'exp': int(dt.strftime('%s'))\n }, settings.SECRET_KEY, algorithm='HS256')\n\n return token.decode('utf-8')",
"def generate_auth_token(self, expi... | [
"0.793682",
"0.77396196",
"0.77252686",
"0.7569785",
"0.7550483",
"0.7504947",
"0.74958557",
"0.74798924",
"0.745215",
"0.7271606",
"0.72704905",
"0.7229112",
"0.7227402",
"0.71781677",
"0.7081612",
"0.69910264",
"0.69628245",
"0.69411725",
"0.69014037",
"0.6862004",
"0.68561... | 0.8095364 | 0 |
Validates if all ConfigurationOption names are unique in the ConfigurationOptions instance. | def configuration_options_object_processor(configuration_options):
option_names = [option.name for option in configuration_options.configuration_options]
for option_name in option_names:
if option_names.count(option_name) > 1:
raise WashError(f'Configuration option with the name {option_name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_options(self):\r\n valid_choices = ('correct', 'partially-correct', 'incorrect')\r\n for option in self.options:\r\n choice = option['choice']\r\n if choice is None:\r\n raise ValueError('Missing required choice attribute.')\r\n elif choic... | [
"0.66978174",
"0.6242515",
"0.6204667",
"0.61873025",
"0.6138533",
"0.60712093",
"0.6030964",
"0.598881",
"0.5862973",
"0.5836668",
"0.5816893",
"0.5737586",
"0.5737399",
"0.57218176",
"0.570948",
"0.5619496",
"0.55831975",
"0.55713516",
"0.55708873",
"0.5567247",
"0.55379665... | 0.7466442 | 0 |
Validates if all ConfigurationOptionParameter names are unique in the ConfigurationOption instance. Also validates if at least one required parameter is specified in the ConfigurationOption instance. | def configuration_option_object_processor(configuration_option):
parameter_names = [parameter.name for parameter in configuration_option.parameters]
for parameter_name in parameter_names:
if parameter_names.count(parameter_name) > 1:
raise WashError(f'Parameter with the name {parameter_name}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate(self):\n for p in self.parameters:\n #Check for missing required parameters:\n if p.is_required and not(p.is_set):\n raise ValueError(\"Parameter %s is not set.\" \\\n % p.names[-1])\n #Also repeat the parameter va... | [
"0.6902311",
"0.6522125",
"0.6513697",
"0.64732",
"0.64559853",
"0.6451961",
"0.6323427",
"0.6316556",
"0.6186604",
"0.6156855",
"0.6142861",
"0.612921",
"0.60664105",
"0.6061574",
"0.6059569",
"0.60359025",
"0.5982344",
"0.59677446",
"0.5965603",
"0.59638935",
"0.5913237",
... | 0.7193669 | 0 |
Get stats for user(s) ( of teas drunk, of teas brewed, of times brewed, of teas received) | def stats(self):
try:
slack_id = MENTION_RE.search(self.command_body).groups()[0]
except AttributeError:
slack_id = None
if slack_id:
users = [UserManager.get_by_slack_id(slack_id)]
else:
users = self.session.query(User).filter(User.tea_ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_stats(df):\r\n print('\\nCalculating User Stats...\\n')\r\n start_time = time.time()\r\n # TO DO: Display counts of user types\r\n df = ['user type'].value_counts()\r\n print('count of user typs:\\n')\r\n # TO DO: Display counts of gender\r\n df = ['grnder'].value... | [
"0.7520656",
"0.7389398",
"0.7170555",
"0.7159044",
"0.71519357",
"0.71448964",
"0.7137626",
"0.7130871",
"0.7130532",
"0.7130459",
"0.71226174",
"0.7107432",
"0.706119",
"0.70610684",
"0.70570743",
"0.704516",
"0.7041531",
"0.70409685",
"0.7035824",
"0.7029423",
"0.70275396"... | 0.70605934 | 14 |
Return a marker's initial pose if it was passed in. | def initial_pose(self):
return self._initial_pose | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_init_pose(self):\n return self.init_pose_R, self.init_pose_t",
"def start_pose():\n global start_pose\n while start_pose is None:\n pass\n return start_pose",
"def _set_init_pose(self):\n raise NotImplementedError()",
"def _set_init_pose(self):\n ... | [
"0.6584604",
"0.6367691",
"0.6337681",
"0.6337681",
"0.6337681",
"0.6199046",
"0.6134793",
"0.60044897",
"0.5989717",
"0.5986071",
"0.59107316",
"0.5883016",
"0.58752507",
"0.58548284",
"0.57934",
"0.5782603",
"0.57810706",
"0.5780764",
"0.5670274",
"0.5653202",
"0.56078744",... | 0.7495326 | 0 |
Get the marker template's interactive marker server. | def server(self):
return self._server | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_server(self):\n\n pass",
"def get_mapserver(self):\n return self.get_node('//MapServer')",
"def server(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"server\")",
"def server(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"server\")",
"def server(self) ->... | [
"0.5713564",
"0.5681471",
"0.56718",
"0.56718",
"0.55612904",
"0.53901726",
"0.5360627",
"0.53534365",
"0.5328185",
"0.52752024",
"0.5226425",
"0.52251995",
"0.5196644",
"0.51267505",
"0.5064403",
"0.50298774",
"0.49947485",
"0.49527696",
"0.49257052",
"0.4907691",
"0.4877441... | 0.5278075 | 10 |
Get the interactive marker map of this marker template. | def marker_map(self):
return self._marker_map | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_map(self):\n return self.map",
"def get_map(self):\n return self.parent.controller.get_map()",
"def mappable(self):\n return self._mappable.get(self._plotid, None)",
"def markers (self):\n return self._markers",
"def get_map(self):\n return self._locmap",
"def G... | [
"0.6520739",
"0.64780396",
"0.63716984",
"0.6316054",
"0.6315033",
"0.6121316",
"0.60842246",
"0.59842247",
"0.5905344",
"0.5881036",
"0.5847196",
"0.57981193",
"0.5774668",
"0.5716302",
"0.569977",
"0.56583416",
"0.55513626",
"0.5545483",
"0.5514279",
"0.5488387",
"0.5481627... | 0.77108824 | 0 |
Get the callback map of this marker template. | def callback_map(self):
return self._callback_map | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def marker_map(self):\n return self._marker_map",
"def get_map(self):\n return self.map",
"def get_map(self):\n return self.parent.controller.get_map()",
"def MAP(self):\n return self.__map",
"def get_map(self):\n return self._locmap",
"def get_callback(self):\n ... | [
"0.7049451",
"0.6784116",
"0.6679001",
"0.6338827",
"0.6203012",
"0.6103992",
"0.6036267",
"0.58860934",
"0.58419704",
"0.5811328",
"0.571724",
"0.5705887",
"0.5624895",
"0.54811853",
"0.5466417",
"0.5464931",
"0.54548174",
"0.5448449",
"0.5445454",
"0.54268634",
"0.5374627",... | 0.78254753 | 0 |
Get the menu handler of this marker template. | def menu_handler(self):
return self._menu_handler | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_menu ( self, object ):\n return self.menu",
"def menu(self):\n return self._menu",
"def get_menu ( self, object, row ):\n return self.menu",
"def GetMenu(self):\n return self._menu",
"def menu(self):\n try:\n return get_template('{}/menu.html'.format(se... | [
"0.687998",
"0.6734362",
"0.66681284",
"0.6660644",
"0.6325513",
"0.630204",
"0.6267521",
"0.608892",
"0.60468376",
"0.60233533",
"0.60089546",
"0.59873855",
"0.5929736",
"0.5915794",
"0.5880168",
"0.58781844",
"0.5877921",
"0.5829185",
"0.58093506",
"0.5780745",
"0.5773996",... | 0.8167384 | 0 |
Returns dictionary for CDP neighbor phone | def phone_parse(neighbor):
mgmt_ip = neighbor[mgmt_ip_s]
hostname = neighbor[hostname_s].split('.')[0]
if nxos:
sysname = neighbor['sysname']
if sysname != '':
hostname = sysname
if mgmt_ip == '':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Neighbors(vendor):\n neighbors = {\"cisco\" : \"\", \"juniper\" : \"\", \"vyatta\" : \"\" }\n cisco_neighbors = {}\n juniper_neighbors = {}\n vyatta_neighbors = {}\n while True:\n print \"***\\t\\t%s NEIGHBORS***\" % (vendor)\n n = raw_input(\"\\t\\tNeighbor information (Press any ... | [
"0.6110668",
"0.6060373",
"0.59975594",
"0.58959544",
"0.5839219",
"0.57849395",
"0.56733996",
"0.5624407",
"0.56165946",
"0.5539645",
"0.546498",
"0.5460354",
"0.5419926",
"0.54115295",
"0.53951436",
"0.5389832",
"0.5381396",
"0.5365169",
"0.53650045",
"0.5330386",
"0.531964... | 0.6916648 | 0 |
Returns dictionary for CDP neighbor router or switch | def router_sw_parse(neighbor):
mgmt_ip = neighbor[mgmt_ip_s]
hostname = neighbor[hostname_s].split('.')[0]
if hostname.__contains__('('):
hostname = hostname.split('(')[0]
if nxos:
sysname = neighbor['sysname']
if sysname !=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Neighbors(vendor):\n neighbors = {\"cisco\" : \"\", \"juniper\" : \"\", \"vyatta\" : \"\" }\n cisco_neighbors = {}\n juniper_neighbors = {}\n vyatta_neighbors = {}\n while True:\n print \"***\\t\\t%s NEIGHBORS***\" % (vendor)\n n = raw_input(\"\\t\\tNeighbor information (Press any ... | [
"0.63590497",
"0.6126241",
"0.61201745",
"0.60082996",
"0.5985307",
"0.59344363",
"0.5915709",
"0.586581",
"0.5772417",
"0.5727852",
"0.57097715",
"0.5701715",
"0.569434",
"0.5683343",
"0.564236",
"0.56369084",
"0.56235886",
"0.5598898",
"0.55868256",
"0.5574442",
"0.5525679"... | 0.6161124 | 1 |
Returns dictionary for CDP neighbor wireless access point | def wap_parse(neighbor):
mgmt_ip = neighbor[mgmt_ip_s]
hostname = neighbor[hostname_s].split('.')[0]
if nxos:
sysname = neighbor['sysname']
if sysname != '':
hostname = sysname
if mgmt_ip == '':
m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_access_points(self):\r\n return {\"invalid mac\": {\"mac\": \"invalid mac\", \"ssid\": \"none\"}}",
"def createWIFIAccessPoint():\n ifname = config.get(\"interface\", \"wifi\")\n ipaddress = config.get(\"hotspot\", \"ip\")\n prefix = int(config.get(\"hotspot\", \"prefix\"))\n ssid = co... | [
"0.65589803",
"0.60421294",
"0.58815694",
"0.5777488",
"0.5672514",
"0.566989",
"0.5562045",
"0.5560893",
"0.55289185",
"0.55088353",
"0.54970974",
"0.54738414",
"0.54605913",
"0.54371357",
"0.54343486",
"0.54248816",
"0.53932667",
"0.5372743",
"0.5359739",
"0.5346931",
"0.53... | 0.5178175 | 30 |
Returns dictionary for CDP neighbor that isn't a phone, access point, router, or switch | def other_parse(neighbor):
mgmt_ip = neighbor[mgmt_ip_s]
hostname = neighbor[hostname_s].split('.')[0]
if nxos:
sysname = neighbor['sysname']
if sysname != '':
hostname = sysname
if mgmt_ip == '':
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Neighbors(vendor):\n neighbors = {\"cisco\" : \"\", \"juniper\" : \"\", \"vyatta\" : \"\" }\n cisco_neighbors = {}\n juniper_neighbors = {}\n vyatta_neighbors = {}\n while True:\n print \"***\\t\\t%s NEIGHBORS***\" % (vendor)\n n = raw_input(\"\\t\\tNeighbor information (Press any ... | [
"0.6003028",
"0.5648148",
"0.56309026",
"0.54871684",
"0.54836214",
"0.5455412",
"0.53574145",
"0.53206867",
"0.5274642",
"0.5270559",
"0.52702534",
"0.5257775",
"0.52102804",
"0.52034205",
"0.5196427",
"0.5195789",
"0.5183352",
"0.5181435",
"0.5161388",
"0.5145692",
"0.51405... | 0.5547205 | 3 |
Given TEXTFSM CDP neighbor, checks type of device and runs through corresponding parser function. | def parse(n):
capabilities = n['capabilities']
if n['platform'].__contains__('IP Phone') or capabilities.__contains__('Phone'):
phone_parse(n)
elif capabilities.__contains__('Router') and capabilities.__contains__('Source-Route-Bridge') or \
capabi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_device_from_datagram(\n device_callback: Callable[[SwitcherBase], Any], datagram: bytes\n) -> None:\n parser = DatagramParser(datagram)\n if not parser.is_switcher_originator():\n logger.debug(\"received datagram from an unknown source\")\n else:\n device_type: DeviceType = par... | [
"0.5448138",
"0.5367822",
"0.51965165",
"0.51411146",
"0.5129462",
"0.4950195",
"0.4934969",
"0.49349013",
"0.47787055",
"0.47489983",
"0.4734217",
"0.4636806",
"0.46320385",
"0.46221396",
"0.46014342",
"0.4576387",
"0.4569176",
"0.45680135",
"0.45521274",
"0.45414808",
"0.45... | 0.55118585 | 0 |
Parses CUCM export of phones with fields 'Description', 'Device Name', and 'Directory Number 1' | def cucm_export_parse(file):
phones = {}
while True:
try:
with open(file) as phonelist_csv:
for line in phonelist_csv:
if not line.__contains__('Description,Device Name,Directory Number 1'):
info = line.split(',')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_phone(parsed_data):\n result = []\n known_values = []\n\n contacts = {'registrant_contact': [], 'administrative_contact': [], 'technical_contact': [],\n 'domain_registrar' :[]}\n if 'registrant_contact' in parsed_data:\n contacts['registrant_conta... | [
"0.5697088",
"0.53372353",
"0.5237132",
"0.52135444",
"0.5204209",
"0.5193696",
"0.5180402",
"0.51639044",
"0.5127449",
"0.5107768",
"0.5095245",
"0.5094951",
"0.50657725",
"0.5043901",
"0.50421095",
"0.49992374",
"0.4995149",
"0.49897113",
"0.49766734",
"0.49737394",
"0.4962... | 0.7282722 | 0 |
Parses device lists and outputs to spreadsheet | def output_to_spreadsheet(routers_switches, phones, aps, others, failed_devices, file_location):
# Creates Excel workbook and worksheets
wb = Workbook()
routers_switches_ws = wb.active
routers_switches_ws.title = 'Routers_Switches'
phones_ws = wb.create_sheet('Phones')
aps_ws = wb.create_sheet('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_devices_summary():\n\n # This function was created to replace get_devices_information\n # because it wasn't detecting virtual systems in Palo Alto Virtual Systems\n global nipper_xml\n devices = {}\n headings = []\n\n # Add the table headings to a list\n for h in nipper_xml.findall(\".... | [
"0.653493",
"0.64370185",
"0.619556",
"0.60104626",
"0.5987369",
"0.59667",
"0.5913384",
"0.5850942",
"0.57446754",
"0.5737992",
"0.5729885",
"0.57229185",
"0.57079405",
"0.5698568",
"0.56967455",
"0.5694549",
"0.5687321",
"0.5673653",
"0.56696445",
"0.56641084",
"0.56432945"... | 0.615764 | 3 |
Simple decorator that intercepts connection errors and ignores these if settings specify this. | def omit_exception(method):
@functools.wraps(method)
def _decorator(self, *args, **kwargs):
if self._ignore_exceptions:
try:
return method(self, *args, **kwargs)
except ConnectionInterrupted:
return None
else:
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raises_conn_error(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except exc.InvalidRequestError:\n LOG.exception('Connection error:')\n raise errors.ConnectionError()\n\n return wrapper",
"def cat... | [
"0.72698784",
"0.66141045",
"0.6369015",
"0.6124528",
"0.60732985",
"0.6064023",
"0.6020223",
"0.598191",
"0.5975428",
"0.5972395",
"0.5914723",
"0.5908168",
"0.58850574",
"0.58763325",
"0.586832",
"0.5864718",
"0.58527994",
"0.58304864",
"0.5756849",
"0.5747329",
"0.57441664... | 0.57709926 | 18 |
Lazy client connection property. | def client(self):
if self._client is None:
self._client = self._client_cls(self._server, self._params, self)
return self._client | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getClientConnection(self):\n self.client = twisted_client.DivvyClient(self.host, self.port, timeout=1.0)\n return self.client.connection.deferred",
"def _http_client(self):\n\n self.__enforce_connected()\n return self.collection._http_client",
"def Client(self):\n return... | [
"0.68353057",
"0.647777",
"0.6356882",
"0.63473797",
"0.63429874",
"0.6337806",
"0.6315816",
"0.62760454",
"0.62649846",
"0.61533195",
"0.6150137",
"0.6147768",
"0.6136684",
"0.6119306",
"0.61188084",
"0.60776466",
"0.60776466",
"0.6076847",
"0.6074807",
"0.6074807",
"0.60748... | 0.615881 | 9 |
Return a raw redis client (connection). Not all pluggable clients supports this feature. If not supports this raises NotImplementedError | def raw_client(self):
warnings.warn("raw_client is deprecated. use self.client.get_client instead",
DeprecationWarning, stacklevel=2)
return self.client.get_client(write=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_redis_client(self):\n\n client = Client(\n #connection_pool=connection_pool,\n host=self.backend_settings.get('HOST', 'localhost'),\n port=int(self.backend_settings.get('PORT', 6379)),\n io_loop=self.io_loop,\n password=self.backend_settings.get... | [
"0.75808513",
"0.7364119",
"0.7324798",
"0.7252318",
"0.7140241",
"0.7111231",
"0.70927393",
"0.70927393",
"0.7028319",
"0.70221347",
"0.6977828",
"0.6932089",
"0.68634254",
"0.68316096",
"0.68309367",
"0.68088293",
"0.67714703",
"0.67087954",
"0.66233534",
"0.6567602",
"0.65... | 0.6708816 | 17 |
Return a next index for read client. This function implements a default behavior for get a next read client for masterslave setup. Overwrite this function if you want a specific behavior. | def get_next_client_index(self, write=True):
if write or len(self._server) == 1:
return 0
return random.randint(1, len(self._server) - 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __next_index():\n return redis_store.incr(String.__name__.lower() + '-index')",
"def get_client(self, write=True):\r\n index = self.get_next_client_index(write=write)\r\n\r\n if self._clients[index] is None:\r\n self._clients[index] = self.connect(index)\r\n\r\n return ... | [
"0.6373826",
"0.60432035",
"0.57846725",
"0.57057947",
"0.56468946",
"0.5631014",
"0.5614183",
"0.56074053",
"0.56074053",
"0.5567467",
"0.5533405",
"0.5528173",
"0.5506794",
"0.55002165",
"0.5483921",
"0.54825854",
"0.5479725",
"0.54147923",
"0.5399875",
"0.53776383",
"0.534... | 0.72630644 | 0 |
Method used for obtain a raw redis client. This function is used by almost all cache backend operations for obtain a native redis client/connection instance. | def get_client(self, write=True):
index = self.get_next_client_index(write=write)
if self._clients[index] is None:
self._clients[index] = self.connect(index)
return self._clients[index] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_redis_client(self):\n\n client = Client(\n #connection_pool=connection_pool,\n host=self.backend_settings.get('HOST', 'localhost'),\n port=int(self.backend_settings.get('PORT', 6379)),\n io_loop=self.io_loop,\n password=self.backend_settings.get... | [
"0.77595675",
"0.75294465",
"0.7431494",
"0.7431494",
"0.7419155",
"0.7383458",
"0.7361354",
"0.7291747",
"0.7288551",
"0.7055464",
"0.69388926",
"0.687926",
"0.682468",
"0.681639",
"0.6660242",
"0.6626695",
"0.6580045",
"0.6546807",
"0.6497834",
"0.64684373",
"0.6462292",
... | 0.0 | -1 |
Method that parse a connection string. | def parse_connection_string(self, constring):
try:
host, port, db = constring.split(":")
port = port if host == "unix" else int(port)
db = int(db)
return host, port, db
except (ValueError, TypeError):
raise ImproperlyConfigured("Incorrec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_connection_string(self, connection_string):\n self.host = '127.0.0.1'\n self.port = 3306\n self.db = None\n self.user = None\n self.pwd = None\n for part in connection_string.split(';'):\n part = part.strip()\n if part != '':\n ... | [
"0.8401574",
"0.6616161",
"0.6538914",
"0.6453745",
"0.6397597",
"0.6344282",
"0.6208351",
"0.6030974",
"0.59864354",
"0.57071424",
"0.56045955",
"0.5569482",
"0.5531569",
"0.5472697",
"0.5466513",
"0.5460773",
"0.54534364",
"0.5451783",
"0.5448955",
"0.5406482",
"0.5380559",... | 0.7921391 | 1 |
Given a connection index, returns a new raw redis client/connection instance. Index is used for master/slave setups and indicates that connection string should be used. In normal setups, index is 0. | def connect(self, index=0):
host, port, db = self.parse_connection_string(self._server[index])
return self.connection_factory.connect(host, port, db) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self, index=0, write=True):\r\n master_name, sentinel_hosts, db = self.parse_connection_string(self._connection_string)\r\n\r\n sentinel_timeout = self._options.get('SENTINEL_TIMEOUT', 1)\r\n sentinel = Sentinel(sentinel_hosts, socket_timeout=sentinel_timeout)\r\n\r\n if wri... | [
"0.5969906",
"0.5762544",
"0.5700567",
"0.5463157",
"0.5462497",
"0.5395308",
"0.5355108",
"0.53345335",
"0.5311246",
"0.53111696",
"0.53071743",
"0.5279201",
"0.52436805",
"0.5213795",
"0.52018327",
"0.5171319",
"0.5145463",
"0.5115737",
"0.51155186",
"0.51154757",
"0.510455... | 0.64365077 | 0 |
Persist a value to the cache, and set an optional expiration time. Also supports optional nx parameter. If set to True will use redis setnx instead of set. | def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None, client=None, nx=False):
if not client:
client = self.get_client(write=True)
key = self.make_key(key, version=version)
value = self.pickle(value)
if timeout is True:
warnings.warn("Using T... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set(self, key, value, ttl=None):\n if ttl and (type(ttl) is int) and (ttl > 0):\n ttl += int(dt.now().strftime('%s'))\n self.dadd('ttl', (key, ttl))\n return super(MyCache, self).set(key, value)",
"def set_cache(self, key, value):\n self.r.set(key, value)\n s... | [
"0.71424836",
"0.703814",
"0.7037537",
"0.693196",
"0.69029826",
"0.68569165",
"0.6698016",
"0.66800463",
"0.66005665",
"0.65324146",
"0.6516281",
"0.65056723",
"0.64677554",
"0.6453569",
"0.64420253",
"0.6440975",
"0.6368826",
"0.6368644",
"0.63575447",
"0.63526106",
"0.6343... | 0.64705276 | 12 |
Adds delta to the cache version for the supplied key. Returns the new version. | def incr_version(self, key, delta=1, version=None, client=None):
if client is None:
client = self.get_client(write=True)
if version is None:
version = self._backend.version
old_key = self.make_key(key, version)
value = self.get(old_key, version=version... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def incr(self, key, delta=1):\n try:\n key = self.prepare_key(key)\n return super(CacheClass, self).incr(key, delta)\n except Exception as err:\n return self.warn_or_error(err, delta)",
"def incr(self, key, delta=1, version=None, client=None):\r\n return self... | [
"0.6767568",
"0.6661848",
"0.6260883",
"0.6248231",
"0.6220057",
"0.5948065",
"0.5826451",
"0.56962454",
"0.55747366",
"0.54451704",
"0.53051615",
"0.52766025",
"0.5254437",
"0.52447313",
"0.5226823",
"0.5207911",
"0.52070314",
"0.52013683",
"0.5162349",
"0.5153979",
"0.51407... | 0.73972917 | 0 |
Add a value to the cache, failing if the key already exists. Returns ``True`` if the object was added, ``False`` if not. | def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None, client=None):
return self.set(key, value, timeout, client=client, nx=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, key, value, timeout=None):\n try:\n key = self.prepare_key(key)\n if self._cache.exists(key):\n return False\n return self.set(key, value, timeout)\n except Exception as err:\n return self.warn_or_error(err, False)",
"async de... | [
"0.79764557",
"0.784722",
"0.76094764",
"0.7570547",
"0.67336345",
"0.66414005",
"0.65780276",
"0.6525757",
"0.65098953",
"0.64111245",
"0.6403692",
"0.63962054",
"0.6391893",
"0.6364911",
"0.63507026",
"0.63174766",
"0.63061655",
"0.6276967",
"0.6250194",
"0.6208237",
"0.620... | 0.60447884 | 43 |
Retrieve a value from the cache. Returns unpickled value if key is found, the default if not. | def get(self, key, default=None, version=None, client=None):
if client is None:
client = self.get_client(write=False)
key = self.make_key(key, version=version)
try:
value = client.get(key)
except ConnectionError:
raise ConnectionInterrupted(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_get(key, default=None):\n mc = get_cache_client()\n try:\n return decode_value(mc.get(get_key(key))) or default\n except:\n return default",
"def get(self, key, default=None):\n try:\n # get the value from the cache\n value = self._cache.get(self.prep... | [
"0.8608674",
"0.8461511",
"0.7560578",
"0.7520198",
"0.7461802",
"0.74511784",
"0.7430722",
"0.7409133",
"0.7403028",
"0.7392436",
"0.73517424",
"0.73517424",
"0.7344049",
"0.7314685",
"0.7308884",
"0.73088133",
"0.73088133",
"0.73070526",
"0.7288571",
"0.72056913",
"0.716522... | 0.69232833 | 37 |
Remove a key from the cache. | def delete(self, key, version=None, client=None):
if client is None:
client = self.get_client(write=True)
try:
return client.delete(self.make_key(key, version=version))
except ConnectionError:
raise ConnectionInterrupted(connection=client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, key):\n del self._cache[key]",
"def delete_cache(self, key):\n self.r.delete(key)",
"def delete(self, key):\n # Initialize key variables\n result = self.cache.delete(key)\n\n # Return\n return result",
"def delete(self, key):\n try:\n ... | [
"0.83336556",
"0.83148736",
"0.82934654",
"0.82560545",
"0.80965835",
"0.8031949",
"0.8010773",
"0.7989685",
"0.7981018",
"0.79799193",
"0.79403096",
"0.78806204",
"0.7873276",
"0.7864556",
"0.7860124",
"0.7842964",
"0.7785126",
"0.77501744",
"0.7734317",
"0.77335244",
"0.770... | 0.0 | -1 |
Remove all keys matching pattern. | def delete_pattern(self, pattern, version=None, client=None):
if client is None:
client = self.get_client(write=True)
pattern = self.make_key(pattern, version=version)
try:
keys = client.keys(pattern)
if keys:
return client.delete(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_keys_script(key_pattern):\n return \"\"\"\n local curkey = redis.call('keys', '%(key_pattern)s')\n if next(curkey) then\n redis.call('del', unpack(curkey))\n end\n \"\"\" % dict(key_pattern = key_pattern)",
"def removeAllKeys(self) -> None:\n ...",
"def ... | [
"0.71263444",
"0.71224153",
"0.69078034",
"0.68396205",
"0.62849766",
"0.6268765",
"0.6172009",
"0.6127846",
"0.6119483",
"0.60778594",
"0.60445154",
"0.60347545",
"0.6034711",
"0.6016867",
"0.59771806",
"0.59697485",
"0.59694785",
"0.59510666",
"0.59176606",
"0.59154534",
"0... | 0.5490217 | 58 |
Remove multiple keys at once. | def delete_many(self, keys, version=None, client=None):
if client is None:
client = self.get_client(write=True)
if not keys:
return
keys = [self.make_key(k, version=version) for k in keys]
try:
return client.delete(*keys)
except C... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_many(self, keys):\n raise NotImplementedError()",
"def delete_many(self, keys):\n return self.delete_many_values(keys)",
"def delete_many(self, keys):\n try:\n if keys:\n self._cache.delete(*map(self.prepare_key, keys))\n except Exception as err:... | [
"0.7817214",
"0.7613119",
"0.75661665",
"0.7246898",
"0.72212213",
"0.7096062",
"0.70484746",
"0.6989821",
"0.6989821",
"0.6989821",
"0.69775665",
"0.6884616",
"0.68422145",
"0.68080235",
"0.6671621",
"0.6636076",
"0.6628445",
"0.6601189",
"0.6573967",
"0.6571191",
"0.6570996... | 0.68532324 | 12 |
Flush all cache keys. | def clear(self, client=None):
if client is None:
client = self.get_client(write=True)
client.flushdb() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flush():\n for k in cache._thecache.keys():\n del cache._thecache[k]",
"def flush_all(cls):\n for sess in cls._session_registry.values():\n sess.flush()",
"def flush(self):\n self._getMemcacheClient().flush_all()",
"def flush():\n global CACHE, STATS_KEYS_COUNT\n CA... | [
"0.8249561",
"0.74615514",
"0.74002236",
"0.73858947",
"0.73273766",
"0.7129604",
"0.7088885",
"0.6993901",
"0.6992103",
"0.6972405",
"0.6971914",
"0.69617254",
"0.6873503",
"0.684811",
"0.681874",
"0.67652905",
"0.6680763",
"0.66221285",
"0.6614499",
"0.6566027",
"0.6557009"... | 0.0 | -1 |
Unpickles the given value. | def unpickle(value):
try:
value = int(value)
except (ValueError, TypeError):
value = smart_bytes(value)
value = pickle.loads(value)
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unserialize(val):\n return pickle.loads(val)",
"def _decode_value(self, value):\n return pickle.loads(value.value) if value else value",
"def from_value(value):\n return pickle.dumps(value)",
"def base64unpickle(self, value):\n if value:\n return pickle.loads(self.base64decod... | [
"0.7045012",
"0.7031028",
"0.6841384",
"0.65678066",
"0.6526041",
"0.64857894",
"0.6477095",
"0.61220485",
"0.6111226",
"0.6080982",
"0.6064356",
"0.60208184",
"0.6005177",
"0.5897015",
"0.58008486",
"0.5781338",
"0.57552445",
"0.57470506",
"0.5712168",
"0.56796086",
"0.56617... | 0.7501486 | 0 |
Pickle the given value. | def pickle(self, value):
if isinstance(value, bool) or not isinstance(value, integer_types):
return pickle.dumps(value, self._pickle_version)
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_value(value):\n return pickle.dumps(value)",
"def dump_object(self, value):\n return pickle.dumps(value)",
"def _encode_value(self, value):\n return pickle.dumps(value)",
"def unserialize(val):\n return pickle.loads(val)",
"def value(self) -> Any:\n return pickle.loads(self.pi... | [
"0.77703",
"0.7441614",
"0.6958083",
"0.6798523",
"0.6667502",
"0.6574332",
"0.6568599",
"0.6552237",
"0.65478945",
"0.6544326",
"0.65061575",
"0.6471692",
"0.64400285",
"0.6392385",
"0.6310394",
"0.6301115",
"0.6247126",
"0.6234851",
"0.619252",
"0.61067325",
"0.6043083",
... | 0.75480545 | 1 |
Set a bunch of values in the cache at once from a dict of key/value pairs. This is much more efficient than calling set() multiple times. If timeout is given, that timeout will be used for the key; otherwise the default cache timeout will be used. | def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None, client=None):
if client is None:
client = self.get_client(write=True)
try:
pipeline = client.pipeline()
for key, value in data.items():
self.set(key, value, timeout, version=versio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_many(self, data, timeout=None):\n try:\n safe_data = {}\n for key, value in data.iteritems():\n safe_data[self.prepare_key(key)] = pickle.dumps(value)\n if safe_data:\n self._cache.mset(safe_data)\n map(self.expire, safe_d... | [
"0.7048416",
"0.65402865",
"0.65266925",
"0.65183073",
"0.6350942",
"0.62865585",
"0.62400687",
"0.6119562",
"0.60667795",
"0.60572",
"0.60372555",
"0.5987229",
"0.5970992",
"0.5851879",
"0.5771597",
"0.5759905",
"0.5714097",
"0.56895006",
"0.56890684",
"0.56627226",
"0.55355... | 0.6101358 | 8 |
Add delta to value in the cache. If the key does not exist, raise a ValueError exception. | def incr(self, key, delta=1, version=None, client=None):
return self._incr(key=key, delta=delta, version=version, client=client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def incr(self, key, delta=1):\n try:\n key = self.prepare_key(key)\n return super(CacheClass, self).incr(key, delta)\n except Exception as err:\n return self.warn_or_error(err, delta)",
"async def _add(self, key, value, ttl=None):\n if key in SimpleMemoryBack... | [
"0.7142552",
"0.66308564",
"0.65371734",
"0.63884085",
"0.62857854",
"0.6254576",
"0.6170329",
"0.60990596",
"0.6067846",
"0.60315996",
"0.6010248",
"0.5961082",
"0.5929392",
"0.59237266",
"0.5892977",
"0.5892977",
"0.58660084",
"0.5862615",
"0.5854951",
"0.580561",
"0.580539... | 0.52970463 | 82 |
Decreace delta to value in the cache. If the key does not exist, raise a ValueError exception. | def decr(self, key, delta=1, version=None, client=None):
return self._incr(key=key, delta=-delta, version=version,
client=client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decr(self, key, delta=1):\n try:\n key = self.prepare_key(key)\n return super(CacheClass, self).decr(key, delta)\n except Exception as err:\n return self.warn_or_error(err, delta)",
"def decr(self, key, delta=1):\n\t\treturn self._incrdecr(\"decr\", key, delta)"... | [
"0.7430303",
"0.6069981",
"0.599998",
"0.5940083",
"0.5817379",
"0.5777649",
"0.5653828",
"0.5540521",
"0.5511951",
"0.5498733",
"0.5495983",
"0.54901856",
"0.546873",
"0.5436476",
"0.5412869",
"0.53812855",
"0.53312963",
"0.520011",
"0.51767087",
"0.51663154",
"0.5164387",
... | 0.5794123 | 5 |
Executes TTL redis command and return the "timetolive" of specified key. If key is a non volatile key, it returns None. | def ttl(self, key, version=None, client=None):
if client is None:
client = self.get_client(write=False)
key = self.make_key(key, version=version)
if not client.exists(key):
return 0
return client.ttl(key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ttl(self, key, now=None):\n if now is None:\n now = time.time()\n with self._lock:\n # pylint: disable=unused-variable\n expire, _value = self._values[key]\n return expire - now",
"def ttl(self, key):\n return self._command(b'PTTL', key, ha... | [
"0.69026345",
"0.68486464",
"0.6479326",
"0.59795386",
"0.5874349",
"0.5834716",
"0.5834716",
"0.5786248",
"0.57667464",
"0.57667464",
"0.57667464",
"0.5726573",
"0.5716824",
"0.57058173",
"0.57058173",
"0.5512666",
"0.54317343",
"0.5408408",
"0.53892404",
"0.5384477",
"0.537... | 0.61664176 | 3 |
Test if key exists. | def has_key(self, key, version=None, client=None):
if client is None:
client = self.get_client(write=False)
key = self.make_key(key, version=version)
try:
return client.exists(key)
except ConnectionError:
raise ConnectionInterrupted(connecti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exists(self, key_name: str) -> bool:\n pass",
"def key_exists(dictionary, key):\n\n exists = dictionary.get(key, None)\n return exists is not None",
"def has(self, key):",
"def has(self, key):\n return False",
"def containsKey(self, key):\n return get(key) != None",
"def ha... | [
"0.8538106",
"0.8020361",
"0.79491585",
"0.7948841",
"0.7855513",
"0.7791192",
"0.77758735",
"0.77736175",
"0.7767599",
"0.77593726",
"0.7699159",
"0.7668944",
"0.7656245",
"0.76534593",
"0.7638008",
"0.7625921",
"0.7601507",
"0.7591905",
"0.7566847",
"0.7560203",
"0.74866575... | 0.698617 | 55 |
Same as keys, but uses redis >= 2.8 cursors for make memory efficient keys iteration. | def iter_keys(self, search, itersize=None, client=None, version=None):
if client is None:
client = self.get_client(write=False)
pattern = self.make_key(search, version=version)
cursor = b"0"
while True:
cursor, data = client.scan(cursor, match=pattern,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keysAll():",
"def iterkeys(self):",
"def iterkeys(self):",
"def __iter__(self):\n with SessionContext(self.SessionClass) as session:\n keys = session.query(PAW2_DBObject.key)\n keys = [c[0] for c in keys]\n random.shuffle(keys)\n return keys.__it... | [
"0.6539967",
"0.6439033",
"0.6439033",
"0.6406501",
"0.6317287",
"0.62992024",
"0.6295674",
"0.62863976",
"0.6251499",
"0.61752737",
"0.61744106",
"0.6127187",
"0.61208725",
"0.6091683",
"0.6080563",
"0.60704976",
"0.60620534",
"0.60554224",
"0.60449165",
"0.60397065",
"0.600... | 0.61971253 | 9 |
Execute KEYS command and return matched results. | def keys(self, search, version=None, client=None):
if client is None:
client = self.get_client(write=False)
pattern = self.make_key(search, version=version)
try:
encoding_map = [smart_text(k) for k in client.keys(pattern)]
return [self.reverse_key(k)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self, pattern=\"*\"):\n return self._command(b'KEYS', pattern, handler=list_of_keys)",
"def cli(ctx):\n return ctx.gi.cannedkeys.get_keys()",
"def hkeys(self, key):\n return self._command(b'HKEYS', key, handler=list_of_keys)",
"def get_keys(self):\r\n\t\tlogger.debug(\"Getting the k... | [
"0.6484579",
"0.64004225",
"0.63666326",
"0.596718",
"0.5795308",
"0.57775927",
"0.57604456",
"0.56159306",
"0.5600945",
"0.54936355",
"0.54684335",
"0.54242885",
"0.5403328",
"0.5398406",
"0.53625154",
"0.53272474",
"0.5319963",
"0.5312056",
"0.5285476",
"0.5284211",
"0.5275... | 0.51984143 | 27 |
Simple decorator that intercepts connection errors and ignores these if settings specify this. | def auto_failover(method):
@functools.wraps(method)
def _decorator(self, *args, **kwargs):
if self._in_fallback:
pass_seconds = (datetime_now() - self._in_fallback_date).total_seconds()
if pass_seconds > self._options.get("FAILOVER_TIME", 30):
print("Go to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def raises_conn_error(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n try:\n return func(*args, **kwargs)\n except exc.InvalidRequestError:\n LOG.exception('Connection error:')\n raise errors.ConnectionError()\n\n return wrapper",
"def cat... | [
"0.72698784",
"0.66141045",
"0.6369015",
"0.6124528",
"0.60732985",
"0.6064023",
"0.6020223",
"0.598191",
"0.5975428",
"0.5972395",
"0.5914723",
"0.5908168",
"0.58850574",
"0.58763325",
"0.586832",
"0.5864718",
"0.58527994",
"0.58304864",
"0.57709926",
"0.5756849",
"0.5747329... | 0.55187356 | 36 |
Set a bunch of values in the cache at once from a dict of key/value pairs. This is much more efficient than calling set() multiple times. If timeout is given, that timeout will be used for the key; otherwise the default cache timeout will be used. | def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None, client=None,
herd=True):
if client is None:
client = self.get_client(write=True)
set_function = self.set if herd else super(HerdClient, self).set
try:
pipeline = client.pipeline()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_many(self, data, timeout=None):\n try:\n safe_data = {}\n for key, value in data.iteritems():\n safe_data[self.prepare_key(key)] = pickle.dumps(value)\n if safe_data:\n self._cache.mset(safe_data)\n map(self.expire, safe_d... | [
"0.7048416",
"0.65402865",
"0.65266925",
"0.65183073",
"0.6350942",
"0.62865585",
"0.62400687",
"0.6119562",
"0.6101358",
"0.60667795",
"0.60572",
"0.60372555",
"0.5987229",
"0.5970992",
"0.5851879",
"0.5771597",
"0.5759905",
"0.5714097",
"0.56890684",
"0.56627226",
"0.553553... | 0.56895006 | 18 |
Slightly different logic than connection to multiple Redis servers. Reserve only one write and read descriptors, as they will be closed on exit anyway. | def __init__(self, server, params, backend):
super(SentinelClient, self).__init__(server, params, backend)
self._client_write = None
self._client_read = None
self._connection_string = server | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run():\n\n # Channel for server 1\n channel1 = grpc.insecure_channel('localhost:50050')\n # Channel for server 2\n channel2 = grpc.insecure_channel('localhost:50051')\n\n # Try connecting to server 1\n try:\n grpc.channel_ready_future(channel1).result(timeout=10)\n except grpc.FutureTimeoutError:\n ... | [
"0.5756547",
"0.5705014",
"0.56609225",
"0.56317014",
"0.56010807",
"0.5594784",
"0.5534754",
"0.5484524",
"0.5445007",
"0.5390398",
"0.5271254",
"0.5266093",
"0.5203367",
"0.5198337",
"0.51727325",
"0.51431376",
"0.51426405",
"0.5134598",
"0.5107338",
"0.5099761",
"0.5095901... | 0.0 | -1 |
Creates a redis connection with connection pool. | def connect(self, index=0, write=True):
master_name, sentinel_hosts, db = self.parse_connection_string(self._connection_string)
sentinel_timeout = self._options.get('SENTINEL_TIMEOUT', 1)
sentinel = Sentinel(sentinel_hosts, socket_timeout=sentinel_timeout)
if write:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_connection(self, params):\r\n return Redis(connection_pool=self.get_or_create_connection_pool(params))",
"def _get_conn(self):\n return redis.Redis(connection_pool=self.pool)",
"def redis_conn_pool(self) -> ConnectionPool:\n if self._redis_conn_pool is None:\n if self._c... | [
"0.816493",
"0.8086648",
"0.80148584",
"0.7929269",
"0.78915024",
"0.7698564",
"0.76977664",
"0.7661963",
"0.7301383",
"0.7234917",
"0.7058955",
"0.7024496",
"0.6995398",
"0.6990696",
"0.6944723",
"0.68580353",
"0.68409115",
"0.6773969",
"0.6773969",
"0.67109364",
"0.67108244... | 0.0 | -1 |
Closing old connections, as master may change in time of inactivity. | def close(self, **kwargs):
del(self._client_write)
del(self._client_read)
self._client_write = None
self._client_read = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def close_TCP_connections(self):\n if self.master_connection is not None:\n self.master_connection.end_connection()",
"def killconnections(self):\n for conn in self._connections:\n try:conn.close()\n except:pass\n self._connections=[]",
"def close_connectio... | [
"0.724613",
"0.71849734",
"0.70590407",
"0.70198625",
"0.68154216",
"0.6805143",
"0.67401",
"0.67300326",
"0.6710922",
"0.6699254",
"0.66523874",
"0.66515815",
"0.6563905",
"0.65553296",
"0.6547943",
"0.65115845",
"0.6450652",
"0.64278555",
"0.6373628",
"0.63606566",
"0.63296... | 0.0 | -1 |
Persist a value to the cache, and set an optional expiration time. | def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None, client=None, nx=False):
if client is None:
key = self.make_key(key, version=version)
client = self.get_server(key)
return super(ShardClient, self).set(key=key, value=value,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self, key, value, expires_in=None):\n raise NotImplementedError()",
"def set_cache(self, key, value):\n self.r.set(key, value)\n self.r.expire(key, time=1500)",
"def set(self, key, value, ttl=None):\n self._cache[key] = (value, self._clock() + (ttl or self.default_ttl))",
... | [
"0.760283",
"0.75839907",
"0.7389476",
"0.7343514",
"0.7335355",
"0.7321049",
"0.7248851",
"0.72112036",
"0.72053784",
"0.70779395",
"0.70533335",
"0.7046328",
"0.68926704",
"0.6892219",
"0.68712306",
"0.68530697",
"0.68502986",
"0.6814827",
"0.679815",
"0.6783913",
"0.677559... | 0.0 | -1 |
Set a bunch of values in the cache at once from a dict of key/value pairs. This is much more efficient than calling set() multiple times. If timeout is given, that timeout will be used for the key; otherwise the default cache timeout will be used. | def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None):
for key, value in data.items():
self.set(key, value, timeout, version=version) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_many(self, data, timeout=None):\n try:\n safe_data = {}\n for key, value in data.iteritems():\n safe_data[self.prepare_key(key)] = pickle.dumps(value)\n if safe_data:\n self._cache.mset(safe_data)\n map(self.expire, safe_d... | [
"0.7050163",
"0.65413386",
"0.651945",
"0.6352375",
"0.62874395",
"0.62409884",
"0.6121251",
"0.61032474",
"0.6068264",
"0.6058403",
"0.6038714",
"0.59884614",
"0.59725994",
"0.58536285",
"0.5773165",
"0.5760298",
"0.5715581",
"0.5691752",
"0.56912005",
"0.5664539",
"0.553672... | 0.65285224 | 2 |
Test if key exists. | def has_key(self, key, version=None, client=None):
if client is None:
key = self.make_key(key, version=version)
client = self.get_server(key)
key = self.make_key(key, version=version)
try:
return client.exists(key)
except ConnectionError:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exists(self, key_name: str) -> bool:\n pass",
"def key_exists(dictionary, key):\n\n exists = dictionary.get(key, None)\n return exists is not None",
"def has(self, key):",
"def has(self, key):\n return False",
"def containsKey(self, key):\n return get(key) != None",
"def ha... | [
"0.8538106",
"0.8020361",
"0.79491585",
"0.7948841",
"0.7855513",
"0.7791192",
"0.77758735",
"0.77736175",
"0.7767599",
"0.77593726",
"0.7699159",
"0.7668944",
"0.7656245",
"0.76534593",
"0.7638008",
"0.7625921",
"0.7601507",
"0.7591905",
"0.7566847",
"0.7560203",
"0.74866575... | 0.6787201 | 79 |
Remove multiple keys at once. | def delete_many(self, keys, version=None):
res = 0
for key in [self.make_key(k, version=version) for k in keys]:
client = self.get_server(key)
res += self.delete(key, client=client)
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_many(self, keys):\n raise NotImplementedError()",
"def delete_many(self, keys):\n return self.delete_many_values(keys)",
"def delete_many(self, keys):\n try:\n if keys:\n self._cache.delete(*map(self.prepare_key, keys))\n except Exception as err:... | [
"0.78181726",
"0.7613702",
"0.7566873",
"0.7248788",
"0.7222351",
"0.70959216",
"0.7048892",
"0.6990814",
"0.6990814",
"0.6990814",
"0.69779724",
"0.6886202",
"0.68539685",
"0.6840806",
"0.68096286",
"0.6636776",
"0.6628584",
"0.66031945",
"0.65741676",
"0.65718824",
"0.65697... | 0.6672314 | 15 |
Remove all keys matching pattern. | def delete_pattern(self, pattern, version=None):
pattern = self.make_key(pattern, version=version)
keys = []
for server, connection in self._serverdict.items():
keys.extend(connection.keys(pattern))
res = 0
if keys:
for server, connection in s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_keys_script(key_pattern):\n return \"\"\"\n local curkey = redis.call('keys', '%(key_pattern)s')\n if next(curkey) then\n redis.call('del', unpack(curkey))\n end\n \"\"\" % dict(key_pattern = key_pattern)",
"def removeAllKeys(self) -> None:\n ...",
"def ... | [
"0.71254295",
"0.7120807",
"0.6908498",
"0.68388987",
"0.62851423",
"0.62675834",
"0.6172457",
"0.6128228",
"0.6118215",
"0.607907",
"0.6034034",
"0.6033035",
"0.6014922",
"0.59763515",
"0.596867",
"0.5966957",
"0.59499526",
"0.5918134",
"0.59159",
"0.58328205",
"0.5824407",
... | 0.60441214 | 10 |
Given a main connection parameters, build a complete dict of connection parameters. | def make_connection_params(self, host, port, db):
kwargs = {
"db": db,
"parser_class": self.get_parser_cls(),
"password": self.options.get('PASSWORD', None),
}
if host == "unix":
kwargs.update({'path': port, 'connection_class': UnixDomai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_conn_params(self) -> dict[str, Any]:\n conn = self.get_connection(self.slack_conn_id)\n if not conn.password:\n raise AirflowNotFoundException(\n f\"Connection ID {self.slack_conn_id!r} does not contain password (Slack API Token).\"\n )\n conn_para... | [
"0.6778545",
"0.6718613",
"0.66834867",
"0.6634806",
"0.6489588",
"0.63820136",
"0.62357676",
"0.6113212",
"0.6085891",
"0.6050217",
"0.6034028",
"0.60113174",
"0.5992468",
"0.5983846",
"0.59766847",
"0.59404546",
"0.5936679",
"0.5914405",
"0.58865356",
"0.57984245",
"0.57612... | 0.60750484 | 9 |
Given a basic connection parameters, return a new connection. | def connect(self, host, port, db):
params = self.make_connection_params(host, port, db)
return self.get_connection(params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_new_connection(self, conn_params):\r\n self.__connection_string = conn_params.get('connection_string', '')\r\n conn = Database.connect(**conn_params)\r\n return conn",
"def establish_connection(self):\n conninfo = self.client\n for name, default_value in items(self.defa... | [
"0.76189566",
"0.75521696",
"0.70348966",
"0.6959789",
"0.6826062",
"0.68241984",
"0.67967474",
"0.67898035",
"0.6777832",
"0.6749526",
"0.6713498",
"0.6677202",
"0.6601608",
"0.6575085",
"0.6556423",
"0.65309495",
"0.650741",
"0.64950335",
"0.64948314",
"0.64918983",
"0.6474... | 0.61695904 | 48 |
Given a now preformated params, return a new connection. The default implementation uses a cached pools for create new connection. | def get_connection(self, params):
return Redis(connection_pool=self.get_or_create_connection_pool(params)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_new_connection(self, conn_params):\r\n self.__connection_string = conn_params.get('connection_string', '')\r\n conn = Database.connect(**conn_params)\r\n return conn",
"def get_or_create_connection_pool(self, params):\r\n key = frozenset((k, repr(v)) for (k, v) in params.items... | [
"0.76215917",
"0.7489781",
"0.73058176",
"0.7165421",
"0.7008004",
"0.65971446",
"0.6503326",
"0.6394611",
"0.6264323",
"0.62370783",
"0.6193519",
"0.61733115",
"0.6165344",
"0.6136383",
"0.61237514",
"0.61154366",
"0.60612833",
"0.60064197",
"0.5986906",
"0.598591",
"0.59634... | 0.71042955 | 4 |
Given a connection parameters and return a new or cached connection pool for them. Reimplement this method if you want distinct connection pool instance caching behavior. | def get_or_create_connection_pool(self, params):
key = frozenset((k, repr(v)) for (k, v) in params.items())
if key not in self._pools:
self._pools[key] = self.get_connection_pool(params)
return self._pools[key] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_connection_pool(self, params):\r\n cp_params = dict(params)\r\n cp_params.update(self.pool_cls_kwargs)\r\n return self.pool_cls(**cp_params)",
"def get_connection(self, params):\r\n return Redis(connection_pool=self.get_or_create_connection_pool(params))",
"def build_connect... | [
"0.7633331",
"0.7093984",
"0.704607",
"0.70299256",
"0.7016528",
"0.6718907",
"0.66587025",
"0.66581637",
"0.66004694",
"0.6494415",
"0.6447045",
"0.641799",
"0.63243353",
"0.6310433",
"0.63036764",
"0.6295449",
"0.6271186",
"0.6250118",
"0.61557645",
"0.61037254",
"0.6043522... | 0.7563619 | 1 |
Given a connection parameters, return a new connection pool for them. Overwrite this method if you want a custom behavior on creating connection pool. | def get_connection_pool(self, params):
cp_params = dict(params)
cp_params.update(self.pool_cls_kwargs)
return self.pool_cls(**cp_params) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_or_create_connection_pool(self, params):\r\n key = frozenset((k, repr(v)) for (k, v) in params.items())\r\n if key not in self._pools:\r\n self._pools[key] = self.get_connection_pool(params)\r\n return self._pools[key]",
"def build_connection_pool(conn_details: dict):\n\n ... | [
"0.7737848",
"0.7455023",
"0.7187452",
"0.70865107",
"0.6992813",
"0.69039977",
"0.684276",
"0.672731",
"0.66503847",
"0.6621734",
"0.659866",
"0.6564659",
"0.6443048",
"0.6405981",
"0.63895524",
"0.6246814",
"0.62264544",
"0.615156",
"0.6043402",
"0.6006722",
"0.6000867",
... | 0.79732764 | 0 |
Load class from path. | def load_class(path):
mod_name, klass_name = path.rsplit('.', 1)
try:
mod = import_module(mod_name)
except AttributeError as e:
raise ImproperlyConfigured('Error importing {0}: "{1}"'.format(mod_name, e))
try:
klass = getattr(mod, klass_name)
except AttributeErr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(path):\n pass",
"def import_class(path):\n components = path.split(\".\")\n module = components[:-1]\n module = \".\".join(module)\n # __import__ needs a native str() on py2\n mod = __import__(module, fromlist=[str(components[-1])])\n return getattr(mod, str(components[-1]))",
... | [
"0.7547932",
"0.74888587",
"0.7334474",
"0.7334474",
"0.72811824",
"0.7205953",
"0.71651363",
"0.7003949",
"0.69815",
"0.6721728",
"0.67175806",
"0.6711963",
"0.66392964",
"0.6612859",
"0.66105014",
"0.6606692",
"0.66007376",
"0.6546381",
"0.6542882",
"0.6378108",
"0.6363662"... | 0.745131 | 2 |
Tests calculating confusion matrix per subpopulation. Tests | def test_confusion_matrix_per_subgroup():
mx1 = np.array([[2, 1, 0], [0, 0, 0], [0, 0, 0]])
mx2 = np.array([[2, 0, 0], [0, 0, 0], [0, 2, 1]])
mx3 = np.array([[2, 0, 1], [0, 2, 0], [1, 0, 1]])
with pytest.warns(UserWarning) as w:
pcmxs, bin_names = fumt.confusion_matrix_per_subgroup(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_classifications(self):\n test_labels = open('./digitdata/testlabels', 'r')\n self.init_confusion_matrix()\n i = 0\n class_stats = {0:[0,0], 1:[0,0], 2:[0,0], 3:[0,0], 4:[0,0], 5:[0,0], 6:[0,0], 7:[0,0], 8:[0,0], 9:[0,0]}\n total_correct = 0\n num_labels = 1000... | [
"0.6618988",
"0.66012615",
"0.65771365",
"0.64746296",
"0.6443359",
"0.6311446",
"0.62488693",
"0.6220614",
"0.6143405",
"0.6113498",
"0.60880667",
"0.60832113",
"0.6033341",
"0.6021256",
"0.6018865",
"0.59884655",
"0.59654135",
"0.59608114",
"0.59072",
"0.5879316",
"0.582956... | 0.68114936 | 0 |
Tests calculating confusion matrix per indexbased subpopulation. Tests | def test_confusion_matrix_per_subgroup_indexed():
incorrect_shape_error_gt = ('The ground_truth parameter should be a '
'1-dimensional numpy array.')
incorrect_shape_error_p = ('The predictions parameter should be a '
'1-dimensional numpy array.')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_confusion_matrix_per_subgroup():\n\n mx1 = np.array([[2, 1, 0], [0, 0, 0], [0, 0, 0]])\n mx2 = np.array([[2, 0, 0], [0, 0, 0], [0, 2, 1]])\n mx3 = np.array([[2, 0, 1], [0, 2, 0], [1, 0, 1]])\n\n with pytest.warns(UserWarning) as w:\n pcmxs, bin_names = fumt.confusion_matrix_per_subgroup... | [
"0.66565275",
"0.62798464",
"0.62386554",
"0.6203715",
"0.61975443",
"0.6048215",
"0.5992596",
"0.59676194",
"0.58624643",
"0.5859458",
"0.58580637",
"0.58289576",
"0.58109146",
"0.5807874",
"0.5788835",
"0.5787484",
"0.57719433",
"0.5745471",
"0.5728884",
"0.572269",
"0.5708... | 0.6355921 | 1 |
BEWARE DIRTY HACK IN COORDINATE FLIPPING!!!! | def wrench_stamped_cb(self, ws):
force_vec = np.array([ws.wrench.force.x, ws.wrench.force.y, ws.wrench.force.z])
scaled_vec = np.multiply(force_vec, self.scaling)
mag = np.linalg.norm(force_vec)
normalized_vec = np.divide(force_vec,mag)
ta = TaxelArray()
ta.header.fr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetLoCorner(self):\n ...",
"def footprint_corner_indices():",
"def degibber(self):",
"def test_coord_preceding_fs(self):",
"def solvate(self):\n\n pass",
"def _update_farness_map(self,ind):",
"def GetFlippedPoints2(paths,blankarray):\n #this may not work for double ups?\n for i ... | [
"0.59002066",
"0.56784844",
"0.56707025",
"0.5661258",
"0.5572482",
"0.55679095",
"0.5510954",
"0.5503216",
"0.55014324",
"0.54342633",
"0.5431841",
"0.5417132",
"0.5391007",
"0.5321995",
"0.53189087",
"0.53001356",
"0.5299283",
"0.52908045",
"0.5242194",
"0.5197884",
"0.5188... | 0.0 | -1 |
Print a result / processing summary. | def printSummary(result):
inputCount = result['inputCount']
print('Kept %d of %d (%.2f%%) candidate substring%s seen on input.' %
(len(result['substrings']), inputCount,
len(result['substrings']) / inputCount * 100.0,
'' if inputCount == 1 else 's'), file=sys.stderr)
notEnou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_results(summary):\n print ('Total running time %.2f secs (includes DB checks)'\n % summary.total_time)\n\n print 'OK:', summary.ok\n print 'Errors:', summary.errors\n\n # Display stats\n print 'Changes stats:'\n for var, s in summary.stats.iteritems():\n print '\\t%s:... | [
"0.76587313",
"0.76228726",
"0.7593415",
"0.7478287",
"0.7439275",
"0.73064995",
"0.73064995",
"0.72284836",
"0.71081173",
"0.7048422",
"0.7037371",
"0.6983675",
"0.6979697",
"0.69744676",
"0.6973929",
"0.6933947",
"0.6898518",
"0.6890774",
"0.6888606",
"0.68714935",
"0.68520... | 0.64669585 | 46 |
Returns the number of prizes that will be awarded for this prize. | def num_awarded(self, floor=None):
if self.award_to in ("individual_overall", "floor_overall", "dorm"):
# For overall prizes, it is only possible to award one.
return 1
elif self.award_to in ("floor_dorm", "individual_dorm"):
# For dorm prizes, this is just the number of dorms.
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_pickets(self) -> int:\n return len(self.pickets)",
"def get_num_petals(self):\n return self._num_petals",
"def psizes(self):\n return self._cache.psizes",
"def num_votes(self):\n return sum(self.votes_per_count)",
"def size(self) -> int:\n\n return self.sizes.sum(... | [
"0.65297043",
"0.6438432",
"0.638483",
"0.625789",
"0.61884695",
"0.6187963",
"0.6182225",
"0.6173951",
"0.6150105",
"0.612123",
"0.61027765",
"0.6080633",
"0.6056884",
"0.60247165",
"0.601722",
"0.60013944",
"0.5973453",
"0.5966288",
"0.5964273",
"0.5963277",
"0.59582824",
... | 0.6676239 | 0 |
Adds a ticket from the user if they have one. Throws an exception if they cannot add a ticket. | def add_ticket(self, user):
profile = user.get_profile()
if profile.available_tickets() <= 0:
raise Exception("This user does not have any tickets to allocate.")
ticket = RaffleTicket(raffle_prize=self, user=user)
ticket.save() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def ticket_add(self, ctx, user: discord.Member):\n guild_settings = await self.config.guild(ctx.guild).all()\n is_admin = await is_admin_or_superior(self.bot, ctx.author) or any(\n [ur.id in guild_settings[\"supportroles\"] for ur in ctx.author.roles]\n )\n must_be_admi... | [
"0.75067663",
"0.65820646",
"0.6444056",
"0.64260346",
"0.6213124",
"0.61979747",
"0.6157786",
"0.60477424",
"0.59763026",
"0.59427506",
"0.58696246",
"0.5796449",
"0.5795518",
"0.579028",
"0.576608",
"0.5748269",
"0.56843877",
"0.56670624",
"0.5599975",
"0.5599003",
"0.55944... | 0.7707899 | 0 |
Removes an allocated ticket. | def remove_ticket(self, user):
# Get the first ticket that matches the query.
ticket = RaffleTicket.objects.filter(raffle_prize=self, user=user)[0]
ticket.delete() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ticket_deleted(self, ticket):\n if 'ticket' not in self.sources:\n return\n gnp = GrowlNotificationPacket(notification='ticket',\n title='Ticket #%d deleted' % ticket.id,\n description=self._ticket_repr(ticket))\... | [
"0.6529886",
"0.62774307",
"0.6127702",
"0.6008233",
"0.59739345",
"0.5789608",
"0.57860637",
"0.57634157",
"0.57043296",
"0.54994345",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
"0.53857934",
... | 0.64663655 | 1 |
Returns the number of tickets allocated to this prize. Takes an optional argument to return the number of tickets allocated by the user. | def allocated_tickets(self, user=None):
query = self.raffleticket_set.filter(raffle_prize=self)
if user:
query = query.filter(user=user)
return query.count() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_assigned(self):\n return FlicketTicket.query.filter_by(assigned=self.user).count()",
"def num_pickets(self) -> int:\n return len(self.pickets)",
"def num_attendees(self):\r\n n = sum([c.qty for c in self.contribution_set.all()])\r\n return n",
"def num_allocated_resources(... | [
"0.6878064",
"0.62725556",
"0.60077244",
"0.5967526",
"0.59303814",
"0.587535",
"0.5703093",
"0.5699997",
"0.5674289",
"0.56504005",
"0.56465405",
"0.5644256",
"0.5603991",
"0.5569141",
"0.5529344",
"0.55266505",
"0.55215555",
"0.5503645",
"0.54946893",
"0.54946893",
"0.54825... | 0.7432309 | 0 |
Compute the transport plan P in regularization path for any given value of lambda | def compute_transport_plan(lam, lambda_list, Pi_list):
if lam <= lambda_list[0]:
Pi_inter = np.zeros(np.shape(Pi_list[-1]))
elif lam >= lambda_list[-1]:
Pi_inter = Pi_list[-1].toarray()
else:
idx = np.where(lambda_list < lam)[0][-1]
lam_k = lambda_list[idx]
lam_k1 = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_PRP(initial):\n return plan_route((initial[0],initial[1]), initial[2],\n # Goals:\n [(2,3),(3,2)],\n # Allowed locations:\n [(0,0),(0,1),(0,2),(0,3),\n (1,0),(1,1),(1,2),(1,3),\n ... | [
"0.5900887",
"0.58707184",
"0.57448065",
"0.56907046",
"0.5612557",
"0.56111515",
"0.5553134",
"0.5529714",
"0.55141824",
"0.54726917",
"0.5471628",
"0.54607534",
"0.54519314",
"0.5421288",
"0.5413783",
"0.5371945",
"0.5369936",
"0.5324903",
"0.5300132",
"0.52990323",
"0.5296... | 0.70644534 | 0 |
Function of regularized path for l2panalized UOT | def ot_ul2_reg_path(a: np.array, b: np.array, C: np.array, lambdamax=np.inf, savePi=False, itmax=50000, save_AT_length=False):
n = np.shape(a)[0]
m = np.shape(b)[0]
ones_n = np.ones((n,))
ones_m = np.ones((m,))
n_iter = 0
lambda_list = []
Pi_list = []
active_index_i = []
active_in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_path2():\n path = [ (np.pi/10, 0.3, 1)] * 20\n execute_path(path, True)",
"def constructShortestPath(self):",
"def test_path7():\n path = [(0, 0, 1)]\n path += [\n [('A', 3, 0)],\n (0, 1, 1),\n [('A', 2, 0)],\n (np.pi/2, 1, 1),\n [('B',3,0)],\n (0, 1, 1),\n [('B',2,0)],\n (... | [
"0.5639856",
"0.56145984",
"0.5576992",
"0.55674124",
"0.54332876",
"0.5414987",
"0.53547007",
"0.53476965",
"0.53245836",
"0.5295886",
"0.5274415",
"0.5268144",
"0.5239604",
"0.52213246",
"0.5107726",
"0.509267",
"0.5091212",
"0.5058955",
"0.50285155",
"0.50141966",
"0.49931... | 0.48698047 | 34 |
BFGS algorithm for l2penalized UOT | def ot_ul2_solve_BFGS(C, a, b, reg, maxiter=100000, tol=1e-14):
# define objective function f
def f(G):
G = G.reshape((a.shape[0], b.shape[0]))
return np.sum(G * C) + reg * np.sum((G.sum(1) - a) ** 2) + reg * np.sum((G.sum(0) - b) ** 2)
# define the gradient of f
def df(G):
G =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epsilon_fit_Chang_homemade(l_onde,vl1,vl2,vt1,vt2,gl1,gl2,gt1,gt2,f_t1,f_t2,f_l1,f_l2,epsinf1,epsinf2):\n # Chang PRB38 12369\n v = 1e4/l_onde\n \n epsx = (epsinf1+epsinf2)/2 - (f_l1*(vl1**2 - vt1**2))/(-vt1**2 + v**2 + 1j*v*gt1) - (f_l2*(vl2**2 - vt2**2))/(-vt2**2 + v**2 + 1j*v*gt2)\n eps... | [
"0.6178091",
"0.6163994",
"0.6161734",
"0.61285937",
"0.6091864",
"0.6065697",
"0.6045943",
"0.6042955",
"0.6023794",
"0.60228187",
"0.59937096",
"0.5975979",
"0.59758705",
"0.59608454",
"0.59554476",
"0.5945483",
"0.59318066",
"0.5918379",
"0.5907455",
"0.5906748",
"0.589358... | 0.0 | -1 |
Construction of design matrix H | def get_X_lasso(n, m):
jHa = np.arange(m * n)
iHa = np.repeat(np.arange(n), m)
jHb = np.arange(m * n)
iHb = np.tile(np.arange(m), n) + n
j = np.concatenate((jHa, jHb))
i = np.concatenate((iHa, iHb))
H = sp.csc_matrix((np.ones(n * m * 2), (i, j)), shape=(n+m, n*m))
return H | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def H(self) -> BaseMatrix:",
"def H(self) -> BaseMatrix:",
"def create_design_matrix(self):\n self.design_matrix = np.zeros([self.n, self.p])\n self.design_matrix[:,0] = 1.0 #First comlum is 1 (bias term)\n\n for i in range(self.n):\n fo... | [
"0.7562958",
"0.7562958",
"0.68509895",
"0.6653759",
"0.65847844",
"0.6574229",
"0.64227295",
"0.6341365",
"0.62836915",
"0.6248243",
"0.617559",
"0.61622995",
"0.6127728",
"0.608536",
"0.608536",
"0.60789907",
"0.60694474",
"0.604963",
"0.6047809",
"0.6045653",
"0.5936148",
... | 0.0 | -1 |
Celer algorithm for lassoformulated l2penalized UOT | def ot_ul2_solve_lasso_celer(C, a, b, reg, nitermax=100000, tol=1e-14):
X = get_X_lasso(C.shape[0], C.shape[1])
y = np.concatenate((a, b))
reg2 = 1.0 / (2 * (C.shape[0] + C.shape[1]) * reg)
model = celer.Lasso(reg2, max_iter=nitermax, weights=C.ravel(), positive=True, fit_intercept=False, tol=tol)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lherzolite():\n\n rho = 3270.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 187.4; C[0,1] = 63.71; C[0,2] = 63.87; C[0,3] = 0.78; C[0,4] = 2.02; C[0,5] = -3.2\n C[1,0] = C[0,1]; C[1,1] = 211.25; C[1,2] = 64.5; C[1,3] = -3.07; C[1,4] = 0.87; C[1,5] = -5.78... | [
"0.59114254",
"0.5880291",
"0.5843534",
"0.5838584",
"0.58302855",
"0.5817063",
"0.5756946",
"0.5756367",
"0.57547534",
"0.5744916",
"0.5710205",
"0.57045275",
"0.56486785",
"0.5626035",
"0.56195045",
"0.5611582",
"0.55996555",
"0.5590846",
"0.55713654",
"0.5568172",
"0.55511... | 0.0 | -1 |
Coordinate descent algorithm for lassoformulated l2penalized UOT | def ot_ul2_solve_lasso_cd(C, a, b, reg, nitermax=100000, tol=1e-14):
X = get_X_lasso(C.shape[0], C.shape[1])
X = X.dot(sp.diags((1 / C.ravel())))
y = np.concatenate((a, b))
reg2 = 1.0 / (2 * (C.shape[0] + C.shape[1]) * reg)
model = Lasso(reg2, positive=True, fit_intercept=False, max_iter=nitermax, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def method2(self):\n cres=np.zeros(self.NL,dtype=float) # List of invariants\n # The U matrices from Fukui's method; storage...\n Ux_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n Uy_loc=np.zeros((self.kS.Nx+1,self.kS.Ny+1),dtype=complex)\n \n for il in range... | [
"0.5958752",
"0.5712532",
"0.56944275",
"0.56809044",
"0.5679663",
"0.5633035",
"0.5623024",
"0.5588956",
"0.55861765",
"0.55407983",
"0.5530264",
"0.55237794",
"0.552077",
"0.55181515",
"0.5517798",
"0.5506699",
"0.55033195",
"0.55033195",
"0.5500844",
"0.5489448",
"0.548216... | 0.0 | -1 |
MajorizationMinimization algorithm for l2penalized UOT | def ot_ul2_solve_mu(C, a, b, reg, nitermax=100000, tol=1e-14, P0=None, verbose=False):
if P0 is None:
P = a[:, None] * b[None, :]
else:
P = P0
abt = np.maximum(a[:, None] + b[None, :] - C / (2 * reg), 0)
for i in range(nitermax):
Pold = P.copy()
P = P * abt / (P.sum(0, k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1(P, q):\n\n m, n = P.size\n\n # Solve equivalent LP \n #\n # minimize [0; 1]' * [u; v]\n # subject to [P, -I; -P, -I] * [u; v] <= [q; -q]\n #\n # maximize -[q; -q]' * z \n # subject to [P', -P']*z = 0\n # [-I, -I]*z + 1 = 0 \n # ... | [
"0.60062426",
"0.60009205",
"0.5966422",
"0.5898558",
"0.58854496",
"0.58482015",
"0.5734522",
"0.56935805",
"0.5605645",
"0.5604729",
"0.55998397",
"0.55965626",
"0.55877346",
"0.5570163",
"0.5558406",
"0.5549005",
"0.554849",
"0.5545878",
"0.5530043",
"0.551141",
"0.5501329... | 0.0 | -1 |
Updates a single entity. Implementers should return a tuple containing two iterables (to_update, to_delete). | def map(self, entity):
return ([], []) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entityUpdates(self, *args):\n\t\tfor entity in self.members.values():\n\t\t\tentity.update(*args)",
"def update_entities(self):\n raise NotImplementedError()",
"def update_many(\n self,\n *args: Union[dict, Mapping],\n session: Optional[ClientSession] = None\n ) -> UpdateMany... | [
"0.63851154",
"0.621751",
"0.61388403",
"0.6048954",
"0.60383564",
"0.59614515",
"0.5907158",
"0.5735908",
"0.5735908",
"0.5735908",
"0.5729625",
"0.570714",
"0.57034546",
"0.56934524",
"0.5678083",
"0.5675096",
"0.5666016",
"0.5653511",
"0.5618034",
"0.56139493",
"0.55728024... | 0.0 | -1 |
Called when the mapper has finished, to allow for any final work to be done. | def finish(self):
logging.info(str(self) + ' Mapper finished.')
if self.next_mapper is not None:
logging.info(str(self) + ' Next: ' + str(self.next_mapper))
self.next_mapper.run()
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finished(self):\n pass",
"def _finished(self) -> None:",
"def finish(self):\n pass",
"def finish(self):\n pass",
"def finished(self):\n raise NotImplementedError()",
"def finished(self):\r\n raise NotImplementedError",
"def finished(self):",
"def finish(self):\r... | [
"0.6983338",
"0.67524016",
"0.6732718",
"0.6732718",
"0.6725664",
"0.6718488",
"0.6698824",
"0.6674772",
"0.6650086",
"0.65816665",
"0.65816665",
"0.6573483",
"0.6461058",
"0.6453406",
"0.6439004",
"0.6439004",
"0.6388175",
"0.63703626",
"0.6352022",
"0.63432056",
"0.6340175"... | 0.8608334 | 0 |
Returns a query over the specified kind, with any appropriate filters applied. | def get_query(self):
q = db.Query(self.KIND,keys_only=self.KEYS_ONLY)
for prop, value in self.FILTERS:
q.filter("%s =" % prop, value)
if self.ancestor:
q.ancestor(self.ancestor)
q.order(self.ORDER_BY)
return q | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_query(kind):\n days = 4\n now = datetime.datetime.now()\n earlier = now - datetime.timedelta(days=days)\n\n query = query_pb2.Query()\n query.kind.add().name = kind\n\n datastore_helper.set_property_filter(query.filter, 'created_at',\n PropertyFilter.GREATER_THA... | [
"0.74351525",
"0.65386915",
"0.6099638",
"0.6088493",
"0.60041225",
"0.5947028",
"0.5898798",
"0.5851256",
"0.5801757",
"0.5797533",
"0.5785968",
"0.57396966",
"0.57052547",
"0.5698724",
"0.56677943",
"0.5620565",
"0.55979",
"0.5590759",
"0.558977",
"0.5579419",
"0.55156595",... | 0.60751003 | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.